Index: apimod.scm
==================================================================
--- apimod.scm
+++ apimod.scm
@@ -200,10 +200,12 @@
     ;; SERVERS
     ;; ((start-server)                    (apply server:kind-run params))
     ((kill-server)                       (set! *server-run* #f))
     ((get-server)                        (api:start-server dbstruct params))
     ((register-server)                   (apply db:register-server dbstruct params) );; dbstruct host port servkey pid ipaddr dbpath)
+    ((deregister-server)                 (apply db:deregister-server dbstruct params) );; dbstruct host port servkey pid ipaddr dbpath)
+    ((get-count-servers)                 (apply db:get-count-servers dbstruct params))
 
     ;; TESTS
 
     ;;((test-set-state-status-by-id)     (apply mt:test-set-state-status-by-id dbstruct params))
     ;;BB - commented out above because it was calling below, eventually, incorrectly (dbstruct passed to mt:test-set-state-status-by-id, which previosly did more, but now only passes thru to db:set-state-status-and-roll-up-items.
@@ -229,10 +231,11 @@
     ((top-test-set-per-pf-counts)      (apply db:top-test-set-per-pf-counts dbstruct params))
     ((test-set-archive-block-id)       (apply db:test-set-archive-block-id dbstruct params))
 
     ;; RUNS
     ((register-run)                 (apply db:register-run dbstruct params))
+    ((insert-run)                   (apply db:insert-run dbstruct params))
     ((set-tests-state-status)       (apply db:set-tests-state-status dbstruct params))
     ((delete-run)                   (apply db:delete-run dbstruct params))
     ((lock/unlock-run)              (apply db:lock/unlock-run dbstruct params))
     ((update-run-event_time)        (apply db:update-run-event_time dbstruct params))
     ((update-run-stats)             (apply db:update-run-stats dbstruct params))

Index: commonmod.scm
==================================================================
--- commonmod.scm
+++ commonmod.scm
@@ -228,17 +228,15 @@
 (define *heartbeat-mutex*   (make-mutex))
 (define *api-process-request-count* 0)
 (define *max-api-process-requests* 0)
 (define *server-overloaded*  #f)
 (define *writes-total-delay*  0)
+(define *unclean-shutdown*  #t) ;; flag to clear on clean shutdown
 
 ;; client
 (define *rmt-mutex*         (make-mutex))     ;; remote access calls mutex 
 
-;; RPC transport
-(define *rpc:listener*      #f)
-
 ;; KEY info
 ;; (define *target*            (make-hash-table)) ;; cache the target here; target is keyval1/keyval2/.../keyvalN
 (define *keys*              (make-hash-table)) ;; cache the keys here
 (define *keyvals*           (make-hash-table))
 (define *toptest-paths*     (make-hash-table)) ;; cache toptest path settings here
@@ -3649,11 +3647,11 @@
 (define (server:expiration-timeout)
   (let ((tmo (configf:lookup *configdat* "server" "timeout")))
     (if (and (string? tmo)
 	     (common:hms-string->seconds tmo)) ;; BUG: hms-string->seconds is broken, if given "10" returns 0. Also, it doesn't belong in this logic unless the string->number is changed below
         (* 3600 (string->number tmo))
-	600))) ;; default is ten minutes
+	60))) ;; default is one minute
 
 (define (runs:get-mt-env-alist run-id runname target testname itempath)
   ;;(bb-check-path msg: "runs:set-megatest-env-vars entry")
   `(("MT_TEST_NAME"     . ,testname)
     

Index: configfmod.scm
==================================================================
--- configfmod.scm
+++ configfmod.scm
@@ -35,10 +35,11 @@
 	chicken.pathname
 	chicken.port
 	chicken.pretty-print
 	chicken.process
 	chicken.process-context
+	chicken.process-context.posix
 	chicken.sort
 	chicken.string
 	chicken.time
 	chicken.eval
 	
@@ -969,10 +970,12 @@
 		     (result  #f)
 		     (start-time (current-seconds))
 		     (cmdsym  (string->symbol cmdtype))
 		     (fullcmd
 		      (conc  configf:std-imports
+			     "(import chicken.process-context.posix)"
+			     "(define setenv set-environment-variable)"
 			     (case cmdsym
 			       ((scheme scm) (conc "(lambda (ht)" cmd ")"))
 			       ((system)     (conc "(lambda (ht)(configf:system ht \"" cmd "\"))"))
 			       ((shell sh)   (conc "(lambda (ht)(string-translate (shell \""  cmd "\") \"\n\" \" \"))"))
 			       ((realpath rp)(conc "(lambda (ht)(common:nice-path \"" cmd "\"))"))

Index: dbmod.scm
==================================================================
--- dbmod.scm
+++ dbmod.scm
@@ -180,19 +180,33 @@
 ;; assemble into dbr:dbdat struct and return
 ;; 
 (define (db:open-dbdat apath dbfile dbinit-proc)
   (let* (;; (dbfile   (db:run-id->path apath run-id))
 	 (db       (db:open-run-db dbfile dbinit-proc))
-	 (inmem    (db:open-inmem-db dbinit-proc))
+	 ;; (inmem    (db:open-inmem-db dbinit-proc))
 	 (dbdat    (make-dbr:dbdat
-		    db:     db
-		    inmem:  inmem
+		    db:     #f ;; db
+		    inmem:  db ;; inmem
 		    ;; run-id: run-id  ;; no can do, there are many run-id values that point to single db
 		    fname:  dbfile)))
     ;; now sync the disk file data into the inmemory db
-    (db:sync-tables (db:sync-all-tables-list) #f db inmem)
+    ;; (db:sync-tables (db:sync-all-tables-list) '("last_update" . 0) db inmem)
+    ;; (sqlite3:finalize! db) ;; open and close every sync
     dbdat))
+;; (define (db:open-dbdat apath dbfile dbinit-proc)
+;;   (let* (;; (dbfile   (db:run-id->path apath run-id))
+;; 	 (db       (db:open-run-db dbfile dbinit-proc))
+;; 	 (inmem    (db:open-inmem-db dbinit-proc))
+;; 	 (dbdat    (make-dbr:dbdat
+;; 		    db:     #f ;; db
+;; 		    inmem:  inmem
+;; 		    ;; run-id: run-id  ;; no can do, there are many run-id values that point to single db
+;; 		    fname:  dbfile)))
+;;     ;; now sync the disk file data into the inmemory db
+;;     (db:sync-tables (db:sync-all-tables-list) '("last_update" . 0) db inmem)
+;;     (sqlite3:finalize! db) ;; open and close every sync
+;;     dbdat))
 
 ;; open the disk database file
 ;; NOTE: May need to add locking to file create process here
 ;; returns an sqlite3 database handle
 ;;
@@ -202,11 +216,11 @@
 	(create-directory parent-dir #t))
     (let* ((exists  (file-exists? dbfile))
 	   (db      (sqlite3:open-database dbfile))
 	   (handler (sqlite3:make-busy-timeout 3600)))
       (sqlite3:set-busy-handler! db handler)
-      (db:set-sync db)
+      ;; (db:set-sync db) ;; we don't mind that this is slow?
       (if (not exists)
 	  (dbinit-proc db))
       db)))
     
 ;; open and initialize the inmem db
@@ -216,10 +230,25 @@
   (let* ((db      (sqlite3:open-database ":memory:"))
 	 (handler (sqlite3:make-busy-timeout 3600)))
     (sqlite3:set-busy-handler! db handler)
     (dbinit-proc db) ;; NOTE: inmem must always be initialized (db:initialize-db db)
     db))
+
+;; for debugging we have a local mode. these routines support that mode
+(define *dbcache* (make-hash-table))
+
+(define (db:cache-get-dbstruct rid apath)
+  (let* ((dbname (db:run-id->dbname rid))
+	 (dbfile (db:dbname->path apath dbname)))
+    (or (hash-table-ref/default *dbcache* dbfile #f)
+	(let* ((dbstruct (db:setup dbfile))) ;; (db:open-dbdat apath dbfile db:initialize-db)))
+	  (hash-table-set! *dbcache* dbfile dbstruct)
+	  dbstruct))))
+
+(define (db:finalize-all-cache-dbstruct)
+  #f)
+	  
 
 ;; get and initalize dbstruct for a given run-id
 ;;
 ;;  - uses db:initialize-db to create the schema
 ;;
@@ -226,14 +255,14 @@
 ;; Make the dbstruct, call for main db at least once
 ;; sync disk db to inmem
 ;;
 ;; called in http-transport and replicated in rmt.scm for *local* access. 
 ;;
-(define (db:setup run-id)
+(define (db:setup db-file) ;; run-id)
   (assert *toppath* "FATAL: db:setup called before toppath is available.")
   (let* ((dbstruct (or *dbstruct-db* (make-dbr:dbstruct)))
-	 (db-file  (db:run-id->path *toppath* run-id)))
+	 #;(db-file  (db:run-id->path *toppath* run-id)))
     (db:get-dbdat dbstruct *toppath* db-file)
     (if (not *dbstruct-db*)(set! *dbstruct-db* dbstruct))
     dbstruct))
 
 ;;======================================================================
@@ -252,11 +281,11 @@
 		  (db:get-iam-server-lock dbh dbfile))))
 
 (define (db:with-lock-db dbfile proc)
   (let* ((dbh (db:open-run-db dbfile db:initialize-db))
 	 (res (proc dbh dbfile)))
-    (sqlite3:finalize! dbh)
+    ;; (sqlite3:finalize! dbh)
     res))
 
 ;; called before db is open?
 ;;
 (define (db:get-iam-server-lock dbh dbfname)
@@ -415,29 +444,33 @@
 
 ;; NOTE: touched logic is disabled/not done
 ;; sync run to disk if touched
 ;;
 (define (db:sync-inmem->disk dbstruct apath dbfile #!key (force-sync #f))
-  (let* ((dbdat       (db:get-dbdat dbstruct apath dbfile))
-	 (db          (dbr:dbdat-db dbdat))
-	 (inmem       (dbr:dbdat-inmem dbdat))
-	 (start-t     (current-seconds))
-	 (last-update (dbr:dbdat-last-write dbdat))
-	 (last-sync   (dbr:dbdat-last-sync dbdat)))
-    (debug:print-info 4 *default-log-port* "Syncing for dbfile: " dbfile)
-    (mutex-lock! *db-multi-sync-mutex*)
-    (let* ((update_info (cons (if force-sync 0 last-update) "last_update"))
-    	   (need-sync   (or force-sync (>= last-update last-sync))))
-       (if need-sync
-	  (db:sync-tables (db:sync-all-tables-list) update_info inmem db)
-	  (debug:print 0 *default-log-port* "Skipping sync as nothing touched.")))
-    (dbr:dbdat-last-sync-set! dbdat start-t)
-    (mutex-unlock! *db-multi-sync-mutex*)))
+  #f) ;; disabled
+;;   (let* ((dbdat       (db:get-dbdat dbstruct apath dbfile))
+;; 	 (dbfullname  (conc apath "/" dbfile))
+;; 	 (db          (db:open-run-db dbfullname db:initialize-db)) ;; (dbr:dbdat-db dbdat))
+;; 	 (inmem       (dbr:dbdat-inmem dbdat))
+;; 	 (start-t     (current-seconds))
+;; 	 (last-update (dbr:dbdat-last-write dbdat))
+;; 	 (last-sync   (dbr:dbdat-last-sync dbdat)))
+;;     (debug:print-info 0 *default-log-port* "Syncing for dbfile: "dbfile", last-update: "last-update", last-sync: "last-sync)
+;;     (mutex-lock! *db-multi-sync-mutex*)
+;;     (let* ((update_info (cons "last_update" (if force-sync 0 last-update))) ;;  "last_update"))
+;;     	   (need-sync   (or force-sync (>= last-update last-sync))))
+;;       (if need-sync
+;; 	  (begin
+;; 	    (db:sync-tables (db:sync-all-tables-list) update_info inmem db)
+;; 	    (dbr:dbdat-last-sync-set! dbdat start-t))
+;; 	  (debug:print 0 *default-log-port* "Skipping sync as nothing touched.")))
+;;     (sqlite3:finalize! db)
+;;     (mutex-unlock! *db-multi-sync-mutex*)))
 
 ;; TODO: Add final sync to this
 ;;
-(define (db:safely-close-sqlite3-db db stmt-cache #!key (try-num 3))
+#;(define (db:safely-close-sqlite3-db db stmt-cache #!key (try-num 3))
   (if (<= try-num 0)
       #f
       (handle-exceptions
 	  exn
 	(begin
@@ -451,11 +484,11 @@
 	      (sqlite3:finalize! db)
 	      #t)
 	    #f))))
 
 ;; close all opened run-id dbs
-(define (db:close-all dbstruct)
+#;(define (db:close-all dbstruct)
   (assert (dbr:dbstruct? dbstruct) "FATAL: db:close-all called with dbstruct not set up.")
   (handle-exceptions
    exn
    (begin
      (debug:print 0 *default-log-port* "WARNING: Finalizing failed, "  ((condition-property-accessor 'exn 'message) exn) ", note - exn=" exn)
@@ -643,38 +676,23 @@
 	   (sqlite3:execute db "vacuum;")))
 	 
 	 (sqlite3:finalize! db)
 	 #t))))))
 
+;; last-update is *always* a pair ( fieldname|#f . last-update-seconds|#f)
 (define (db:sync-one-table fromdb todb tabledat last-update numrecs)
+  (assert (pair? last-update) "FATAL: last-update must always be a pair.")
   (let* ((tablename        (car tabledat))
 	 (fields           (cdr tabledat))
 	 (has-last-update  (member "last_update" fields))
-	 (use-last-update  (cond
-			    ((and has-last-update
-				  (member "last_update" fields))
-			     #t) ;; if given a number, just use it for all fields
-			    ((number? last-update) #f) ;; if not matched first entry then ignore last-update for this table
-			    ((and (pair? last-update)
-				  (member (car last-update)    ;; last-update field name
-					  (map car fields)))
-			     #t)
-			    (last-update
-			     (debug:print 0 *default-log-port* "ERROR: parameter last-update for db:sync-tables must be a pair or a number, received: " last-update);; found in fields
-			     #f)
-			    (else
-			     #f)))
-	 (last-update-value (if use-last-update ;; no need to check for has-last-update - it is already accounted for
-				(if (number? last-update)
-				    last-update
-				    (cdr last-update))
-				#f))
-	 (last-update-field (if use-last-update
-				(if (number? last-update)
+	 (last-update-field (or (car last-update)
+				(if has-last-update
 				    "last_update"
-				    (car last-update))
-				#f))
+				    #f)))
+	 (has-field         (member last-update-field fields))
+	 (last-update-value (cdr last-update))
+	 (use-last-update   (and has-field last-update-field last-update-value))
 	 (num-fields (length fields))
 	 (field->num (make-hash-table))
 	 (num->field (apply vector (map car fields))) ;; BBHERE
 	 (full-sel   (conc "SELECT " (string-intersperse (map car fields) ",") 
 			   " FROM " tablename (if use-last-update ;; apply last-update criteria
@@ -757,10 +775,11 @@
 		   (if (and same
 			    (< i (- num-fields 1)))
 		       (loop (+ i 1))))
 		 (if (not same)
 		     (begin
+		       (debug:print 0 *default-log-port* "applying data "fromrow"to table "tablename", numrecs="numrecs)
 		       (apply sqlite3:execute stmth (vector->list fromrow))
 		       (hash-table-set! numrecs tablename (+ 1 (hash-table-ref/default numrecs tablename 0)))))))
 	     fromdat-lst))))
        fromdats)
       (sqlite3:finalize! stmth)
@@ -773,11 +792,11 @@
 ;; if last-update specified ("field-name" . time-in-seconds)
 ;;    then sync only records where field-name >= time-in-seconds
 ;;    IFF field-name exists
 ;;
 (define (db:sync-tables tbls last-update fromdb todb)
-
+  (assert (pair? last-update) "FATAL: last-update must always be a pair")
   ;; NOTE: I'm moving all the checking OUT of this routine. Check for read/write access, existance, etc
   ;;       BEFORE calling this sync
   
   (let ((stmts       (make-hash-table)) ;; table-field => stmt
 	(all-stmts   '())              ;; ( ( stmt1 value1 ) ( stml2 value2 ))
@@ -798,11 +817,11 @@
        (lambda (dat)
 	 (let ((tblname (car dat))
 	       (count   (cdr dat)))
 	   (set! tot-count (+ tot-count count))
 	   (if (> count 0)
-	       (if should-print (debug:print 0 *default-log-port* (format #f "    ~10a ~5a" tblname count))))))
+	       (if should-print (debug:print 0 *default-log-port* "   "tblname" "count))))) ;; (format #f "    ~10a ~5a" tblname count))))))
        (sort (hash-table->alist numrecs)(lambda (a b)(> (cdr a)(cdr b))))))
     tot-count))
 
 (define (db:patch-schema-rundb frundb)
   ;;
@@ -2089,11 +2108,11 @@
           (if newres
               newres
               res))
         res)))
 
-(define (db:no-sync-close-db db stmt-cache)
+#;(define (db:no-sync-close-db db stmt-cache)
   (db:safely-close-sqlite3-db db stmt-cache))
 
 ;; transaction protected lock aquisition
 ;; either:
 ;;    fails    returns  (#f . lock-creation-time)
@@ -2245,10 +2264,46 @@
 	(db:with-db
 	 dbstruct #f #f
 	 (lambda (db)
 	   (let ((res #f))
 	     (apply sqlite3:execute db (conc "INSERT OR IGNORE INTO runs (runname,state,status,owner,event_time,contour" comma keystr ") VALUES (?,?,?,?,strftime('%s','now'),?" comma valslots ");")
+		    allvals)
+	     (apply sqlite3:for-each-row 
+		    (lambda (id)
+		      (set! res id))
+		    db
+		    (let ((qry (conc "SELECT id FROM runs WHERE (runname=? " andstr key=?str ");")))
+		      qry)
+		    qryvals)
+	     (sqlite3:execute db "UPDATE runs SET state=?,status=?,event_time=strftime('%s','now') WHERE id=? AND state='deleted';" state status res)
+	     res))) 
+	(begin
+	  (debug:print-error 0 *default-log-port* "Called without all necessary keys")
+	  #f))))
+
+;; register a test run with the db, this accesses the main.db and does NOT
+;; use server api
+;;
+(define (db:insert-run dbstruct run-id keyvals runname state status user contour-in)
+  (let* ((keys      (map car keyvals))
+	 (keystr    (keys->keystr keys))
+	 (contour   (or contour-in ""))  ;; empty string to force no hierarcy and be backwards compatible.
+	 (comma     (if (> (length keys) 0) "," ""))
+	 (andstr    (if (> (length keys) 0) " AND " ""))
+	 (valslots  (keys->valslots keys)) ;; ?,?,? ...
+	 (allvals   (append (list runname state status user contour) (map cadr keyvals)))
+	 (qryvals   (append (list runname) (map cadr keyvals)))
+	 (key=?str  (string-intersperse (map (lambda (k)(conc k "=?")) keys) " AND ")))
+    (debug:print 3 *default-log-port* "keys: " keys " allvals: " allvals " keyvals: " keyvals " key=?str is " key=?str)
+    (debug:print 2 *default-log-port* "NOTE: using target " (string-intersperse (map cadr keyvals) "/") " for this run")
+    (if (and runname (null? (filter (lambda (x)(not x)) keyvals))) ;; there must be a better way to "apply and"
+	(db:with-db
+	 dbstruct #f #f
+	 (lambda (db)
+	   (let ((res #f))
+	     (apply sqlite3:execute db (conc "INSERT OR IGNORE INTO runs (id,runname,state,status,owner,event_time,contour" comma keystr ") VALUES (?,?,?,?,?,strftime('%s','now'),?" comma valslots ");")
+		    run-id
 		    allvals)
 	     (apply sqlite3:for-each-row 
 		    (lambda (id)
 		      (set! res id))
 		    db
@@ -5537,10 +5592,30 @@
 	      (begin
 		(sqlite3:execute db "INSERT INTO servers (host,port,servkey,pid,ipaddr,apath,dbname) VALUES (?,?,?,?,?,?,?);"
 				 host port servkey pid ipaddr apath dbname)
 		(db:get-server-info dbstruct apath dbname)))))))))
   
+;; run this one in a transaction where first check if host:port is taken
+(define (db:deregister-server dbstruct host port servkey pid ipaddr apath dbname)
+  (db:with-db
+   dbstruct
+   #f #f
+   (lambda (db)
+     (sqlite3:with-transaction
+      db
+      (lambda ()
+	(let* ((sinfo      (db:get-server-info dbstruct apath dbname)))
+	  (if (not sinfo)
+	      (begin
+		(debug:print-info 0 *default-log-port* "Server already removed for "apath", "dbname) ;; at "sinfo ", while trying to register server " host":"port)
+		#f) ;; server already deregistered
+	      (begin
+		(sqlite3:execute db "DELETE FROM servers WHERE apath=? AND dbname=?;" ;; (host,port,servkey,pid,ipaddr,apath,dbname) VALUES (?,?,?,?,?,?,?);"
+				 ;; host port servkey pid ipaddr
+				 apath dbname)
+		#;(db:get-server-info dbstruct apath dbname)))))))))
+
 (define (db:get-server-info dbstruct apath dbname)
   (db:with-db
    dbstruct
    #f #f
    (lambda (db)
@@ -5549,7 +5624,20 @@
 	(list host port servkey pid ipaddr apath dbpath))
       #f
       db
       "SELECT host,port,servkey,pid,ipaddr,apath,dbname FROM servers WHERE apath=? AND dbname=?;"
       apath dbname))))
+
+(define (db:get-count-servers dbstruct apath)
+  (db:with-db
+   dbstruct
+   #f #f
+   (lambda (db)
+     (sqlite3:fold-row
+      (lambda (res count)
+	(max res count))
+      0
+      db
+      "SELECT count(*) FROM servers WHERE apath=?;"
+      apath))))
 
 )

Index: docs/manual/server.dot
==================================================================
--- docs/manual/server.dot
+++ docs/manual/server.dot
@@ -17,61 +17,65 @@
 digraph G {
 
     subgraph cluster_1 {
         node [style=filled,shape=box];
 
-	check_available_queue       -> remove_entries_over_10s_old;
-	remove_entries_over_10s_old -> set_available [label="num_avail < 3"];
-	remove_entries_over_10s_old -> exit [label="num_avail > 2"];
-
-	set_available               -> delay_2s;
-	delay_2s          -> check_place_in_queue;
-
-	check_place_in_queue        -> "http:transport-launch" [label="at head"];
-	check_place_in_queue        -> exit [label="not at head"];
-
-	"client:login"              -> "server:shutdown" [label="login failed"];
-	"server:shutdown"           -> exit;	
-
-	subgraph cluster_2 {
-		"http:transport-launch"       -> "http:transport-run";
-		"http:transport-launch"       -> "http:transport-keep-running";
-
-		"http:transport-keep-running" -> "tests running?";
-		"tests running?"              -> "client:login" [label=yes];
-		"tests running?"              -> "server:shutdown" [label=no];
-		"client:login"                -> delay_5s [label="login ok"];
-		delay_5s                      -> "http:transport-keep-running";
-	}
-
-	// start_server -> "server_running?";
-	// "server_running?" -> set_available [label="no"];
-	// "server_running?" -> delay_2s [label="yes"];
-	// delay_2s -> "still_running?";
-	// "still_running?" -> ping_server [label=yes];
-	// "still_running?" -> set_available [label=no];
-	// ping_server -> exit [label=alive];
-	// ping_server -> remove_server_record [label=dead];
-	// remove_server_record -> set_available;
-	// set_available -> avail_delay [label="delay 3s"];
-	// avail_delay -> "first_in_queue?";
-	// 
-	// "first_in_queue?" -> set_running [label=yes];
-	// set_running -> get_next_port -> handle_requests;
-	// "first_in_queue?" -> "dead_entry_in_queue?" [label=no];
-	// "dead_entry_in_queue?" -> "server_running?" [label=no];
-	// "dead_entry_in_queue?" -> "remove_dead_entries" [label=yes];
-	// remove_dead_entries -> "server_running?";
-	// 
-	// handle_requests -> start_shutdown [label="no traffic\nno running tests"];
-	// handle_requests -> shutdown_request;
-	// start_shutdown -> shutdown_delay;
-	// shutdown_request -> shutdown_delay;
-	// shutdown_delay -> exit;
-	
-        label = "server:launch";
-        color=brown;
+	rmt:send-receive -> "init-*remote* if needed" -> rmt:general-open-connection ->
+	  rmt:send-receive-real;
+	
+
+//	check_available_queue       -> remove_entries_over_10s_old;
+//	remove_entries_over_10s_old -> set_available [label="num_avail < 3"];
+//	remove_entries_over_10s_old -> exit [label="num_avail > 2"];
+//
+//	set_available               -> delay_2s;
+//	delay_2s          -> check_place_in_queue;
+//
+//	check_place_in_queue        -> "http:transport-launch" [label="at head"];
+//	check_place_in_queue        -> exit [label="not at head"];
+//
+//	"client:login"              -> "server:shutdown" [label="login failed"];
+//	"server:shutdown"           -> exit;	
+//
+//	subgraph cluster_2 {
+//		"http:transport-launch"       -> "http:transport-run";
+//		"http:transport-launch"       -> "http:transport-keep-running";
+//
+//		"http:transport-keep-running" -> "tests running?";
+//		"tests running?"              -> "client:login" [label=yes];
+//		"tests running?"              -> "server:shutdown" [label=no];
+//		"client:login"                -> delay_5s [label="login ok"];
+//		delay_5s                      -> "http:transport-keep-running";
+//	}
+//
+//	// start_server -> "server_running?";
+//	// "server_running?" -> set_available [label="no"];
+//	// "server_running?" -> delay_2s [label="yes"];
+//	// delay_2s -> "still_running?";
+//	// "still_running?" -> ping_server [label=yes];
+//	// "still_running?" -> set_available [label=no];
+//	// ping_server -> exit [label=alive];
+//	// ping_server -> remove_server_record [label=dead];
+//	// remove_server_record -> set_available;
+//	// set_available -> avail_delay [label="delay 3s"];
+//	// avail_delay -> "first_in_queue?";
+//	// 
+//	// "first_in_queue?" -> set_running [label=yes];
+//	// set_running -> get_next_port -> handle_requests;
+//	// "first_in_queue?" -> "dead_entry_in_queue?" [label=no];
+//	// "dead_entry_in_queue?" -> "server_running?" [label=no];
+//	// "dead_entry_in_queue?" -> "remove_dead_entries" [label=yes];
+//	// remove_dead_entries -> "server_running?";
+//	// 
+//	// handle_requests -> start_shutdown [label="no traffic\nno running tests"];
+//	// handle_requests -> shutdown_request;
+//	// start_shutdown -> shutdown_delay;
+//	// shutdown_request -> shutdown_delay;
+//	// shutdown_delay -> exit;
+//	
+//        label = "server:launch";
+//        color=brown;
     }
 
 //     client_start_server -> start_server;
 //     handle_requests -> read_write;
 //     read_write -> handle_requests;

Index: launchmod.scm
==================================================================
--- launchmod.scm
+++ launchmod.scm
@@ -2289,13 +2289,16 @@
 	 (dbfile     (args:get-arg "-db"))
 	 (apath      *toppath*))
     (let loop ()
       (thread-sleep! 5) ;; add control / setting for this
       (if am-server
-	  (if (not  *dbstruct-db*)
+	  (if (not  *dbstruct-db*) ;; skip syncing until db is setup
 	      (loop)
-	      (db:sync-inmem->disk *dbstruct-db* *toppath* dbfile))))))
+	      (begin
+		;; (debug:print-info 0 *default-log-port* "syncing "apath" "dbfile" at "(current-seconds))
+		;; (db:sync-inmem->disk *dbstruct-db* apath dbfile)
+		(loop)))))))
   
 ;; 
 ;; (let ((dbstruct 
 ;; 	    (debug:print-info 13 *default-log-port* "after db:setup with dbstruct=" dbstruct)
 ;; 	    (cond

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -182,20 +182,20 @@
 (include "ods.scm")
 
 (define *usage-log-file* #f)    ;; put path to file for logging usage in this var in the ~/.megatestrc file
 (define *usage-use-seconds* #t) ;; for Epoc seconds in usage logging change this to #t in ~/.megatestrc file
 
-     ;;======================================================================
-     ;; Test commands (i.e. for use inside tests)
-     ;;======================================================================
-     
-     (define (megatest:step step state status logfile msg)
-       (if (not (getenv "MT_CMDINFO"))
-           (begin
+;;======================================================================
+;; Test commands (i.e. for use inside tests)
+;;======================================================================
+
+(define (megatest:step step state status logfile msg)
+  (if (not (getenv "MT_CMDINFO"))
+      (begin
      	(debug:print-error 0 *default-log-port* "MT_CMDINFO env var not set, -step must be called *inside* a megatest invoked environment!")
      	(exit 5))
-           (let* ((cmdinfo   (common:read-encoded-string (getenv "MT_CMDINFO")))
+      (let* ((cmdinfo   (common:read-encoded-string (getenv "MT_CMDINFO")))
      	     (transport (assoc/default 'transport cmdinfo))
      	     (testpath  (assoc/default 'testpath  cmdinfo))
      	     (test-name (assoc/default 'test-name cmdinfo))
      	     (runscript (assoc/default 'runscript cmdinfo))
      	     (db-host   (assoc/default 'db-host   cmdinfo))
@@ -215,18 +215,18 @@
      	      (rmt:teststep-set-status! run-id test-id step state status (or comment msg) logfile))
      	    (begin
      	      (debug:print-error 0 *default-log-port* "You must specify :state and :status with every call to -step")
      	      (exit 6))))))
 
-     ;;======================================================================
-     ;; full run
-     ;;======================================================================
-     
-     (define (handle-run-requests target runname keys keyvals need-clean)	 
-       (if (or (args:get-arg "-kill-rerun") (args:get-arg "-rerun-clean")) ;; first set states/statuses correct
-           ;; For rerun-clean do we or do we not support the testpatt?
-           (let ((states   (or (configf:lookup *configdat* "validvalues" "cleanrerun-states")
+;;======================================================================
+;; full run
+;;======================================================================
+
+(define (handle-run-requests target runname keys keyvals need-clean)	 
+  (if (or (args:get-arg "-kill-rerun") (args:get-arg "-rerun-clean")) ;; first set states/statuses correct
+      ;; For rerun-clean do we or do we not support the testpatt?
+      (let ((states   (or (configf:lookup *configdat* "validvalues" "cleanrerun-states")
      			  "KILLREQ,KILLED,UNKNOWN,INCOMPLETE,STUCK,NOT_STARTED"))
      	    (statuses (or (configf:lookup *configdat* "validvalues" "cleanrerun-statuses")
      			  "FAIL,INCOMPLETE,ABORT,CHECK,DEAD,PREQ_FAIL,PREQ_DISCARDED")))
      	(hash-table-set! args:arg-hash "-preclean" #t)
      	(runs:operate-on 'set-state-status
@@ -244,13 +244,13 @@
      			 ;; "%" ;; (common:args-get-testpatt #f) ;; (args:get-arg "-testpatt")
      			 (common:args-get-testpatt #f) ;; (args:get-arg "-testpatt")
      			 ;; state:  states
      			 status: statuses
      			 new-state-status: "NOT_STARTED,n/a")))
-       ;; RERUN ALL
-       (if (args:get-arg "-rerun-all") ;; first set states/statuses correct
-           (let* ((rconfig (full-runconfigs-read)))
+  ;; RERUN ALL
+  (if (args:get-arg "-rerun-all") ;; first set states/statuses correct
+      (let* ((rconfig (full-runconfigs-read)))
      	(hash-table-set! args:arg-hash "-preclean" #t)
      	(runs:operate-on 'set-state-status
      			 target
      			 (common:args-get-runname)  ;; (or (args:get-arg "-runname")(args:get-arg ":runname"))
      			 (common:args-get-testpatt rconfig) ;; (args:get-arg "-testpatt")
@@ -263,67 +263,67 @@
      			 (common:args-get-runname)  ;; (or (args:get-arg "-runname")(args:get-arg ":runname"))
      			 (common:args-get-testpatt rconfig) ;; (args:get-arg "-testpatt")
      			 ;; state:  states
      			 status: #f
      			 new-state-status: "NOT_STARTED,n/a")))
-       (let* ((config-reruns      (let ((x (configf:lookup *configdat* "setup" "reruns")))
+  (let* ((config-reruns      (let ((x (configf:lookup *configdat* "setup" "reruns")))
      			       (if x (string->number x) #f)))
      	 (rerun-cnt (if config-reruns
      			config-reruns
      			1)))
-     
-         (runs:run-tests target
+    
+    (runs:run-tests target
      		    runname
      		    #f ;; (common:args-get-testpatt #f)
      		    ;; (or (args:get-arg "-testpatt")
      		    ;;     "%")
      		    (bdat-user *bdat*)
      		    args:arg-hash
      		    run-count: rerun-cnt)))
 
-     ;; csv processing record
-     (define (make-refdb:csv)
-       (vector 
-        (make-sparse-array)
-        (make-hash-table)
-        (make-hash-table)
-        0
-        0))
-     (define-inline (refdb:csv-get-svec     vec)    (vector-ref  vec 0))
-     (define-inline (refdb:csv-get-rows     vec)    (vector-ref  vec 1))
-     (define-inline (refdb:csv-get-cols     vec)    (vector-ref  vec 2))
-     (define-inline (refdb:csv-get-maxrow   vec)    (vector-ref  vec 3))
-     (define-inline (refdb:csv-get-maxcol   vec)    (vector-ref  vec 4))
-     (define-inline (refdb:csv-set-svec!    vec val)(vector-set! vec 0 val))
-     (define-inline (refdb:csv-set-rows!    vec val)(vector-set! vec 1 val))
-     (define-inline (refdb:csv-set-cols!    vec val)(vector-set! vec 2 val))
-     (define-inline (refdb:csv-set-maxrow!  vec val)(vector-set! vec 3 val))
-     (define-inline (refdb:csv-set-maxcol!  vec val)(vector-set! vec 4 val))
-     
-     (define (get-dat results sheetname)
-       (or (hash-table-ref/default results sheetname #f)
-           (let ((tmp-vec  (make-refdb:csv)))
+;; csv processing record
+(define (make-refdb:csv)
+  (vector 
+   (make-sparse-array)
+   (make-hash-table)
+   (make-hash-table)
+   0
+   0))
+(define-inline (refdb:csv-get-svec     vec)    (vector-ref  vec 0))
+(define-inline (refdb:csv-get-rows     vec)    (vector-ref  vec 1))
+(define-inline (refdb:csv-get-cols     vec)    (vector-ref  vec 2))
+(define-inline (refdb:csv-get-maxrow   vec)    (vector-ref  vec 3))
+(define-inline (refdb:csv-get-maxcol   vec)    (vector-ref  vec 4))
+(define-inline (refdb:csv-set-svec!    vec val)(vector-set! vec 0 val))
+(define-inline (refdb:csv-set-rows!    vec val)(vector-set! vec 1 val))
+(define-inline (refdb:csv-set-cols!    vec val)(vector-set! vec 2 val))
+(define-inline (refdb:csv-set-maxrow!  vec val)(vector-set! vec 3 val))
+(define-inline (refdb:csv-set-maxcol!  vec val)(vector-set! vec 4 val))
+
+(define (get-dat results sheetname)
+  (or (hash-table-ref/default results sheetname #f)
+      (let ((tmp-vec  (make-refdb:csv)))
      	(hash-table-set! results sheetname tmp-vec)
      	tmp-vec)))
-     
-     ;; bracket open-output-file with code to make leading directory if it does not exist and handle exceptions
-     (define (open-logfile logpath-in)
-       (condition-case
-        (let* ((log-dir (or (pathname-directory logpath-in) "."))
+
+;; bracket open-output-file with code to make leading directory if it does not exist and handle exceptions
+(define (open-logfile logpath-in)
+  (condition-case
+   (let* ((log-dir (or (pathname-directory logpath-in) "."))
      	  (fname   (pathname-strip-directory logpath-in))
      	  (logpath (if (> (string-length fname) 250)
      		       (let ((newlogf (conc log-dir "/" (common:get-signature fname) ".log")))
      			 (debug:print 0 *default-log-port* "WARNING: log file " logpath-in " path too long, converted to " newlogf)
      			 newlogf)
      		       logpath-in)))
-          (if (not (directory-exists? log-dir))
-              (system (conc "mkdir -p " log-dir)))
-          (open-output-file logpath))
-        (exn ()
-             (debug:print-error 0 *default-log-port* "Could not open log file for write: "logpath-in)
-             (define *didsomething* #t)  
-             (exit 1))))
+     (if (not (directory-exists? log-dir))
+	 (system (conc "mkdir -p " log-dir)))
+     (open-output-file logpath))
+   (exn ()
+	(debug:print-error 0 *default-log-port* "Could not open log file for write: "logpath-in)
+	(define *didsomething* #t)  
+	(exit 1))))
 
 (define (debug:setup)
   (let ((debugstr (or (args:get-arg "-debug")
       		      (args:get-arg "-debug-noprop")
       		      (getenv "MT_DEBUG_MODE"))))
@@ -349,11 +349,11 @@
 
 ;; Disabled help items
 ;;  -rollup                 : (currently disabled) fill run (set by :runname)  with latest test(s)
 ;;                            from prior runs with same keys
 ;;  -daemonize              : fork into background and disconnect from stdin/out
-     
+
 (define help (conc "
 Megatest, documentation at http://www.kiatoa.com/fossils/megatest
   version " megatest-version "
   license GPL, Copyright Matt Welland 2006-2017
  
@@ -786,11 +786,11 @@
      (let ((targ (or (args:get-arg "-reqtarg")(args:get-arg "-target"))))
        (if targ (setenv "MT_TARGET" targ)))
      
      ;; The watchdog is to keep an eye on things like db sync etc.
      ;;
-(init-watchdog)
+;; (init-watchdog)
   
 ;;      (define (debug:debug-mode n)
 ;;        (cond
 ;;         ((and (number? *verbosity*)   ;; number number
 ;;      	 (number? n))
@@ -912,12 +912,13 @@
            (hash-table-set! args:arg-hash "-testpatt" newval)
            (hash-table-delete! args:arg-hash "-itempatt")))
      
      (if (args:get-arg "-runtests")
          (debug:print 0 *default-log-port* "WARNING: \"-runtests\" is deprecated. Use \"-run\" with \"-testpatt\" instead"))
-     
-     (on-exit std-exit-procedure)
+
+     (debug:print 0 *default-log-port* "on-exit disabled. Please re-enable")
+     ;; (on-exit std-exit-procedure)
      
      ;;======================================================================
      ;; Misc general calls
      ;;======================================================================
 

Index: rmtmod.scm
==================================================================
--- rmtmod.scm
+++ rmtmod.scm
@@ -62,10 +62,11 @@
 	;; http-client
 	;; intarweb
 	matchable
 	md5
 	message-digest
+	nanomsg
 	(prefix base64 base64:)
 	(prefix sqlite3 sqlite3:)
 	regex
 	s11n
 	;; spiffy
@@ -75,11 +76,11 @@
 	srfi-13
 	srfi-18
 	srfi-69
 	stack
 	system-information
-	tcp6
+	;; tcp6
 	typed-records
 	uri-common
 	z3
        
 	apimod
@@ -119,10 +120,11 @@
 ;;
 (defstruct servdat
   (host #f)
   (port #f)
   (uuid #f)
+  (rep  #f)
   (dbfile #f)
   (api-url #f)
   (api-uri #f)
   (api-req #f)
   (status 'starting)
@@ -243,15 +245,16 @@
 	(start-main-srv))))
 
 ;; NB// remote is a rmt:remote struct
 ;;
 (define (rmt:general-open-connection remote apath dbname #!key (num-tries 5))
-  (let ((mdbname (db:run-id->dbname #f)))
+  (let* ((mdbname (db:run-id->dbname #f))
+	 (mconn   (rmt:get-conn remote apath mdbname)))
     (cond
-     ((not (rmt:get-conn remote apath mdbname)) ;; no channel open to main? 
+     ((or (not mconn) ;; no channel open to main?
+	  (< (rmt:conn-expires mconn)(+ (current-seconds) 2))) ;; restablish connection if less than 2 seconds on the lease
       (rmt:open-main-connection remote apath)
-      (thread-sleep! 2)
       (rmt:general-open-connection remote apath mdbname))
      ((not (rmt:get-conn remote apath dbname))                 ;; no channel open to dbname?     
       (let* ((res (rmt:send-receive-real remote apath mdbname 'get-server `(,apath ,dbname))))
 	(case res
 	  ((server-started)
@@ -262,27 +265,59 @@
 	       (begin
 		 (debug:print-error 0 *default-log-port* "Failed to start servers needed or open channel to "apath", "dbname)
 		 (exit 1))))
 	  (else
 	   (if (list? res) ;; server has been registered and the info was returned. pass it on.
-	       res
+	       (begin ;;  ("192.168.0.9" 53817
+		      ;;  "5e34239f48e8973b3813221e54701a01" "24310"
+		      ;;  "192.168.0.9"
+		      ;;  "/home/matt/data/megatest/tests/simplerun"
+		 ;;  ".db/1.db")
+		 (match
+		  res
+		  ((host port servkey pid ipaddr apath dbname)
+		   (debug:print-info 0 *default-log-port* "got "res)
+		   (hash-table-set! (rmt:remote-conns remote)
+				    dbname
+				    (make-rmt:conn
+				     apath: apath
+				     dbname: dbname
+				     hostport: (conc host":"port)
+				     ipaddr: ipaddr
+				     port: port
+				     srvkey: servkey
+				     lastmsg: (current-seconds)
+				     expires: (+ (current-seconds) 60))))
+		  (else
+		   (debug:print-info 0 *default-log-port* "return data from starting server did not match host port servkey pid ipaddr apath dbname " res)))
+		 res)
 	       (begin
 		 (debug:print-info 0 *default-log-port* "Unexpected result: " res)
-		 res)))))))))
+		 res))))))
+     
+
+     )))
 
 ;;======================================================================
 
