Index: fullrununit.sh
==================================================================
--- fullrununit.sh
+++ fullrununit.sh
@@ -1,6 +1,9 @@
 #!/bin/bash
 
-(killall mtest -v;sleep 1;killall mtest -v -9;rm -f tests/simplerun/.db/* tests/simplerun/logs/* tests/basicserver.log) &
-ck5 make -j install &&
-wait  &&
-script -c "ck5 make unit" 
+for x in basicserver server;do 
+    (killall mtest -v;sleep 1;killall mtest -v -9;rm -f tests/simplerun/.db/* tests/simplerun/logs/* tests/$x.log) &
+    ck5 make -j install &&
+	wait  &&
+	script -c "cd tests;ck5 make $x.log" full-$x.log
+done
+

Index: rmtmod.scm
==================================================================
--- rmtmod.scm
+++ rmtmod.scm
@@ -215,13 +215,13 @@
 			   (thread-sleep! 4)
 			   (rmt:open-main-connection remote apath) ;; TODO: Add limit to number of tries
 			   )))
     (if the-srv ;; yes, we have a server, now try connecting to it
 	(let* ((srv-addr (server-address the-srv))
-	       (ipaddr   (alist-ref 'ipaddr the-srv))
-	       (port     (alist-ref 'port   the-srv))
-	       (srvkey   (alist-ref 'Z      the-srv))
+	       (ipaddr   (alist-ref 'ipaddr  the-srv))
+	       (port     (alist-ref 'port    the-srv))
+	       (srvkey   (alist-ref 'servkey the-srv))
 	       (fullpath (db:dbname->path apath dbname))
 	       (srvready (server-ready? ipaddr port srvkey)))
 	  (if srvready
 	      (begin
 		(hash-table-set! (rmt:remote-conns remote)
@@ -232,11 +232,11 @@
 				  fullname: fullpath
 				  hostport: srv-addr
 				  ipaddr: ipaddr
 				  port: port
 				  srvpkt: the-srv
-				  srvkey: srvkey ;; not the same as signature?
+				  srvkey: srvkey ;; generated by rmt:get-signature on the server side
 				  lastmsg: (current-seconds)
 				  expires: (+ (current-seconds) 60) ;; this needs to be gathered during the ping
 				  ))
 		#t)
 	      (start-main-srv)))
@@ -280,11 +280,11 @@
 	 (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)))
 
-(define (rmt:send-receive-setup conn)
+#;(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))))
 	(rmt:conn-inport-set! conn i)
 	(rmt:conn-outport-set! conn o))))
@@ -293,21 +293,26 @@
 ;; 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")
-    (rmt:send-receive-setup conn)
-    (let* ((key     #f)
-	   (payload `((cmd . ,cmd)
-		      (key . ,(rmt:conn-srvpkt conn))
-		      (params . ,params)))
-	   (res      (begin
-		       (write payload (rmt:conn-outport conn))
-		       (with-input-from-port
-			   (rmt:conn-inport conn)
-			 read))))
-      res)))
+    (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))))
 
 
@@ -1586,22 +1591,21 @@
 	  (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))
-	   (dbstruct #f))
+    (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 indat)))
+		(let* ((res (api:process-request *dbstruct-db* indat)))
 		  (set! *db-last-access* (current-seconds))
 		  (write res o)
 		  (loop (read i))))))))
     (let* ((portnum (servdat-port *server-info*)))
       (portlogger:open-run-close portlogger:set-port portnum "released")
@@ -1924,11 +1928,11 @@
 				 (register-server
 				  pkts-dir *srvpktspec*
 				  (get-host-name)
 				  (servdat-port sdat) server-key
 				  (servdat-host sdat) db-file))
-	      (set! *my-signature* (servdat-uuid sdat)) ;; replace with Z
+	      ;; (set! *my-signature* (servdat-uuid sdat)) ;; replace with Z, no, stick with proper key
 	      ;; now read pkts and see if we are a contender
 	      (let* ((all-pkts     (get-all-server-pkts pkts-dir *srvpktspec*))
 		     (viables      (get-viable-servers all-pkts db-file))
 		     (best-srv     (get-best-candidate viables db-file))
 		     (best-srv-key (if best-srv (alist-ref 'servkey best-srv) #f)))
@@ -1936,11 +1940,10 @@
 		;; am I the best-srv, compare server-keys to know
 		(if (equal? best-srv-key server-key)
 		    (if (get-lock-db sdat db-file) ;; (db:get-iam-server-lock *dbstruct-db* *toppath* run-id)
 			(begin
 			  (debug:print 0 *default-log-port* "I'm the server!")
-			  ;; (if (not *server-id*)
 			  (servdat-dbfile-set! sdat db-file)
 			  (servdat-status-set! sdat 'db-locked))
 			(begin
 			  (debug:print 0 *default-log-port* "I'm not the server, exiting.")
 			  (bdat-time-to-exit-set! *bdat* #t)
@@ -1948,10 +1951,13 @@
 			  (exit)))
 		    (begin
 		      (debug:print 0 *default-log-port*
 				   "Keys do not match "best-srv-key", "server-key", exiting.")
 		      (bdat-time-to-exit-set! *bdat* #t)
+		      (delete-file* (conc (get-pkts-dir *toppath*)
+					  "/" (servdat-uuid *server-info*)
+					  ".pkt")) ;; remove immediately instead of waiting for on-exit
 		      (thread-sleep! 0.2)
 		      (exit)))
 		sdat))
 	    (begin ;; sdat not yet contains server info
 	      (debug:print-info 0 *default-log-port* "Still waiting, last-sdat=" last-sdat)
@@ -2002,11 +2008,11 @@
 	  (loop curr-host curr-port (+ tries 1)))
 	 ((< (- (current-seconds) stime) 1) ;; keep up the looping until at least 3 seconds have passed
 	  (thread-sleep! 0.5)
 	  (loop curr-host curr-port (+ tries 1)))
 	 (else
-	  (rmt:mk-signature) ;; sets *my-signature* as side effect
+	  (rmt:get-signature) ;; sets *my-signature* as side effect
 	  (servdat-status-set! *server-info* 'interface-stable)
 	  (debug:print 0 *default-log-port*
 		       "SERVER STARTED: " curr-host
 		       ":" curr-port
 		       " AT " (current-seconds) " server signature: " *my-signature*
@@ -2023,16 +2029,15 @@
   ;; This thread waits for the server to come alive
   (debug:print-info 0 *default-log-port* "Starting the sync-back, keep alive thread in server")
 
   (let* ((server-start-time (current-seconds))
 	 (pkts-dir          (get-pkts-dir))
-	 (server-key        (rmt:mk-signature))
+	 (server-key        (rmt:get-signature)) ;; This servers key
 	 (is-main           (equal? (args:get-arg "-db") ".db/main.db"))
 	 (last-access       0)
 	 (server-timeout    (server:expiration-timeout)))
     ;; main and run db servers have both got wait logic (could/should merge it)
-    (set! *server-id* server-key)
     (if is-main
 	(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*))

Index: tests/Makefile
==================================================================
--- tests/Makefile
+++ tests/Makefile
@@ -40,11 +40,11 @@
 TARGET     = "ubuntu/nfs/none"
 
 all : build unit test4
 # test1 test2 test3 test4 test5 test6 test7 test8 test9
 
-unit : basicserver.log
+unit : basicserver.log server.log
 # all-rmt.log all-api.log
 # runs.log misc.log tests.log
 
 # inter dependencies on the unit tests, I wish these could be "suggestions"
 all-rmt.log : all-api.log

Index: tests/unittests/basicserver.scm
==================================================================
--- tests/unittests/basicserver.scm
+++ tests/unittests/basicserver.scm
@@ -76,278 +76,5 @@
 (test #f '() (string->sexpr "()"))
 (test #f 'server-started (api:execute-requests *db* 'get-server (list *toppath* ".db/2.db")))
 (set! *dbstruct-db* #f)
 
 (exit)
-
-(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 '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)))
-;; 
-
-;; (exit)

Index: tests/unittests/server.scm
==================================================================
--- tests/unittests/server.scm
+++ tests/unittests/server.scm
@@ -20,10 +20,321 @@
 
 
 ;; Run like this:
 ;;
 ;;  (cd ..;make && make install) && ./rununittest.sh server 1;(cd simplerun;megatest -stop-server 0)
+(import rmtmod trace http-client apimod dbmod
+	launchmod)
+
+(trace-call-sites #t)
+(trace
+ ;; db:get-dbdat
+ ;; rmt:find-main-server
+;;  rmt:send-receive-real
+;;  rmt:send-receive
+ ;; sexpr->string
+ ;; server-ready?
+ ;; rmt:register-server
+ ;; rmt:open-main-connection
+ ;; rmt:general-open-connection
+ ;; rmt:get-conny
+ ;; common:watchdog
+ ;; rmt:find-main-server
+ ;; get-all-server-pkts
+ ;; get-viable-servers
+ ;; get-best-candidate
+ ;; api:run-server-process
+ ;; rmt:run
+ ;; rmt:try-start-server
+ )
+
+(define *db* (db:setup #f))
+
+;; 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 '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)))
+;; 
+
+;; (exit)
+
+
+;; all old stuff below
+
+
+
 
 (delete-file* "logs/1.log")
 (define run-id 1)
 
 (test "setup for run" #t (begin (launch:setup-for-run)