Index: TODO
==================================================================
--- TODO
+++ TODO
@@ -1,4 +1,12 @@
 
-1. Confirm that branch transaction-for-sequential-writes content was added to trunk/development
-2. Add a host chooser for ssh to launch-tests
-3. Try making static executable
+TODO
+====
+
+Migration to inmem db plus per run db
+-------------------------------------
+
+. Re-work the dbstruct data structure?
+.. Move main.db to global?
+.. [ run-id.db inmemdb last-mod last-read last-sync inuse ]
+. Re-work all queries to use run-id to dereference server
+. Open main.db directly in calls to -runtests etc. No need to talk remote?

Index: api.scm
==================================================================
--- api.scm
+++ api.scm
@@ -71,27 +71,27 @@
 					  (realparams (cddr params)))
 				      (db:with-db dbstruct run-id #t ;; these are all for modifying the db
 						  (lambda (db)
 						    (db:general-call db stmtname realparams)))))
     ((sync-inmem->db)               (db:sync-touched dbstruct force-sync: #t))
-    ((kill-server)
-     (db:sync-tables (db:tbls *inmemdb*) *inmemdb* *db*)  ;; (db:sync-to *inmemdb* *db*)
-     (let ((hostname (car  *runremote*))
-	   (port     (cadr *runremote*))
-	   (pid      (if (null? params) #f (car params)))
-	   (th1      (make-thread (lambda ()(thread-sleep! 3)(debug:print 0 "Server exiting!")(exit 0)) "Server exit thread")))
-       (debug:print 0 "WARNING: Server on " hostname ":" port " going down by user request!")
-       (debug:print-info 1 "current pid=" (current-process-id))
-       (open-run-close tasks:server-deregister tasks:open-db 
-		       hostname
-		       port: port)
-       (set! *server-run* #f)
-       (thread-sleep! 3)
-       (if pid 
-	   (process-signal pid signal/kill)
-	   (thread-start! th1))
-       '(#t "exit process started")))
+    ;; ((kill-server)
+    ;;  (db:sync-tables (db:tbls *inmemdb*) *inmemdb* *db*)  ;; (db:sync-to *inmemdb* *db*)
+    ;;  (let ((hostname (car  *runremote*))
+    ;;        (port     (cadr *runremote*))
+    ;;        (pid      (if (null? params) #f (car params)))
+    ;;        (th1      (make-thread (lambda ()(thread-sleep! 3)(debug:print 0 "Server exiting!")(exit 0)) "Server exit thread")))
+    ;;    (debug:print 0 "WARNING: Server on " hostname ":" port " going down by user request!")
+    ;;    (debug:print-info 1 "current pid=" (current-process-id))
+    ;;    (open-run-close tasks:server-deregister tasks:open-db 
+    ;;     	       hostname
+    ;;     	       port: port)
+    ;;    (set! *server-run* #f)
+    ;;    (thread-sleep! 3)
+    ;;    (if pid 
+    ;;        (process-signal pid signal/kill)
+    ;;        (thread-start! th1))
+    ;;    '(#t "exit process started")))
     ((sdb-qry)                      (apply sdb:qry params))
 
     ;; TESTMETA
     ((testmeta-get-record)       (apply db:testmeta-get-record dbstruct params))
     ((testmeta-add-record)       (apply db:testmeta-add-record dbstruct params))

Index: client.scm
==================================================================
--- client.scm
+++ client.scm
@@ -50,43 +50,48 @@
 ;;   1. We are a test manager and we received *transport-type* and *runremote* via cmdline
 ;;   2. We are a run tests, list runs or other interactive process and we must figure out
 ;;      *transport-type* and *runremote* from the monitor.db
 ;;
 ;; client:setup
-(define (client:setup #!key (numtries 3))
+(define (client:setup run-id #!key (numtries 3))
   (if (not *toppath*)
       (if (not (setup-for-run))
 	  (begin
 	    (debug:print 0 "ERROR: failed to find megatest.config, exiting")
 	    (exit))))
-  (push-directory *toppath*) ;; This is probably NOT needed 
+  ;; (push-directory *toppath*) ;; This is probably NOT needed 
   ;; clients get the sdb:qry proc created here
   ;; (if (not sdb:qry)
   ;;     (begin
   ;;       (set! sdb:qry (make-sdb:qry (conc *toppath* "/db/strings.db"))) ;; we open the normalization helpers here
   ;;       (sdb:qry 'setup #f)))
-
-  (debug:print-info 11 "*transport-type* is " *transport-type* ", *runremote* is " *runremote*)
-  (let* ((hostinfo  (open-run-close tasks:get-best-server tasks:open-db)))
-    (debug:print-info 11 "CLIENT SETUP, hostinfo=" hostinfo)
-    (set! *transport-type* (if hostinfo 
-    			       (string->symbol (tasks:hostinfo-get-transport hostinfo))
-			       'fs))
-    (debug:print-info 11 "Using transport type of " *transport-type* (if hostinfo (conc " to connect to " hostinfo) ""))
-    (case *transport-type* 
-      ;; ((fs)(if (not *megatest-db*)(set! *megatest-db* (open-db))))
-      ((http)
-       (http-transport:client-connect (tasks:hostinfo-get-interface hostinfo)
-				      (tasks:hostinfo-get-port hostinfo)))
-      ((zmq)
-       (zmq-transport:client-connect (tasks:hostinfo-get-interface hostinfo)
-				     (tasks:hostinfo-get-port      hostinfo)
-				     (tasks:hostinfo-get-pubport   hostinfo)))
-      (else  ;; default to fs
-       (debug:print 0 "ERROR: unrecognised transport type " *transport-type* " exiting now.")
-       (exit)))
-    (pop-directory)))
+  (let ((hostinfo (and run-id (hash-table-ref/default *runremote* run-id #f))))
+    (debug:print-info 11 "for run-id=" run-id ", *transport-type* is " *transport-type*)
+    (if hostinfo
+	hostinfo ;; have hostinfo - just return it
+	(let* ((hostinfo  (open-run-close tasks:get-server tasks:open-db run-id))
+	       (transport (if hostinfo 
+			      (string->symbol (tasks:hostinfo-get-transport hostinfo))
+			      'http)))
+	  (hash-table-set! *runremote* run-id hostinfo)
+	  (debug:print-info 11 "CLIENT SETUP, hostinfo=" hostinfo)
+	  (debug:print-info 11 "Using transport type of " transport (if hostinfo (conc " to connect to " hostinfo) ""))
+	  (case *transport-type* 
+	    ;; ((fs)(if (not *megatest-db*)(set! *megatest-db* (open-db))))
+	    ((http)
+	     ;; this saves the hostinfo in the *runremote* hash and returns it
+	     (http-transport:client-connect run-id 
+					    (tasks:hostinfo-get-interface hostinfo)
+					    (tasks:hostinfo-get-port hostinfo)))
+	    ((zmq)
+	     (zmq-transport:client-connect (tasks:hostinfo-get-interface hostinfo)
+					   (tasks:hostinfo-get-port      hostinfo)
+					   (tasks:hostinfo-get-pubport   hostinfo)))
+	    (else  ;; default to fs
+	     (debug:print 0 "ERROR: unrecognised transport type " *transport-type* " exiting now.")
+	     (exit)))))))
+;;	  (pop-directory)))
 
 ;; client:signal-handler
 (define (client:signal-handler signum)
   (handle-exceptions
    exn
@@ -103,13 +108,16 @@
      (thread-start! th2)
      (thread-start! th1)
      (thread-join! th2))))
 
 ;; client:launch
-(define (client:launch)
+;; Need to set the signal handler somewhere other than here as this
+;; routine will go away.
+;;
+(define (client:launch run-id)
   (set-signal-handler! signal/int client:signal-handler)
-   (if (client:setup)
-       (debug:print-info 2 "connected as client")
-       (begin
-	 (debug:print 0 "ERROR: Failed to connect as client")
-	 (exit))))
+  (if (client:setup run-id)
+      (debug:print-info 2 "connected as client")
+      (begin
+	(debug:print 0 "ERROR: Failed to connect as client")
+	(exit))))
 

Index: common.scm
==================================================================
--- common.scm
+++ common.scm
@@ -46,11 +46,11 @@
 ;; SERVER
 (define *my-client-signature* #f)
 (define *transport-type*    'fs)
 (define *megatest-db*       #f)
 (define *rpc:listener*      #f) ;; if set up for server communication this will hold the tcp port
-(define *runremote*         #f) ;; if set up for server communication this will hold <host port>
+(define *runremote*         (make-hash-table)) ;; if set up for server communication this will hold <host port>
 (define *last-db-access*    (current-seconds))  ;; update when db is accessed via server
 (define *max-cache-size*    0)
 (define *logged-in-clients* (make-hash-table))
 (define *client-non-blocking-mode* #f)
 (define *server-id*         #f)

Index: http-transport.scm
==================================================================
--- http-transport.scm
+++ http-transport.scm
@@ -370,30 +370,26 @@
 	 (thread-join! th1)
 	 (thread-terminate! th2)
 	 (debug:print-info 11 "got res=" res)
 	 res)))))
 
-(define (http-transport:client-connect iface port)
+(define (http-transport:client-connect run-id iface port)
   (let* ((login-res   #f)
 	 (uri-dat     (make-request method: 'POST uri: (uri-reference (conc "http://" iface ":" port "/ctrl"))))
 	 (uri-api-dat (make-request method: 'POST uri: (uri-reference (conc "http://" iface ":" port "/api"))))
 	 (serverdat   (list iface port uri-dat uri-api-dat)))
-    (set! *runremote* serverdat) ;; may or may not be good ...
-    (set! login-res (rmt:login))
+    (hash-table-set! *runremote* run-id serverdat) ;; may or may not be good ...
+    (set! login-res (rmt:login run-id))
     (if (and (list? login-res)
 	     (car login-res))
 	(begin
 	  (debug:print-info 2 "Logged in and connected to " iface ":" port)
-	  (set! *runremote* serverdat)
+	  (hash-table-set! *runremote* run-id serverdat)
 	  serverdat)
 	(begin
 	  (debug:print-info 0 "ERROR: Failed to login or connect to " iface ":" port)
 	  (exit 1)))))
-;; 	  (set! *runremote* #f)
-;; 	  (set! *transport-type* 'fs)
-;; 	  #f))))
-
 
 ;; run http-transport:keep-running in a parallel thread to monitor that the db is being 
 ;; used and to shutdown after sometime if it is not.
 ;;
 (define (http-transport:keep-running server-id)

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -364,11 +364,12 @@
 		     '("-list-servers"
 		       "-stop-server"
 		       "-show-cmdinfo"
 		       "-list-runs")))
 	(if (setup-for-run)
-	    (begin
+	    (let ((run-id    (and (args:get-arg "-run-id")
+				  (string->number (args:get-arg "-run-id")))))
 	      ;; (set! *fdb*   (filedb:open-db (conc *toppath* "/db/paths.db")))
 	      ;; if not list or kill then start a client (if appropriate)
 	      (if (or (args-defined? "-h" "-version" "-gen-megatest-area" "-gen-megatest-test")
 		      (eq? (length (hash-table-keys args:arg-hash)) 0))
 		  (debug:print-info 1 "Server connection not needed")
@@ -389,14 +390,12 @@
 								      "fs"))))
 		    (debug:print 2 "chosen-transport: " chosen-transport " have; config=" transport-from-config ", cmdln=" transport-from-cmdln ", cmdinfo=" transport-from-cmdinfo)
 		    (case chosen-transport
 		      ((http)
 		       (set! *transport-type 'http)
-		       (server:ensure-running)
-		       ;; Get rid of this
-
-		       (client:launch))
+		       (if run-id (server:ensure-running run-id))
+		       (client:launch run-id))
 		      (else ;; (fs)
 		       (debug:print 0 "ERROR: Should NOT be getting here! fs transport is no longer supported")
 		       (set! *transport-type* 'fs)
 		       (set! *megatest-db* (make-dbr:dbstruct path: *toppath* local: #t))))))))))
 

Index: rmt.scm
==================================================================
--- rmt.scm
+++ rmt.scm
@@ -35,24 +35,24 @@
 ;;======================================================================
 
 ;; cmd is a symbol
 ;; vars is a json string encoding the parameters for the call
 ;;
-(define (rmt:send-receive cmd params)
+(define (rmt:send-receive cmd run-id params)
   (case *transport-type* 
     ((fs-aint-here)
      (debug:print 0 "ERROR: Not yet (re)supported")
      (exit 1))
     ((fs http)
-     (let* ((jparams (db:obj->string params)) ;; (rmt:dat->json-str params))
-	    (res (http-transport:client-api-send-receive *runremote* cmd jparams)))
+     (let* ((connection-info (client:setup run-id))
+	    (jparams         (db:obj->string params)) ;; (rmt:dat->json-str params))
+	    (res (http-transport:client-api-send-receive connection-info cmd jparams)))
        (if res
 	   (db:string->obj res) ;; (rmt:json-str->dat res)
 	   (begin
 	     (debug:print 0 "ERROR: Bad value from http-transport:client-api-send-receive " res)
-	     #f))
-     ))
+	     #f))))
     (else
      (debug:print 0 "ERROR: Transport " *transport-type* " not yet (re)supported")
      (exit 1))))
 
 ;; Wrap json library for strings (why the ports crap in the first place?)
@@ -74,56 +74,58 @@
 
 ;;======================================================================
 ;;  M I S C
 ;;======================================================================
 
-(define (rmt:login)
-  (rmt:send-receive 'login (list *toppath* megatest-version *my-client-signature*)))
+(define (rmt:login run-id)
+  (rmt:send-receive 'login run-id (list *toppath* megatest-version *my-client-signature*)))
 
-(define (rmt:kill-server)
-  (rmt:send-receive 'kill-server '()))
+(define (rmt:kill-server run-id)
+  (rmt:send-receive 'kill-server run-id (list run-id)))
 
 ;; hand off a call to one of the db:queries statements
 ;; added run-id to make looking up the correct db possible 
 ;;
 (define (rmt:general-call stmtname run-id . params)
-  (rmt:send-receive 'general-call (append (list stmtname run-id) params)))
+  (rmt:send-receive 'general-call run-id (append (list stmtname run-id) params)))
 
-(define (rmt:sync-inmem->db)
-  (rmt:send-receive 'sync-inmem->db '()))
+(define (rmt:sync-inmem->db run-id)
+  (rmt:send-receive 'sync-inmem->db run-id '()))
 
-(define (rmt:sdb-qry qry val)
+(define (rmt:sdb-qry qry val run-id)
   ;; add caching if qry is 'getid or 'getstr
-  (rmt:send-receive 'sdb-qry (list qry val)))
+  (rmt:send-receive 'sdb-qry run-id (list qry val)))
 
 ;;======================================================================
 ;;  K E Y S 
 ;;======================================================================
 
+;; These should not require run-id but it is more consistent to have it. 
+;; run-id can theoretically be #f but how to handle that is not yet done.
 (define (rmt:get-key-val-pairs run-id)
-  (rmt:send-receive 'get-key-val-pairs (list run-id)))
+  (rmt:send-receive 'get-key-val-pairs run-id (list run-id)))
 
-(define (rmt:get-keys)
-  (rmt:send-receive 'get-keys '()))
+(define (rmt:get-keys run-id)
+  (rmt:send-receive 'get-keys run-id '()))
 
 ;;======================================================================
 ;;  T E S T S
 ;;======================================================================
 
 (define (rmt:get-test-id run-id testname item-path)
-  (rmt:send-receive 'get-test-id (list run-id testname item-path)))
+  (rmt:send-receive 'get-test-id run-id (list run-id testname item-path)))
 
 (define (rmt:get-test-info-by-id run-id test-id)
   (if (and (number? run-id)(number? test-id))
-      (rmt:send-receive 'get-test-info-by-id (list run-id test-id))
+      (rmt:send-receive 'get-test-info-by-id run-id (list run-id test-id))
       (begin
 	(debug:print 0 "ERROR: Bad data handed to rmt:get-test-info-by-id run-id=" run-id ", test-id=" test-id)
 	(print-call-chain)
 	#f)))
 
 (define (rmt:test-get-rundir-from-test-id run-id test-id)
-  (rmt:send-receive 'test-get-rundir-from-test-id (list run-id test-id)))
+  (rmt:send-receive 'test-get-rundir-from-test-id run-id (list run-id test-id)))
 
 (define (rmt:open-test-db-by-test-id run-id test-id #!key (work-area #f))
   (let* ((test-path (if (string? work-area)
 			work-area
 			(rmt:test-get-rundir-from-test-id run-id test-id))))
@@ -130,88 +132,93 @@
     (debug:print 3 "TEST PATH: " test-path)
     (open-test-db test-path)))
 
 ;; WARNING: This currently bypasses the transaction wrapped writes system
 (define (rmt:test-set-state-status-by-id run-id test-id newstate newstatus newcomment)
-  (rmt:send-receive 'test-set-state-status-by-id (list run-id test-id newstate newstatus newcomment)))
+  (rmt:send-receive 'test-set-state-status-by-id run-id (list run-id test-id newstate newstatus newcomment)))
 
 (define (rmt:set-tests-state-status run-id testnames currstate currstatus newstate newstatus)
-  (rmt:send-receive 'set-tests-state-status (list run-id testnames currstate currstatus newstate newstatus)))
+  (rmt:send-receive 'set-tests-state-status run-id (list run-id testnames currstate currstatus newstate newstatus)))
 
 (define (rmt:get-tests-for-run run-id testpatt states statuses offset limit not-in sort-by sort-order qryvals)
   (if (number? run-id)
-      (rmt:send-receive 'get-tests-for-run (list run-id testpatt states statuses offset limit not-in sort-by sort-order qryvals))
+      (rmt:send-receive 'get-tests-for-run run-id (list run-id testpatt states statuses offset limit not-in sort-by sort-order qryvals))
       (begin
 	(debug:print "ERROR: rmt:get-tests-for-run called with bad run-id=" run-id)
 	(print-call-chain)
 	'())))
 
 (define (rmt:get-tests-for-runs-mindata run-ids testpatt states status not-in)
-  (rmt:send-receive 'get-tests-for-runs-mindata (list run-ids testpatt states status not-in)))
+  (apply append (map (lambda (run-id)
+		       (rmt:send-receive 'get-tests-for-run-mindata run-id (list run-ids testpatt states status not-in)))
+		     run-ids)))
 
 (define (rmt:delete-test-records run-id test-id)
-  (rmt:send-receive 'delete-test-records (list run-id test-id)))
+  (rmt:send-receive 'delete-test-records run-id (list run-id test-id)))
 
 (define (rmt:test-set-status-state run-id test-id status state msg)
-  (rmt:send-receive 'test-set-status-state (list run-id test-id status state msg)))
+  (rmt:send-receive 'test-set-status-state run-id (list run-id test-id status state msg)))
 
 (define (rmt:get-previous-test-run-record run-id test-name item-path)
-  (rmt:send-receive 'get-previous-test-run-record (list run-id test-name item-path)))
+  (rmt:send-receive 'get-previous-test-run-record run-id (list run-id test-name item-path)))
 
 (define (rmt:get-matching-previous-test-run-records run-id test-name item-path)
-  (rmt:send-receive 'get-matching-previous-test-run-records (list run-id test-name item-path)))
+  (rmt:send-receive 'get-matching-previous-test-run-records run-id (list run-id test-name item-path)))
 
 (define (rmt:test-get-logfile-info run-id test-name)
-  (rmt:send-receive 'test-get-logfile-info (list run-id test-name)))
+  (rmt:send-receive 'test-get-logfile-info run-id (list run-id test-name)))
 
 (define (rmt:test-get-records-for-index-file run-id test-name)
-  (rmt:send-receive 'test-get-records-for-index-file (list  run-id test-name)))
+  (rmt:send-receive 'test-get-records-for-index-file run-id (list run-id test-name)))
 
 (define (rmt:get-testinfo-state-status run-id test-id)
-  (rmt:send-receive 'get-testinfo-state-status (list run-id test-id)))
+  (rmt:send-receive 'get-testinfo-state-status run-id (list run-id test-id)))
 
 (define (rmt:test-set-log! run-id test-id logf)
   (if (string? logf)(rmt:general-call 'test-set-log run-id logf test-id)))
 
 (define (rmt:test-get-paths-matching-keynames-target-new keynames target res testpatt statepatt statuspatt runname)
-  (rmt:send-receive 'test-get-paths-matching-keynames-target-new (list keynames target res testpatt statepatt statuspatt runname)))
+  (let ((run-ids (rmt:get-run-ids-matching keynames target res)))
+    (apply append (lambda (run-id)
+		    (rmt:send-receive 'test-get-paths-matching-keynames-target-new (list keynames target res testpatt statepatt statuspatt runname)))
+	   run-ids)))
 
 (define (rmt:get-prereqs-not-met run-id waitons ref-item-path #!key (mode 'normal))
-  (rmt:send-receive 'get-prereqs-not-met (list run-id waitons ref-item-path mode)))
+  (rmt:send-receive 'get-prereqs-not-met run-id (list run-id waitons ref-item-path mode)))
 
 (define (rmt:get-count-tests-running-for-run-id run-id)
-  (rmt:send-receive 'get-count-tests-running-for-run-id (list run-id)))
+  (rmt:send-receive 'get-count-tests-running-for-run-id run-id (list run-id)))
 
 ;; Statistical queries
 
 (define (rmt:get-count-tests-running run-id)
-  (rmt:send-receive 'get-count-tests-running (list run-id)))
+  (rmt:send-receive 'get-count-tests-running run-id (list run-id)))
 
 (define (rmt:get-count-tests-running-in-jobgroup run-id jobgroup)
-  (rmt:send-receive 'get-count-tests-running-in-jobgroup (list run-id jobgroup)))
+  (rmt:send-receive 'get-count-tests-running-in-jobgroup run-id (list run-id jobgroup)))
 
 (define (rmt:roll-up-pass-fail-counts run-id test-name item-path status)
-  (rmt:send-receive 'roll-up-pass-fail-counts (list run-id test-name item-path status)))
+  (rmt:send-receive 'roll-up-pass-fail-counts run-id (list run-id test-name item-path status)))
 
 (define (rmt:update-pass-fail-counts run-id test-name)
-  (rmt:general-call 'update-fail-pass-counts (list run-id test-name run-id test-name run-id test-name)))
+  (rmt:general-call 'update-fail-pass-counts run-id (list run-id test-name run-id test-name run-id test-name)))
 
 ;;======================================================================
 ;;  R U N S
 ;;======================================================================
 
 (define (rmt:get-run-info run-id)
-  (rmt:send-receive 'get-run-info (list run-id)))
+  (rmt:send-receive 'get-run-info run-id (list run-id)))
 
 (define (rmt:register-run keyvals runname state status user)
   (rmt:send-receive 'register-run (list keyvals runname state status user)))
     
 (define (rmt:get-run-name-from-id run-id)
-  (rmt:send-receive 'get-run-name-from-id (list run-id)))
+  (rmt:send-receive 'get-run-name-from-id run-id (list run-id)))
 
 (define (rmt:delete-run run-id)
-  (rmt:send-receive 'delete-run (list run-id)))
+  (rmt:send-receive 'delete-run run-id (list run-id)))
 
 (define (rmt:delete-old-deleted-test-records)
   (rmt:send-receive 'delete-old-deleted-test-records '()))
 
 (define (rmt:get-runs runpatt count offset keypatts)
@@ -237,30 +244,30 @@
 ;;  2. Open the testdat.db file and do the query
 ;; If not given the work area
 ;;  1. Do a remote call to get the test path
 ;;  2. Continue as above
 ;; 
-(define (rmt:get-steps-for-test test-id)
-  (rmt:send-receive 'get-steps-data (list test-id)))
+(define (rmt:get-steps-for-test run-id test-id)
+  (rmt:send-receive 'get-steps-data run-id (list test-id)))
 
 (define (rmt:teststep-set-status! run-id test-id teststep-name state-in status-in comment logfile)
   (let* ((state     (items:check-valid-items "state" state-in))
 	 (status    (items:check-valid-items "status" status-in)))
     (if (or (not state)(not status))
 	(debug:print 3 "WARNING: Invalid " (if status "status" "state")
 		     " value \"" (if status state-in status-in) "\", update your validvalues section in megatest.config"))
-    (rmt:send-receive 'teststep-set-status! (list run-id test-id teststep-name state-in status-in comment logfile))))
+    (rmt:send-receive 'teststep-set-status! run-id (list run-id test-id teststep-name state-in status-in comment logfile))))
 
-(define (rmt:get-steps-for-test test-id)
-  (rmt:send-receive 'get-steps-for-test (list test-id)))
+(define (rmt:get-steps-for-test run-id test-id)
+  (rmt:send-receive 'get-steps-for-test run-id (list test-id)))
 
 ;;======================================================================
 ;;  T E S T   D A T A 
 ;;======================================================================
 
-(define (rmt:read-test-data test-id categorypatt #!key (work-area #f)) 
-  (let ((tdb  (rmt:open-test-db-by-test-id test-id work-area: work-area)))
+(define (rmt:read-test-data run-id test-id categorypatt #!key (work-area #f)) 
+  (let ((tdb  (rmt:open-test-db-by-test-id run-id test-id work-area: work-area)))
     (if tdb
 	(tdb:read-test-data tdb test-id categorypatt)
 	'())))
 
 (define (rmt:testmeta-add-record testname)
@@ -271,9 +278,9 @@
 
 (define (rmt:testmeta-update-field test-name fld val)
   (rmt:send-receive 'testmeta-update-field (list test-name fld val)))
 
 (define (rmt:test-data-rollup run-id test-id status)
-  (rmt:send-receive 'test-data-rollup (list run-id test-id status)))
+  (rmt:send-receive 'test-data-rollup run-id (list run-id test-id status)))
 
 (define (rmt:csv->test-data run-id test-id csvdata)
-  (rmt:send-receive 'csv->test-data (list run-id test-id csvdata)))
+  (rmt:send-receive 'csv->test-data run-id (list run-id test-id csvdata)))

Index: server.scm
==================================================================
--- server.scm
+++ server.scm
@@ -117,19 +117,19 @@
        (send-message pub-socket (db:obj->string (vector success/fail query-sig result)))))
     (else 
      (debug:print 0 "ERROR: unrecognised transport type: " *transport-type*)
      result)))
 
-(define (server:ensure-running)
-  (let loop ((servers  (open-run-close tasks:get-best-server tasks:open-db))
+(define (server:ensure-running run-id)
+  (let loop ((servers  (open-run-close tasks:get-server tasks:open-db run-id))
 	     (trycount 0))
     (if (or (not servers)
 	    (null? servers))
 	(begin
 	  (if (even? trycount) ;; just do the server start every other time through this loop (every 8 seconds)
 	      (let ((cmdln (conc (if (getenv "MT_MEGATEST") (getenv "MT_MEGATEST") "megatest")
-				 " -server - -daemonize")))
+				 " -server - -daemonize -run-id " run-id)))
 		(debug:print 0 "INFO: Starting server (" cmdln ") as none running ...")
 		;; (server:launch (string->symbol (args:get-arg "-transport" "http"))))
 		;; no need to use fork, no need to do the list-servers trick. Just start the damn server, it will exit on it's own
 		;; if there is an existing server
 		(system cmdln)

Index: tasks.scm
==================================================================
--- tasks.scm
+++ tasks.scm
@@ -113,11 +113,11 @@
    -1                         ;; pubport
    (random 1000)              ;; priority (used a tiebreaker on get-available)
    "available"                ;; state
    (common:version-signature) ;; mt_version
    -1                         ;; interface
-   -1                         ;; transport
+   "http"                     ;; transport
    run-id
    ))
 
 (define (tasks:server-clean-out-old-records-for-run-id mdb run-id)
   (sqlite3:execute mdb "DELETE FROM servers WHERE state='available' AND (strftime('%s','now') - start_time) > 30 AND run_id=?;" run-id)