+;; FOR DEBUGGING SET TO #t
+(define *localmode* #t)
 
 ;; Defaults to current area
 ;;
 (define (rmt:send-receive cmd rid params #!key (attemptnum 1)(area-dat #f))
   (if (not *rmt:remote*)(set! *rmt:remote* (make-rmt:remote)))
-  (let* ((apath *toppath*)
-	 (conns *rmt:remote*)
-	 (dbname (db:run-id->dbname rid)))
-    (rmt:general-open-connection conns apath dbname)
-    (rmt:send-receive-real conns apath dbname cmd params)))
+  (let* ((apath      *toppath*)
+	 (conns      *rmt:remote*)
+	 (dbname     (db:run-id->dbname rid)))
+    (if *localmode*
+	(let* ((dbstruct (db:cache-get-dbstruct rid apath))
+	       (indat    `((cmd . ,cmd)(params . ,params))))
+	  (api:process-request dbstruct indat))
+	(begin
+	  (rmt:general-open-connection conns apath dbname)
+	  (rmt:send-receive-real conns apath dbname cmd params)))))
 
 #;(define (rmt:send-receive-setup conn)
   (if (not (rmt:conn-inport conn))
       (let-values (((i o) (tcp-connect (rmt:conn-ipaddr conn)
 				       (rmt:conn-port conn))))
@@ -293,31 +328,19 @@
 ;; sometime in the future
 ;;
 (define (rmt:send-receive-real remote apath dbname cmd params)
   (let* ((conn (rmt:get-conn remote apath dbname)))
     (assert conn "FATAL: rmt:send-receive-real called without the needed channels opened")
-    (pp (rmt:conn->alist conn))
-    ;; (rmt:send-receive-setup conn)
-    (let-values (((i o) (tcp-connect (rmt:conn-ipaddr conn)
-				     (rmt:conn-port conn))))
-      (let* ((key     #f)
-	     (payload `((cmd    . ,cmd)
-			(key    . ,(rmt:conn-srvkey conn))
-			(params . ,params)))
-	     (res      (begin
-			 (write payload o) ;; (rmt:conn-outport conn))
-			 (with-input-from-port
-			     i ;; (rmt:conn-inport conn)
-			   read))))
-	(close-input-port i)
-	(close-output-port o)
-	res))))
-;;  (if (string? res)
-;; 	  (string->sexpr res)
-;; 	  res))))
-
-
+    (let* ((key     #f)
+	   (host    (rmt:conn-ipaddr conn))
+	   (port    (rmt:conn-port   conn))
+	   (payload `((cmd    . ,cmd)
+		      (key    . ,(rmt:conn-srvkey conn))
+		      (params . ,params)))
+	   (res      (open-send-receive-nn (conc host":"port)
+					   (sexpr->string payload))))
+      (string->sexpr res))))
 
 ;; db is at apath/.db/dbname, rid is an intermediary solution and will be removed
 ;; sometime in the future.
 ;;
 ;; Purpose - call the main.db server and request a server be started
@@ -332,11 +355,11 @@
 ;; 		      read-string)))
 ;;       (string->sexpr res))))
 
 (define (rmt:print-db-stats)
   (let ((fmtstr "~40a~7-d~9-d~20,2-f")) ;; "~20,2-f"
-    (debug:print 18 *default-log-port* "DB Stats\n========")
+    (debug:print 18 *default-log-port* "DB Stats, "(seconds->year-week/day-time (current-seconds))"\n=====================")
     (debug:print 18 *default-log-port* (format #f "~40a~8a~10a~10a" "Cmd" "Count" "TotTime" "Avg"))
     (for-each (lambda (cmd)
 		(let ((cmd-dat (hash-table-ref *db-stats* cmd)))
 		  (debug:print 18 *default-log-port* (format #f fmtstr cmd (vector-ref cmd-dat 0) (vector-ref cmd-dat 1) (/ (vector-ref cmd-dat 1)(vector-ref cmd-dat 0))))))
 	      (sort (hash-table-keys *db-stats*)
@@ -677,12 +700,11 @@
   ;; first register in main.db (thus the #f)
   (let* ((run-id (rmt:send-receive 'register-run #f (list keyvals runname state status user contour))))
     ;; now register in the run db itself
 
     ;; NEED A RECORD INSERT INCLUDING SETTING id
-    (rmt:send-receive 'register-run run-id (list keyvals runname state status user contour))
-    
+    (rmt:send-receive 'insert-run run-id (list run-id keyvals runname state status user contour))
     run-id))
   
 (define (rmt:get-run-name-from-id run-id)
   (rmt:send-receive 'get-run-name-from-id run-id (list run-id)))
 
@@ -1443,10 +1465,57 @@
                (common:version-signature))))
 
 (define (common:api-changed?)
   (not (equal? (substring (->string megatest-version) 0 4)
                (substring (conc (common:get-last-run-version)) 0 4))))
+
+(define (rmt:server-shutdown)
+  (let ((dbfile   (servdat-dbfile *server-info*)))
+    (debug:print-info 0 *default-log-port* "dbfile is "dbfile)
+    (if dbfile
+	(let* ((am-server  (args:get-arg "-server"))
+	       (dbfile     (args:get-arg "-db"))
+	       (apath      *toppath*)
+	       (dbdat      (db:get-dbdat *dbstruct-db* apath dbfile))
+	       (db         (dbr:dbdat-db dbdat))
+	       (inmem      (dbr:dbdat-db dbdat))
+	       )
+	  ;; do a final sync here
+	  (debug:print-info 0 *default-log-port* "Doing final sync for "apath" "dbfile" at "(current-seconds))
+	  (db:sync-inmem->disk *dbstruct-db* apath dbfile force-sync: #t)
+	  ;; let's finalize here
+	  (debug:print-info 0 *default-log-port* "Finalizing db and inmem")
+	  (sqlite3:finalize! db)
+	  (sqlite3:finalize! inmem)
+	  (debug:print-info 0 *default-log-port* "Finalizing db and inmem complete")
+	  (if am-server
+	      (if (string-match ".*/main.db$" dbfile)
+		  (let ((pkt-file (conc (get-pkts-dir *toppath*)
+					"/" (servdat-uuid *server-info*)
+					".pkt")))
+		    (debug:print-info 0 *default-log-port* "removing pkt "pkt-file)
+		    (delete-file* pkt-file)
+		    (debug:print-info 0 *default-log-port* "Releasing lock for "dbfile)
+		    (db:with-lock-db (servdat-dbfile *server-info*)
+				     (lambda (dbh dbfile)
+				       (db:release-lock dbh dbfile))))
+		  (let* ((sdat *server-info*) ;; we have a run-id server
+			 (host (servdat-host sdat))
+			 (port (servdat-port sdat))
+			 (uuid (servdat-uuid sdat)))
+		    (if (not (string-match ".db/main.db" (args:get-arg "-db")))
+			(let* ((res (rmt:deregister-server *rmt:remote* ;; TODO/BUG: why is this requiring *rmt:remote*?
+							   *toppath*
+							   (servdat-host *server-info*)   ;; iface
+							   (servdat-port *server-info*)
+							   (servdat-uuid *server-info*)
+							   (current-process-id)
+							   )))
+			  (debug:print-info 0 *default-log-port* "deregistered-server, res="res)))
+		    
+		    (debug:print-info 0 *default-log-port* "deregistering server "host":"port" with uuid "uuid)
+		    )))))))
 
 (define (std-exit-procedure)
   ;;(common:telemetry-log-close)
   (on-exit (lambda () 0))
   ;;(debug:print-info 13 *default-log-port* "std-exit-procedure called; *time-to-exit*="*time-to-exit*)
@@ -1456,56 +1525,40 @@
 			 (bdat-time-to-exit-set! *bdat* #t)
 			 #t))))
     (debug:print-info 4 *default-log-port* "starting exit process, finalizing databases.")
     (if (and no-hurry (debug:debug-mode 18))
 	(rmt:print-db-stats))
-    (let ((th1 (make-thread (lambda () ;; thread for cleaning up, give it five seconds
-                              (if *server-info*
-				  (let ((pkt-file (conc (get-pkts-dir *toppath*)
-							"/" (servdat-uuid *server-info*)
-							".pkt"))
-					(dbfile   (servdat-dbfile *server-info*)))
-				    (if dbfile
-					(begin
-
-					  ;; do a final sync here
-					  
-					(if (string-match ".*/main.db$" dbfile)
-					    (begin
-					      (debug:print-info 0 *default-log-port* "removing pkt "pkt-file)
-					      (delete-file* pkt-file)
-					      (debug:print-info 0 *default-log-port* "Releasing lock for "dbfile)
-					      (db:with-lock-db (servdat-dbfile *server-info*)
-							       (lambda (dbh dbfile)
-								 (db:release-lock dbh dbfile))))
-					    (let* ((sdat *server-info*)) ;; we have a run-id server
-					      (rmt:send-receive-real *rmt:remote* *toppath*
-								     (db:run-id->dbname #f)
-								     'deregister-server
-								     `(,(servdat-uuid sdat)
-								       ,(current-process-id)
-								       ,(servdat-host sdat)   ;; iface
-								       ,(servdat-port sdat)))))))))
-			      (if *dbstruct-db* (db:close-all *dbstruct-db*)) ;; one second allocated
-			      (if (bdat-task-db *bdat*)    ;; TODO: Check that this is correct for task db
-				  (let ((db (cdr (bdat-task-db *bdat*))))
-				    (if (sqlite3:database? db)
-					(begin
-					  (sqlite3:interrupt! db)
-					  (sqlite3:finalize! db #t)
-					  (bdat-task-db-set! *bdat* #f)))))
-                              #;(http-client#close-idle-connections!)
-                              (if (not (eq? *default-log-port* (current-error-port)))
-                                  (close-output-port *default-log-port*))
-			      (set! *default-log-port* (current-error-port))) "Cleanup db exit thread"))
+    (let ((th1 (make-thread
+		(lambda () ;; thread for cleaning up, give it five seconds
+		  (let* ((start-time (current-seconds)))
+		    (if (and *server-info*
+			     *unclean-shutdown*)
+			(begin
+			  (debug:print-info 0 *default-log-port* "Unclean server exit, calling server-shtudown")
+			  (rmt:server-shutdown)))
+		    (debug:print-info 0 *default-log-port* "Shutdown activities completed in "(- (current-seconds) start-time)" seconds"))
+		  ;; (if *dbstruct-db* (db:close-all *dbstruct-db*)) ;; one second allocated
+		  #;(if (bdat-task-db *bdat*)    ;; TODO: Check that this is correct for task db
+		  (let ((db (cdr (bdat-task-db *bdat*))))
+		  (if (sqlite3:database? db)
+		  (begin
+		  (debug:print-info 0 *default-log-port* "Closing down task db "db)
+		  (sqlite3:interrupt! db)
+		  (sqlite3:finalize! db #t)
+		  (bdat-task-db-set! *bdat* #f)))))
+		  #;(http-client#close-idle-connections!)
+		  (if (not (eq? *default-log-port* (current-error-port)))
+		      (close-output-port *default-log-port*))
+		  (set! *default-log-port* (current-error-port))) "Cleanup db exit thread"))
 	  (th2 (make-thread (lambda ()
-			      (debug:print 4 *default-log-port* "Attempting clean exit. Please be patient and wait a few seconds...")
+			      (debug:print 4 *default-log-port* "Attempting clean exit. Mode="(if no-hurry "no-hurry" "normal")
+					   " Please be patient and wait a few seconds...")
 			      (if no-hurry
                                   (begin
                                     (thread-sleep! 5)) ;; give the clean up few seconds to do it's stuff
                                   (begin
-      				  (thread-sleep! 2)))
+				    (thread-sleep! 2)))
       			      (debug:print 4 *default-log-port* " ... done")
       			      )
 			    "clean exit")))
       (thread-start! th1)
       (thread-start! th2)
@@ -1539,38 +1592,13 @@
 
 ;;======================================================================
 ;; S E R V E R
 ;; ======================================================================
 
-;; NOTE: http-transport:launch is the entry point
-;;          -> http-transport:run
-;;             -> http-transport:try-start-server -> http-transport:try-start-server (until success)
-
 (define (http-get-function fnkey)
   (hash-table-ref/default *http-functions* fnkey (lambda () "nothing here yet")))
 
-#;(define (rmt:launch-server hostn port)
-   (if *server-info*
-	(begin
-	  (servdat-host-set! *server-info* hostn)
-	  (servdat-port-set! *server-info* port)
-	  (servdat-status-set! *server-info* 'trying-port)
-	  (servdat-trynum-set! *server-info* (+ (servdat-trynum *server-info*) 1)))
-	(set! *server-info* (make-servdat host: ipaddrstr port: portnum)))
-   (let* ((l        (tcp-listen port))
-	 (dbstruct #f))
-    (let-values (((i o) (tcp-accept l)))
-      ;; (write-line "Hello!" o)
-      (let loop ((indat (read i)))
-	(let* ((res (api:process-request dbstruct indat)))
-	  (case res
-	    ((quit)
-	     (close-input-port i)
-	     (close-output-port o))
-	    (else
-	     (write res o))))))))
-
 (define (rmt:run hostn)
   ;;  ;; Configurations for server
   ;;  (tcp-buffer-size 2048)
   ;;  (max-connections 2048) 
   (debug:print 2 *default-log-port* "Attempting to start the server ...")
@@ -1581,73 +1609,109 @@
 					   (server:get-best-guess-address hostname)
 					   #f)))
 			    (if ipstr ipstr hostn))) ;; hostname))) 
 	 (port            (portlogger:open-run-close portlogger:find-port))
 	 (link-tree-path  (common:get-linktree))
-	 (tmp-area        (common:get-db-tmp-area))
+	 ;; (tmp-area        (common:get-db-tmp-area))
 	 #;(start-file      (conc tmp-area "/.server-start")))
     (debug:print-info 0 *default-log-port* "portlogger recommended port: " port)
     (if *server-info*
 	(begin
 	  (servdat-host-set! *server-info* ipaddrstr)
 	  (servdat-port-set! *server-info* port)
 	  (servdat-status-set! *server-info* 'trying-port)
 	  (servdat-trynum-set! *server-info* (+ (servdat-trynum *server-info*) 1)))
 	(set! *server-info* (make-servdat host: ipaddrstr port: port)))
-    (let* ((l        (rmt:try-start-server ipaddrstr port)))
-      (let oloop ()
-	(let-values (((i o) (tcp-accept l)))
-	  ;; (write-line "Hello!" o)
-	  (let loop ((indat (read i)))
-	    (if (eof-object? indat)
-		(begin
-		  (close-input-port i)
-		  (close-output-port o)
-		  (oloop))
-		(let* ((res (api:process-request *dbstruct-db* indat)))
-		  (set! *db-last-access* (current-seconds))
-		  (write res o)
-		  (loop (read i))))))))
+    (let* ((rep (rmt:try-start-server ipaddrstr port)))
+      (let loop ((instr (nn-recv rep)))
+	(let* ((data   (string->sexpr instr))
+	       (res    (case data
+			 ((quit) 'quit)
+			 (else    (api:process-request *dbstruct-db* data))))
+	       (resdat (sexpr->string res)))
+	  (if (not (eq? res 'quit))
+	      (begin
+		(set! *db-last-access* (current-seconds))
+		(nn-send rep resdat)
+		(loop (nn-recv rep)))))))
+    (debug:print-info 0 *default-log-port* "After server, should never see this")
+    ;; server exit stuff here
     (let* ((portnum (servdat-port *server-info*)))
       (portlogger:open-run-close portlogger:set-port portnum "released")
-      (debug:print 1 *default-log-port* "INFO: server has been stopped"))))
+      (rmt:server-shutdown)
+      ;; (bdat-time-to-exit-set! *bdat* #t) ;; tell on-exit to be fast as we've already cleaned up
+      (portlogger:open-run-close portlogger:set-port port "released") ;; done in rmt:run
+      ;; (debug:print-info 0 *default-log-port* "Max cached queries was    " *max-cache-size*)
+      ;; (debug:print-info 0 *default-log-port* "Number of cached writes   " *number-of-writes*)
+      ;; (debug:print-info 0 *default-log-port* "Average cached write time "
+      ;; 		      (if (eq? *number-of-writes* 0)
+      ;; 			  "n/a (no writes)"
+      ;; 			  (/ *writes-total-delay*
+      ;; 			     *number-of-writes*))
+      ;; 		      " ms")
+      ;; (debug:print-info 0 *default-log-port* "Number non-cached queries "  *number-non-write-queries*)
+      ;; (debug:print-info 0 *default-log-port* "Average non-cached time   "
+      ;; 		      (if (eq? *number-non-write-queries* 0)
+      ;; 			  "n/a (no queries)"
+      ;; 			  (/ *total-non-write-delay* 
+      ;; 			     *number-non-write-queries*))
+      ;; 		      " ms")
+      
+      (db:print-current-query-stats)
+      (debug:print-info 0 *default-log-port* "Server shutdown complete. Exiting")
+      )))
 
 (define (rmt:try-start-server ipaddrstr portnum)
-  (if *server-info*
+  (if *server-info* ;; update the server info as we might be trying next port
       (begin
 	(servdat-host-set! *server-info* ipaddrstr)
 	(servdat-port-set! *server-info* portnum)
 	(servdat-status-set! *server-info* 'trying-port)
-	(servdat-trynum-set! *server-info* (+ (servdat-trynum *server-info*) 1)))
+	(servdat-trynum-set! *server-info*
+			     (+ (servdat-trynum *server-info*) 1)))
       (set! *server-info* (make-servdat host: ipaddrstr port: portnum)))
   (debug:print-info 0 *default-log-port* "rmt:try-start-server time="
 		    (seconds->time-string (current-seconds))
 		    " ipaddrsstr=" ipaddrstr
 		    " portnum=" portnum)
-  (handle-exceptions
-   exn
-   (begin
-     (print-error-message exn)
-     (if (< portnum 64000)
-	 (begin 
-	   (debug:print 0 *default-log-port* "WARNING: attempt to start server failed. Trying again ...")
-	   (debug:print 0 *default-log-port* " message: " ((condition-property-accessor 'exn 'message) exn))
-	   (debug:print 5 *default-log-port* "exn=" (condition->list exn))
-	   (portlogger:open-run-close portlogger:set-failed portnum)
-	   (debug:print 0 *default-log-port* "WARNING: failed to start on portnum: " portnum ", trying next port")
-	   ;; (thread-sleep! 0.1)
-	   (rmt:try-start-server ipaddrstr
-				 (portlogger:open-run-close portlogger:find-port)))
-	 (begin
-	   (print "ERROR: Tried and tried but could not start the server"))))
-   ;; any error in following steps will result in a retry
-   (if *server-info*
-       (servdat-status-set! *server-info* 'starting)
-       (set! *server-info* (make-servdat host: ipaddrstr port: portnum)))
-   
-   (debug:print 0 *default-log-port* "INFO: Trying to start server on " ipaddrstr ":" portnum)
-   (tcp-listen portnum)))
+  (if (is-port-in-use portnum)
+      (begin
+	(portlogger:open-run-close portlogger:set-failed portnum)
+	(debug:print 0 *default-log-port* "WARNING: failed to start on portnum: " portnum ", trying next port")
+	;; (thread-sleep! 0.1)
+	(rmt:try-start-server ipaddrstr
+			      (portlogger:open-run-close
+			       portlogger:find-port)))
+      (begin
+	(if (not *server-info*)
+	    (set! *server-info* (make-servdat
+				 host: ipaddrstr
+				 port: portnum)))
+	(servdat-status-set! *server-info* 'starting)
+	(servdat-port-set!   *server-info* portnum)
+	(if (not (servdat-rep *server-info*))
+	    (servdat-rep-set!    *server-info*  (nn-socket 'rep)))
+	(let* ((rep (servdat-rep *server-info*)))
+	  (debug:print 0 *default-log-port* "INFO: Trying to start server on " ipaddrstr ":" portnum)
+	  (handle-exceptions
+	   exn
+	   (begin
+	     (print-error-message exn)
+	     (if (< portnum 64000)
+		 (begin 
+		   (debug:print 0 *default-log-port* "WARNING: attempt to start server failed. Trying again ...")
+		   (debug:print 0 *default-log-port* " message: " ((condition-property-accessor 'exn 'message) exn))
+		   (debug:print 5 *default-log-port* "exn=" (condition->list exn))
+		   (portlogger:open-run-close portlogger:set-failed portnum)
+		   (debug:print 0 *default-log-port* "WARNING: failed to start on portnum: " portnum ", trying next port")
+		   ;; (thread-sleep! 0.1)
+		   (rmt:try-start-server ipaddrstr
+					 (portlogger:open-run-close portlogger:find-port)))
+		 (begin
+		   (print "ERROR: Tried and tried but could not start the server, stopping at port "portnum))))
+	   (nn-bind rep (conc "tcp://*:" portnum))
+	   rep)))))
 
 ;;======================================================================
 ;; S E R V E R   U T I L I T I E S 
 ;;======================================================================
 
@@ -1796,31 +1860,33 @@
 (define (server-address srv-pkt)
   (conc (alist-ref 'host srv-pkt) ":"
 	(alist-ref 'port srv-pkt)))
 	
 (define (server-ready? host port key) ;; server-address is host:port
-  (let-values (((i o)(handle-exceptions
-		      exn
-		      (values #f #f)
-		      (tcp-connect host port))))
-    (if (and i o)
-	(begin
-	  (write `((cmd . ping)
-		   (key . ,key)
-		   (params . ())) o)
-	  (let ((res (with-input-from-port i
-		       read)))
-	    (close-output-port o)
-	    (close-input-port i)
-	    res))
+;;  (let-values (((i o)(handle-exceptions
+;;		      exn
+;;		      (values #f #f)
+;;		      (tcp-connect host port))))
+;;    (if (and i o)
+  (let* ((data (sexpr->string  `((cmd . ping)
+				 (key . ,key)
+				 (params . ()))))
+	 (res  (open-send-receive-nn (conc host ":" port) data)))
+    (string->sexpr res)))
+
+;; (let ((res (with-input-from-port i
+;; 		       read)))
+;; 	    (close-output-port o)
+;; 	    (close-input-port i)
+;; 	    res))
 ;; 	    (if (string? res)
 ;; 		(string->sexpr res)
 ;; 		res)))
-	(begin ;; connection failed
-	  (debug:print-info 0 *default-log-port* "Server at "host":"port" is not responding.")
-	  #f))))
- 	      
+;;     (begin ;; connection failed
+;; 	  (debug:print-info 0 *default-log-port* "Server at "host":"port" is not responding.")
+;; 	  #f))))
+
 ;; (define (loop-test host port data) ;; server-address is host:port
 ;;   ;; ping the server and ask it
 ;;   ;; if it ready
 ;;   ;; (let* ((sdat (servdat-init #f host port #f)))
 ;;   ;;   (http-transport:send-receive sdat "abc" 'ping '())))
@@ -1970,18 +2036,38 @@
 			(equal? sdat last-sdat)
 			sdat))))))))
 
 (define (rmt:register-server remote apath iface port server-key dbname)
   (rmt:open-main-connection remote apath) ;; we need a channel to main.db
-  (rmt:send-receive-real remote apath ;; params: host port servkey pid ipaddr dbpath
-			 (db:run-id->dbname #f) 'register-server `(,iface
-								   ,port
-								   ,server-key
-								   ,(current-process-id)
-								   ,iface
-								   ,apath
-								   ,dbname)))
+  (rmt:send-receive-real remote apath      ;; params: host port servkey pid ipaddr dbpath
+			 (db:run-id->dbname #f)
+			 'register-server `(,iface
+					    ,port
+					    ,server-key
+					    ,(current-process-id)
+					    ,iface
+					    ,apath
+					    ,dbname)))
+
+(define (rmt:get-count-servers remote apath)
+  (rmt:open-main-connection remote apath) ;; we need a channel to main.db
+  (rmt:send-receive-real remote apath      ;; params: host port servkey pid ipaddr dbpath
+			 (db:run-id->dbname #f)
+			 'get-count-servers `(,apath
+					      )))
+
+(define (rmt:deregister-server remote apath iface port server-key dbname)
+  (rmt:open-main-connection remote apath) ;; we need a channel to main.db
+  (rmt:send-receive-real remote apath      ;; params: host port servkey pid ipaddr dbpath
+                         (db:run-id->dbname #f)
+                         'deregister-server `(,iface
+                                              ,port
+                                              ,server-key
+                                              ,(current-process-id)
+                                              ,iface
+                                              ,apath
+                                              ,dbname)))
 
 (define (http-transport:wait-for-stable-interface #!optional (num-tries-allowed 100))
   ;; wait until *server-info* stops changing
   (let* ((stime (current-seconds)))
     (let loop ((last-host  #f)
@@ -2040,15 +2126,16 @@
 	(http-transport:wait-for-server pkts-dir dbname server-key)
 	(http-transport:wait-for-stable-interface))
     ;; this is our forever loop
     (let* ((iface             (servdat-host *server-info*))
 	   (port              (servdat-port *server-info*)))
-      (let loop ((count         0)
+      (let loop ((count          0)
 		 (bad-sync-count 0)
 		 (start-time     (current-milliseconds)))
 	
-	(if (not is-main)
+	(if (and (not is-main)
+		 (common:low-noise-print 60 "servdat-status"))
 	    (debug:print-info 0 *default-log-port* "servdat-status is " (servdat-status *server-info*)))
 
 	;; set up the database handle
 	(mutex-lock! *heartbeat-mutex*)
 	(if (not *dbstruct-db*) ;; no db opened yet, open the db and register with main if appropriate
@@ -2068,20 +2155,28 @@
 			  (exit)))))
 	      (debug:print 0 *default-log-port*
 			   "SERVER: running, db "dbname" opened, megatest version: "
 			   (common:get-full-version))
 	      ;; start the watchdog
-	      (if watchdog
+
+	      ;; is this really needed?
+	      
+	      #;(if watchdog
 		  (if (not (member (thread-state watchdog)
 				   '(ready running blocked
 					   sleeping dead)))
 		      (begin
 			(debug:print-info 0 *default-log-port* "Starting watchdog thread (in state "(thread-state watchdog)")")
 			(thread-start! watchdog))
 		      (debug:print-info 0 *default-log-port* "Not starting watchdog thread (in state "(thread-state watchdog)")"))
 		  (debug:print 0 *default-log-port* "ERROR: *watchdog* not setup, cannot start it."))
-	      #;(loop (+ count 1) bad-sync-count start-time)))
+	      #;(loop (+ count 1) bad-sync-count start-time)
+	      ))
+
+	(debug:print-info 0 *default-log-port* "syncing "*toppath*" "dbname" at "(current-seconds))
+	(db:sync-inmem->disk *dbstruct-db* *toppath* dbname force-sync: #t)
+	
 	(mutex-unlock! *heartbeat-mutex*)
 	
 	;; when things go wrong we don't want to be doing the various
 	;; queries too often so we strive to run this stuff only every
 	;; four seconds or so.
@@ -2103,64 +2198,37 @@
 	      (db:print-current-query-stats)))
 	(let* ((hrs-since-start  (/ (- (current-seconds) server-start-time) 3600)))
 	  (cond
 	   ((and *server-run*
 		 (> (+ last-access server-timeout)
-		    (current-seconds)))
+		    (current-seconds))
+		 (if is-main
+		     (> (rmt:get-count-servers *rmt:remote* *toppath*) 1)
+		     #t))
 	    (if (common:low-noise-print 120 "server continuing")
 		(debug:print-info 0 *default-log-port* "Server continuing, seconds since last db access: " (- (current-seconds) last-access)))
 	    (loop 0 bad-sync-count (current-milliseconds)))
 	   (else
+	    (set! *unclean-shutdown* #f)
 	    (debug:print-info 0 *default-log-port* "Server timed out. seconds since last db access: " (- (current-seconds) last-access))
-	    (http-transport:server-shutdown port))))))))
-
-(define (http-transport:server-shutdown port)
-  (begin
-    ;;(BB> "http-transport:server-shutdown called")
-    (debug:print-info 0 *default-log-port* "Starting to shutdown the server. pid="(current-process-id))
-    ;;
-    ;; start_shutdown
-    ;;
-
-    ;; deregister the server
-
-    
-    (bdat-time-to-exit-set! *bdat* #t) ;; tell on-exit to be fast as we've already cleaned up
-    (portlogger:open-run-close portlogger:set-port port "released")
-    (thread-sleep! 1)
-
-    ;; (debug:print-info 0 *default-log-port* "Max cached queries was    " *max-cache-size*)
-    ;; (debug:print-info 0 *default-log-port* "Number of cached writes   " *number-of-writes*)
-    ;; (debug:print-info 0 *default-log-port* "Average cached write time "
-    ;; 		      (if (eq? *number-of-writes* 0)
-    ;; 			  "n/a (no writes)"
-    ;; 			  (/ *writes-total-delay*
-    ;; 			     *number-of-writes*))
-    ;; 		      " ms")
-    ;; (debug:print-info 0 *default-log-port* "Number non-cached queries "  *number-non-write-queries*)
-    ;; (debug:print-info 0 *default-log-port* "Average non-cached time   "
-    ;; 		      (if (eq? *number-non-write-queries* 0)
-    ;; 			  "n/a (no queries)"
-    ;; 			  (/ *total-non-write-delay* 
-    ;; 			     *number-non-write-queries*))
-    ;; 		      " ms")
-    
-    (db:print-current-query-stats)
-    (common:save-pkt `((action . exit)
-                       (T      . server)
-                       (pid    . ,(current-process-id)))
-                     *configdat* #t)
-    (debug:print-info 0 *default-log-port* "Server shutdown complete. Exiting")
-    (exit)))
+	    (debug:print-info 0 *default-log-port* "Starting to shutdown the server. pid="(current-process-id))
+	    (rmt:server-shutdown)
+	    (portlogger:open-run-close portlogger:set-port port "released")
+	    (exit)
+	    #;(debug:print-info 0 *default-log-port* "Sending 'quit to server, received: "
+			      (open-send-receive-nn (conc iface":"port)      ;; do this here and not in server-shutdown
+						    (sexpr->string 'quit)))
+	    )))))))
 
 ;; Call this to start the actual server
 ;;
 ;; all routes though here end in exit ...
 ;;
 ;; This is the point at which servers are started
 ;;
 (define (rmt:server-launch dbname)
+  (debug:print-info 0 *default-log-port* "Entered rmt:server-launch")
   (let* ((th2 (make-thread (lambda ()
 			     (debug:print-info 0 *default-log-port* "Server run thread started")
 			     (rmt:run (if (args:get-arg "-server")
 					  (args:get-arg "-server")
 					  "-")
@@ -2172,12 +2240,13 @@
     (thread-start! th2)
     (thread-sleep! 0.252) ;; give the server time to settle before starting the keep-running monitor.
     (thread-start! th3)
     (set! *didsomething* #t)
     (thread-join! th2)
-  (exit))
-
+    (thread-join! th3)
+    ;; (exit))
+  )
   #f
   )
 	    
 ;; Generate a unique signature for this process, used at both client and
 ;; server side
@@ -2192,10 +2261,110 @@
 (define (rmt:get-signature) 
   (if *my-signature* *my-signature*
       (let ((sig (rmt:mk-signature)))
         (set! *my-signature* sig)
         *my-signature*)))
+
+;;======================================================================
+;; Nanomsg transport
+;;======================================================================
+
+(define (is-port-in-use port-num)
+  (let* ((ret #f))
+    (let-values (((inp oup pid)
+		  (process "netstat" (list  "-tulpn" ))))
+      (let loop ((inl (read-line inp)))
+        (if (not (eof-object? inl))
+            (begin 
+	      (if (string-search (regexp (conc ":" port-num)) inl)
+		  (begin
+					;(print "Output: "  inl)
+		    (set! ret  #t))
+		  (loop (read-line inp)))))))
+    ret))
+
+;;start a server, returns the connection
+;;
+(define (start-nn-server portnum )
+  (let ((rep (nn-socket 'rep)))
+    (handle-exceptions
+     exn
+     (let ((emsg ((condition-property-accessor 'exn 'message) exn)))
+       (print "ERROR: Failed to start server \"" emsg "\"")
+       (exit 1))
+      
+     (nn-bind rep (conc "tcp://*:" portnum)))
+    rep))
+
+;; open connection to server, send message, close connection
+;;
+(define (open-send-close-nn host-port msg #!key (timeout 3) ) ;; default timeout is 3 seconds
+  (let ((req  (nn-socket 'req))
+        (uri  (conc "tcp://" host-port))
+        (res  #f)
+        ;; (contacts (alist-ref 'contact attrib))
+        ;; (mode (alist-ref 'mode attrib))
+	) 
+    (handle-exceptions
+     exn
+     (let ((emsg ((condition-property-accessor 'exn 'message) exn)))
+       ;; Send notification       
+       (debug:print 0 *default-log-port* "ERROR: Failed to connect / send to " uri " message was \"" emsg "\"" )
+       #f)
+     (nn-connect req uri)
+     ;; (print "Connected to the server " )
+     (nn-send req msg)
+     ;; (print "Request Sent")  
+     (let* ((th1  (make-thread (lambda ()
+                                 (let ((resp (nn-recv req)))
+                                   (nn-close req)
+                                   (set! res (if (equal? resp "ok")
+                                                 #t
+                                                 #f))))
+                               "recv thread"))
+            (th2 (make-thread (lambda ()
+                                (thread-sleep! timeout)
+                                (thread-terminate! th1))
+			      "timer thread")))
+       (thread-start! th1)
+       (thread-start! th2)
+       (thread-join! th1)
+       res))))
+
+(define (open-send-receive-nn host-port msg #!key (timeout 3) ) ;; default timeout is 3 seconds
+  (let ((req  (nn-socket 'req))
+        (uri  (conc "tcp://" host-port))
+        (res  #f)
+	;;        (contacts (alist-ref 'contact attrib))
+        ;; (mode (alist-ref 'mode attrib))
+	) 
+    (handle-exceptions
+     exn
+     (let ((emsg ((condition-property-accessor 'exn 'message) exn)))
+       ;; Send notification      
+       (debug:print 0 *default-log-port* "ERROR: Failed to connect / send to " uri " message was \"" emsg "\", exn=" exn)
+       #f)
+     (nn-connect req uri)
+     ;; (print "Connected to the server " )
+     (nn-send req msg)
+     ;; (print "Request Sent")  
+     ;; receive code here
+     ;;(print (nn-recv req))
+     (let* ((th1  (make-thread (lambda ()
+                                 (let ((resp (nn-recv req)))
+                                   (nn-close req)
+                                   (print resp)
+                                   (set! res resp)))
+                               "recv thread"))
+            (th2 (make-thread (lambda ()
+                                (thread-sleep! timeout)
+                                (thread-terminate! th1))
+                             "timer thread")))
+       (thread-start! th1)
+       (thread-start! th2)
+       (thread-join! th1)
+       res))))
 
 ;;======================================================================
 ;; S E R V E R   U T I L I T I E S 
 ;;======================================================================
 

Index: runsmod.scm
==================================================================
--- runsmod.scm
+++ runsmod.scm
@@ -345,11 +345,11 @@
   (let* ((keys               (keys:config-get-fields *configdat*))
 	 (keyvals            (keys:target->keyval keys target))
 	 (run-id             (rmt:register-run keyvals runname "new" "n/a" user (args:get-arg "-contour")))  ;;  test-name)))
 	 ;; (deferred          '()) ;; delay running these since they have a waiton clause
 	 (runconfigf         (conc  *toppath* "/runconfigs.config"))
-         (dbfile             (conc  *toppath* "/megatest.db"))
+         (dbfile             (conc  *toppath* "/.db/main.db"))
          (readonly-mode      (not (file-writable? dbfile)))
 	 (test-records       (make-hash-table))
 	 ;; need to process runconfigs before generating these lists
 	 (all-tests-registry #f)  ;; (tests:get-all)) ;; (tests:get-valid-tests (make-hash-table) test-search-path)) ;; all valid tests to check waiton names
 	 (all-test-names     #f)  ;; (hash-table-keys all-tests-registry))

Index: tests/unittests/basicserver.scm
==================================================================
--- tests/unittests/basicserver.scm
+++ tests/unittests/basicserver.scm
@@ -63,11 +63,11 @@
 ;; 				     (rmt:conn-port *main*) tdat)))
 ;; 	  (list 'a
 ;; 		'(a "b" 123 1.23 )))
 (test #f #t (rmt:send-receive 'ping #f 'hello))
 
-(define *db* (db:setup #f))
+(define *db* (db:setup ".db/main.db"))
 
 ;; these let me cut and paste from source easily
 (define apath *toppath*)
 (define dbname ".db/2.db")
 (define remote *rmt:remote*)

Index: tests/unittests/server.scm
==================================================================
--- tests/unittests/server.scm
+++ tests/unittests/server.scm
@@ -32,490 +32,51 @@
 ;;  rmt:send-receive-real
 ;;  rmt:send-receive
  ;; sexpr->string
  ;; server-ready?
  ;; rmt:register-server
+ ;;  rmt:deregister-server
  ;; rmt:open-main-connection
  ;; rmt:general-open-connection
- ;; rmt:get-conny
+ ;; rmt:get-conn
  ;; common:watchdog
  ;; rmt:find-main-server
  ;; get-all-server-pkts
  ;; get-viable-servers
  ;; get-best-candidate
  ;; api:run-server-process
+ ;; api:process-request
  ;; rmt:run
  ;; rmt:try-start-server
  )
 
-(define *db* (db:setup #f))
+(define *db* (db:setup ".db/main.db"))
 
 ;; these let me cut and paste from source easily
 (define apath *toppath*)
 (define dbname ".db/2.db")
 (define remote *rmt:remote*)
 (define keyvals  '(("SYSTEM" "a")("RELEASE" "b")))
 
 (test #f #t (rmt:open-main-connection remote apath))
+(test #f #t (rmt:conn? (rmt:get-conn *rmt:remote* *toppath* ".db/main.db")))
 (test #f #t (rmt:conn? (rmt:get-conn *rmt:remote* *toppath* ".db/main.db")))
 (test #f 'server-started (rmt:send-receive-real *rmt:remote* *toppath* ".db/main.db" 'get-server `(,apath ,dbname)))
 
 (thread-sleep! 2)
 (test #f #t (list? (rmt:general-open-connection *rmt:remote* *toppath* ".db/2.db")))
 
 (test #f '("SYSTEM" "RELEASE") (rmt:get-keys))
 (test #f 1 (rmt:send-receive 'register-run #f (list keyvals "run1" "new" "n/a" "justme" #f)))
 (print "Got here.")
-(test #t 1 (rmt:send-receive 'register-run 1 (list keyvals "run2" "new" "n/a" "justme" #f)))
-
-(test #f 1 (rmt:register-run keyvals "run2" "new" "n/a" "justme" #f))
-
-;; (delete-file* "logs/1.log")
-;; (define run-id 1)
-
-;; (test "setup for run" #t (begin (launch:setup)
-;;  				(string? (getenv "MT_RUN_AREA_HOME"))))
-;; 
-;; (test #f #t (and (server:kind-run *toppath*) #t))
-;; 
-;; 
-;; (define user    (current-user-name))
-;; (define runname "mytestrun")
-;; (define keys    (rmt:get-keys))
-;; (define runinfo #f)
-;; (define keyvals '(("SYSTEM" "abc")("RELEASE" "def")))
-;; (define header  (list "SYSTEM" "RELEASE" "id" "runname" "state" "status" "owner" "event_time"))
-;; 
-;; ;; Setup
-;; ;;
-;; ;; (test #f #f  (not (client:setup run-id)))
-;; ;; (test #f #f  (not (hash-table-ref/default *runremote* run-id #f)))
-;; 
-;; ;; Login
-;; ;;
-;; (test #f'(#t "successful login")
-;;       (rmt:login run-id))
-;; 
-;; ;; Keys
-;; ;;
-;; (test #f '("SYSTEM" "RELEASE")  (rmt:get-keys))
-;; 
-;; ;; No data in db
-;; ;;
-;; (test #f '() (rmt:get-all-run-ids))
-;; (test #f #f  (rmt:get-run-name-from-id run-id))
-;; (test #f 
-;;       (vector
-;;        header
-;;        (vector #f #f #f #f))
-;;       (rmt:get-run-info run-id))
-;; 
-;; ;; Insert data into db
-;; ;;
-;; (test #f 1 (rmt:register-run keyvals runname "new" "n/a" user))
-;; ;; (test #f #f (rmt:get-runs-by-patt keys runname))
-;; (test #f #t (rmt:general-call 'register-test run-id run-id "test-one" ""))
-;; (define test-one-id #f)
-;; (test #f 1  (let ((test-id (rmt:get-test-id run-id "test-one" "")))
-;; 	      (set! test-one-id test-id)
-;; 	      test-id))
-;; (define test-one-rec #f)
-;; (test #f "test-one" (let ((test-rec (rmt:get-test-info-by-id run-id test-one-id)))
-;; 		      (set! test-one-rec test-rec)
-;; 		      (vector-ref test-rec 2)))
-;; 
-;; ;; With data in db
-;; ;;
-;; (print "Using runame=" runname)
-;; (test #f '(1)    (rmt:get-all-run-ids))
-;; (test #f runname (rmt:get-run-name-from-id run-id))
-;; (test #f 
-;;       runname
-;;       (let ((run-info (rmt:get-run-info run-id)))
-;; 	(db:get-value-by-header (db:get-rows run-info)
-;; 				(db:get-header run-info)
-;; 				"runname")))
-;; 
-;; ;; test killing server
-;; ;;
-;; (for-each
-;;  (lambda (run-id)
-;;    (test #f #t (and (tasks:kill-server-run-id run-id) #t))
-;;    (test #f #f (tasks:server-running-or-starting? (db:delay-if-busy (tasks:open-db)) run-id)))
-;;  (list 0 1))
-;; 
-;; ;; Tests to assess reading/writing while servers are starting/stopping
-;; ;; NO LONGER APPLICABLE
-;; 
-;; ;; Server tests go here
-;; (define (server-tests-dont-run-right-now)
-;; (for-each
-;;  (lambda (run-id)
-;;    (test #f #f (tasks:server-running-or-starting? (db:delay-if-busy (tasks:open-db)) run-id))
-;;    (server:kind-run run-id)
-;;    (test "did server start within 20 seconds?"
-;; 	 #t
-;; 	 (let loop ((remtries 20)
-;; 		    (running (tasks:server-running-or-starting? (db:delay-if-busy
-;; 								 (tasks:open-db))
-;; 								run-id)))
-;; 	   (if running 
-;; 	       (> running 0)
-;; 	       (if (> remtries 0)
-;; 		   (begin
-;; 		     (thread-sleep! 1)
-;; 		     (loop (- remtries 1)
-;; 			   (tasks:server-running-or-starting? (db:delay-if-busy
-;; 							       (tasks:open-db))
-;; 							      run-id)))))))
-;;    
-;;    (test "did server become available" #t
-;; 	 (let loop ((remtries 10)
-;; 		    (res      (tasks:get-server (db:delay-if-busy (tasks:open-db)) run-id)))
-;; 	   (if res
-;; 	       (vector? res)
-;; 	       (begin
-;; 		 (if (> remtries 0)
-;; 		     (begin
-;; 		       (thread-sleep! 1.1)
-;; 		       (loop (- remtries 1)(tasks:get-server (db:delay-if-busy (tasks:open-db)) run-id)))
-;; 		     res)))))
-;;    )
-;;  (list 0 1)))
-;; 
-;; (define start-time (current-seconds))
-;; (define (reading-writing-while-server-starting-stopping-dont-run-now)
-;; (let loop ((test-state 'start))
-;;   (let* ((server-dats (tasks:get-server-records (db:delay-if-busy (tasks:open-db)) run-id))
-;; 	 (first-dat   (if (not (null? server-dats))
-;; 			  (car server-dats)
-;; 			  #f)))
-;;     (map (lambda (dat)
-;; 	   (apply print (intersperse (vector->list dat) ", ")))
-;; 	 server-dats)
-;;     (test #f test-one-rec (rmt:get-test-info-by-id run-id test-one-id))
-;;     (thread-sleep! 1)
-;;     (case test-state
-;;       ((start)
-;;        (print "Trying to start server")
-;;        (server:kind-run run-id)
-;;        (loop 'server-started))
-;;       ((server-started)
-;;        (case (if first-dat (vector-ref first-dat 0) 'blah)
-;; 	 ((running)
-;; 	  (print "Server appears to be running. Now ask it to shutdown")
-;; 	  (rmt:kill-server run-id)
-;; 	  (loop 'server-shutdown))
-;; 	 ((shutting-down)
-;; 	  (loop test-state))
-;; 	 (else (print "Don't know what to do if get here"))))
-;;       ((server-shutdown)
-;;        (loop test-state)))))
-;; )
-
-;;======================================================================
-;; END OF TESTS
-;;======================================================================
-
-
-;; (test #f #f (client:setup run-id))
-
-;; (set! *transport-type* 'http)
-;; 
-;; (test "setup for run" #t (begin (launch:setup-for-run)
-;; 				(string? (getenv "MT_RUN_AREA_HOME"))))
-;; 
-;; (test "server-register, get-best-server" #t (let ((res #f))
-;; 					      (open-run-close tasks:server-register tasks:open-db 1 "bob" 1234 100 'live 'http)
-;; 					      (set! res (open-run-close tasks:get-best-server tasks:open-db))
-;; 					      (number? (vector-ref res 3))))
-;; 
-;; (test "de-register server" #f (let ((res #f))
-;; 				(open-run-close tasks:server-deregister tasks:open-db "bob" port: 1234)
-;; 				(vector? (open-run-close tasks:get-best-server tasks:open-db))))
-;; 
-;; (define server-pid #f)
-;; 
-;; ;; Not sure how the following should work, replacing it with system of megatest -server
-;; ;; (test "launch server" #t (let ((pid (process-fork (lambda ()
-;; ;; 						    ;; (daemon:ize)
-;; ;; 						    (server:launch 'http)))))
-;; ;; 			   (set! server-pid pid)
-;; ;; 			   (number? pid)))
-;; (system "../../bin/megatest -server - -debugbcom 22 > server.log 2> server.log &")
-;; 
-;; (let loop ((n 10))
-;;   (thread-sleep! 1) ;; need to wait for server to start.
-;;   (let ((res (open-run-close tasks:get-best-server tasks:open-db)))
-;;     (print "tasks:get-best-server returned " res)
-;;     (if (and (not res)
-;; 	     (> n 0))
-;; 	(loop (- n 1)))))
-;; 
-;; (test "get-best-server" #t (begin 
-;; 			     (client:launch)
-;; 			     (let ((dat (open-run-close tasks:get-best-server tasks:open-db)))
-;; 			       (vector? dat))))
-;; 
-;; (define *keys*               (keys:config-get-fields *configdat*))
-;; (define *keyvals*            (keys:target->keyval *keys* "a/b/c"))
-;; 
-;; (test #f #t                       (string? (car *runremote*)))
-;; (test #f '(#t "successful login") (rmt:login)) ;;  *runremote* *toppath* *my-client-signature*)))
-;; 
-;; (test #f #f                       (rmt:get-test-info-by-id 99)) ;; get non-existant test
-;; 
-;; ;; RUNS
-;; (test #f 1                        (rmt:register-run  *keyvals* "firstrun" "new" "n/a" (current-user-name)))
-;; (test "get run info"  "firstrun"  (let ((rinfo (rmt:get-run-info 1)))
-;; 				    (vector-ref (vector-ref rinfo 1) 3)))
-;; (test "get runname from id" "firstrun" (rmt:get-run-name-from-id 1))
-;; 
-;; ;; TESTS
-;; (test "get tests (no data)" '()   (rmt:get-tests-for-run 1 "%" '() '() #f #f #f #f #f #f))
-;; (test "register test"       #t    (rmt:general-call 'register-test 1 "test1" ""))
-;; (test "get tests (some data)"  1  (length (rmt:get-tests-for-run 1 "%" '() '() #f #f #f #f #f #f)))
-;; (test "get test id"            1  (rmt:get-test-id 1 "test1" ""))
-;; (test "sync back"              #t (> (rmt:sync-inmem->db) 0))
-;; (test "get test id from main"  1  (db:get-test-id *db* 1 "test1" ""))
-;; (test "get keys"               #t (list? (rmt:get-keys)))
-;; (test "set comment"            #t (begin (rmt:general-call 'set-test-comment "this is a comment" 1) #t))
-;; (test "get comment" "this is a comment" (let ((trec (rmt:get-test-info-by-id 1)))
-;; 					  (db:test-get-comment trec)))
-;; 
-;; ;; MORE RUNS
-;; (test "get runs"  #t (let* ((runs   (rmt:get-runs "%" #f #f '()))
-;; 			    (header (vector-ref runs 0))
-;; 			    (data   (vector-ref runs 1)))
-;; 		       (and (list?   header)
-;; 			    (list?   data)
-;; 			    (vector? (car data)))))
-;; 
-;; (test "get local testinfo" "test1" (vector-ref (db:get-testinfo-state-status *db* 1) 2))
-;; (test "get testinfo"       "test1" (vector-ref (rmt:get-testinfo-state-status 1) 2))
-;; 
-;; ;;======================================================================
-;; ;; D B
-;; ;;======================================================================
-;; 
-;; (test "pass fail counts" #t (rmt:general-call 'pass-fail-counts 10 9 1))
-;; (test "get pass fail counts" 19 (let ((dat (rmt:get-test-info-by-id 1)))
-;; 				  (+ (db:test-get-pass_count dat)
-;; 				     (db:test-get-fail_count dat))))
-;; 
-;; (define testregistry (make-hash-table))
-;; (for-each
-;;  (lambda (tname)
-;;    (for-each
-;;     (lambda (itempath)
-;;       (let ((tkey  (conc tname "/" itempath))
-;; 	    (rpass (random 10))
-;; 	    (rfail (random 10)))
-;; 	(hash-table-set! testregistry tkey (list tname itempath))
-;; 	(rmt:general-call 'register-test 1 tname itempath)
-;; 	(let* ((tid  (rmt:get-test-id 1 tname itempath))
-;; 	       (tdat (rmt:get-test-info-by-id tid)))
-;; 	  (rmt:general-call 'pass-fail-counts rpass rfail (db:test-get-id tdat))
-;; 	  (let* ((resdat (rmt:get-test-info-by-id tid)))
-;; 	    (test "set/get pass fail counts" (list rpass rfail)
-;; 		  (list (db:test-get-pass_count resdat)
-;; 			(db:test-get-fail_count resdat)))))))
-;;     (list "" "a" "b" "c" "d" "e" "f" "g" "h" "i" "j")))
-;;  (list "test1" "test2" "test3" "test4" "test5"))
-;; 
-;; 
-;; (test #f '(#t "exit process started") (rmt:kill-server)) ;; *toppath* *my-client-signature* #f)))
-;; 
+
+(test #f 1 (rmt:send-receive 'register-run 1 (list keyvals "run1" "new" "n/a" "justme" #f)))
+
+(test #f 2 (rmt:register-run keyvals "run2" "new" "n/a" "justme" #f))
+;; (test #f 2 (rmt:deregister-server *rmt:remote* *toppath* iface port server-key dbname
+
+(test #f 2 (rmt:get-count-servers *rmt:remote* *toppath*))
+
+(test #f "run2" (rmt:get-run-name-from-id 2))
 
 ;; (exit)
 
-
-;; all old stuff below
-
-
-
-
-(delete-file* "logs/1.log")
-(define run-id 1)
-
-(test "setup for run" #t (begin (launch:setup-for-run)
- 				(string? (getenv "MT_RUN_AREA_HOME"))))
-
-;; Insert data into db
-;;
-(define user    (current-user-name))
-(define runname "mytestrun")
-(define keys    (rmt:get-keys))
-(define runinfo #f)
-(define keyvals '(("SYSTEM" "abc")("RELEASE" "def")))
-(define header  (list "SYSTEM" "RELEASE" "id" "runname" "state" "status" "owner" "event_time"))
-
-(test #f 1 (rmt:register-run keyvals runname "new" "n/a" user))
-;; (test #f #f (rmt:get-runs-by-patt keys runname))
-(test #f #t (rmt:general-call 'register-test run-id run-id "test-one" ""))
-(define test-one-id #f)
-(test #f 30001  (let ((test-id (rmt:get-test-id run-id "test-one" "")))
-	      (set! test-one-id test-id)
-	      test-id))
-(define test-one-rec #f)
-(test #f "test-one" (let ((test-rec (rmt:get-test-info-by-id run-id test-one-id)))
-		      (set! test-one-rec test-rec)
-		      (vector-ref test-rec 2)))
-
-(use trace)
-(import trace)
-;; (trace
-;;  rmt:send-receive
-;;  rmt:open-qry-close-locally
-;; )
-
-;; Tests to assess reading/writing while servers are starting/stopping
-(define start-time (current-seconds))
-(let loop ((test-state 'start))
-  (let* ((server-dats (tasks:get-server-records (db:delay-if-busy (tasks:open-db)) run-id))
-	 (first-dat   (if (not (null? server-dats))
-			  (car server-dats)
-			  #f))
-	 (server-state (or (and first-dat (string->symbol (vector-ref first-dat 8))) 'no-dat)))
-    (if first-dat
-	(map (lambda (dat)
-	       (apply print (intersperse (vector->list dat) ", ")))
-	     server-dats)
-	(print "No server"))
-    (test #f test-one-rec (rmt:get-test-info-by-id run-id test-one-id))
-    (thread-sleep! 1)
-    (case test-state
-      ((start)
-       (print "Trying to start server")
-       (server:kind-run run-id)
-       (loop 'server-started))
-      ((server-started)
-       (case server-state 
-	 ((running)
-	  (print "Server appears to be running. Now ask it to shutdown")
-	  (rmt:kill-server run-id)
-	  ;; (trace rmt:open-qry-close-locally rmt:send-receive)
-	  (loop 'shutdown-started))
-	 ((available)
-	  (loop test-state))
-	 ((shutting-down)
-	  (loop test-state))
-	 ((no-dat)
-	  (loop test-state))
-	 (else (print "Don't know what to do if get here"))))
-      ((shutdown-started)
-       (case server-state 
-	 ((no-dat)
-	  (print "Server appears to have shutdown, ending this test"))
-	 (else
-	  (loop test-state)))))))
-
-(exit)	 
-       
-;; (set! *transport-type* 'http)
-;; 
-;; (test "setup for run" #t (begin (setup-for-run)
-;; 				(string? (getenv "MT_RUN_AREA_HOME"))))
-;; 
-;; (test "server-register, get-best-server" #t (let ((res #f))
-;; 					      (open-run-close tasks:server-register tasks:open-db 1 "bob" 1234 100 'live 'http)
-;; 					      (set! res (open-run-close tasks:get-best-server tasks:open-db))
-;; 					      (number? (vector-ref res 3))))
-;; 
-;; (test "de-register server" #f (let ((res #f))
-;; 				(open-run-close tasks:server-deregister tasks:open-db "bob" port: 1234)
-;; 				(vector? (open-run-close tasks:get-best-server tasks:open-db))))
-;; 
-;; (define server-pid #f)
-;; 
-;; ;; Not sure how the following should work, replacing it with system of megatest -server
-;; ;; (test "launch server" #t (let ((pid (process-fork (lambda ()
-;; ;; 						    ;; (daemon:ize)
-;; ;; 						    (server:launch 'http)))))
-;; ;; 			   (set! server-pid pid)
-;; ;; 			   (number? pid)))
-;; (system "../../bin/megatest -server - -debug 22 > server.log 2> server.log &")
-;; 
-;; (let loop ((n 10))
-;;   (thread-sleep! 1) ;; need to wait for server to start.
-;;   (let ((res (open-run-close tasks:get-best-server tasks:open-db)))
-;;     (print "tasks:get-best-server returned " res)
-;;     (if (and (not res)
-;; 	     (> n 0))
-;; 	(loop (- n 1)))))
-;; 
-;; (test "get-best-server" #t (begin 
-;; 			     (client:launch)
-;; 			     (let ((dat (open-run-close tasks:get-best-server tasks:open-db)))
-;; 			       (vector? dat))))
-;; 
-;; (define *keys*               (keys:config-get-fields *configdat*))
-;; (define *keyvals*            (keys:target->keyval *keys* "a/b/c"))
-;; 
-;; (test #f #t                       (string? (car *runremote*)))
-;; (test #f '(#t "successful login") (rmt:login)) ;;  *runremote* *toppath* *my-client-signature*)))
-;; 
-;; (test #f #f                       (rmt:get-test-info-by-id 1 99)) ;; get non-existant test
-;; 
-;; ;; RUNS
-;; (test #f 1                        (rmt:register-run  *keyvals* "firstrun" "new" "n/a" (current-user-name)))
-;; (test "get run info"  "firstrun"  (let ((rinfo (rmt:get-run-info 1)))
-;; 				    (vector-ref (vector-ref rinfo 1) 3)))
-;; (test "get runname from id" "firstrun" (rmt:get-run-name-from-id 1))
-;; 
-;; ;; TESTS
-;; (test "get tests (no data)" '()   (rmt:get-tests-for-run 1 "%" '() '() #f #f #f #f #f #f))
-;; (test "register test"       #t    (rmt:general-call 'register-test 1 1 "test1" ""))
-;; (test "get tests (some data)"  1  (length (rmt:get-tests-for-run 1 "%" '() '() #f #f #f #f #f #f)))
-;; (test "get test id"            1  (rmt:get-test-id 1 "test1" ""))
-;; 
-;; (test "sync back"              #t (> (rmt:sync-inmem->db) 0))
-;; (test "get test id from main"  1  (db:get-test-id *db* 1 "test1" ""))
-;; 
-;; (test "get keys"               #t (list? (rmt:get-keys)))
-;; (test "set comment"            #t (begin (rmt:general-call 'set-test-comment 1 "this is a comment" 1) #t))
-;; (test "get comment" "this is a comment" (let ((trec (rmt:get-test-info-by-id 1 1)))
-;; 					  (db:test-get-comment trec)))
-;; 
-;; ;; MORE RUNS
-;; (test "get runs"  #t (let* ((runs   (rmt:get-runs "%" #f #f '()))
-;; 			    (header (vector-ref runs 0))
-;; 			    (data   (vector-ref runs 1)))
-;; 		       (and (list?   header)
-;; 			    (list?   data)
-;; 			    (vector? (car data)))))
-;; 
-;; (test "get local testinfo" "test1" (vector-ref (db:get-testinfo-state-status *db* 1 1) 2))
-;; (test "get testinfo"       "test1" (vector-ref (rmt:get-testinfo-state-status 1 1) 2))
-;; 
-;; ;;======================================================================
-;; ;; D B
-;; ;;======================================================================
-;; 
-;; (test "pass fail counts" #t (rmt:general-call 'pass-fail-counts 10 9 1))
-;; (test "get pass fail counts" 19 (let ((dat (rmt:get-test-info-by-id 1)))
-;; 				  (+ (db:test-get-pass_count dat)
-;; 				     (db:test-get-fail_count dat))))
-;; 
-;; (define testregistry (make-hash-table))
-;; (for-each
-;;  (lambda (tname)
-;;    (for-each
-;;     (lambda (itempath)
-;;       (let ((tkey  (conc tname "/" itempath))
-;; 	    (rpass (random 10))
-;; 	    (rfail (random 10)))
-;; 	(hash-table-set! testregistry tkey (list tname itempath))
-;; 	(rmt:general-call 'register-test 1 tname itempath)
-;; 	(let* ((tid  (rmt:get-test-id 1 tname itempath))
-;; 	       (tdat (rmt:get-test-info-by-id tid)))
-;; 	  (rmt:general-call 'pass-fail-counts rpass rfail (db:test-get-id tdat))
-;; 	  (let* ((resdat (rmt:get-test-info-by-id tid)))
-;; 	    (test "set/get pass fail counts" (list rpass rfail)
-;; 		  (list (db:test-get-pass_count resdat)
-;; 			(db:test-get-fail_count resdat)))))))
-;;     (list "" "a" "b" "c" "d" "e" "f" "g" "h" "i" "j")))
-;;  (list "test1" "test2" "test3" "test4" "test5"))
-;; 
-;; 
-;; (test #f '(#t "exit process started") (rmt:kill-server)) ;; *toppath* *my-client-signature* #f)))
-;;