Index: dashboard.scm
==================================================================
--- dashboard.scm
+++ dashboard.scm
@@ -56,11 +56,11 @@
 		 (argv)
 		 (list  "-rows"
 			"-run"
 			"-test"
 			"-debug"
-			"-server" 
+			"-host" 
 			) 
 		 (list  "-h"
 			"-guimonitor"
 			"-main"
 			"-v"
@@ -79,33 +79,35 @@
       (print "Failed to find megatest.config, exiting") 
       (exit 1)))
 
 (define *db* #f) ;; (open-db))
 
-(if (args:get-arg "-server")
+(if (args:get-arg "-host")
     (begin
-      (set! *runremote* (string-split (args:get-arg "-server" ":")))
-      (server:client-launch)))
+      (set! *runremote* (string-split (args:get-arg "-host" ":")))
+      (server:client-launch))
+    (server:client-launch))
 
 ;; HACK ALERT: this is a hack, please fix.
 (define *read-only* (not (file-read-access? (conc *toppath* "/megatest.db"))))
 ;; (server:client-setup *db*)
 
 (define toplevel #f)
 (define dlg      #f)
 (define max-test-num 0)
-(define *keys*   (open-run-close db:get-keys #f))
+;; (define *keys*   (open-run-close db:get-keys #f))
+(define *keys*   (cdb:remote-run db:get-keys #f))
 ;; (define *keys*   (db:get-keys   *db*))
 (define *dbkeys*  (map (lambda (x)(vector-ref x 0))
 		      (append *keys* (list (vector "runname" "blah")))))
 (define *header*       #f)
 (define *allruns*     '())
 (define *buttondat*    (make-hash-table)) ;; <run-id color text test run-key>
 (define *alltestnamelst* '())
 (define *searchpatts*  (make-hash-table))
 (define *num-runs*      8)
-(define *tot-run-count* (open-run-close db:get-num-runs #f "%"))
+(define *tot-run-count* (cdb:remote-run db:get-num-runs #f "%"))
 ;; (define *tot-run-count* (db:get-num-runs *db* "%"))
 (define *last-update*   (current-seconds))
 (define *num-tests*     15)
 (define *start-run-offset*  0)
 (define *start-test-offset* 0)
@@ -169,11 +171,11 @@
 	(begin
 	  (debug:print-info 4 "update-rundat runnamepatt: " runnamepatt " numruns: " numruns " testnamepatt: " testnamepatt " keypatts: " keypatts)
 	  (set! *please-update-buttons* #t)
 	  (set! *last-db-update-time* modtime)
 	  (set! *delayed-update* (- *delayed-update* 1))
-	  (let* ((allruns     (open-run-close db:get-runs #f runnamepatt numruns ;; (+ numruns 1) ;; (/ numruns 2))
+	  (let* ((allruns     (cdb:remote-run db:get-runs #f runnamepatt numruns ;; (+ numruns 1) ;; (/ numruns 2))
 					   *start-run-offset* keypatts))
 		 (header      (db:get-header allruns))
 		 (runs        (db:get-rows   allruns))
 		 (result      '())
 		 (maxtests    0)
@@ -185,13 +187,13 @@
 		(begin
 		  (set! *last-update* (current-seconds))
 		  (set! *tot-run-count* (length runs)))) ;; (rdb:get-num-runs *db* runnamepatt))))
 	    (for-each (lambda (run)
 			(let* ((run-id   (db:get-value-by-header run header "id"))
-			       (tests    (let ((tsts (open-run-close db:get-tests-for-run #f run-id testnamepatt states statuses)))
+			       (tests    (let ((tsts (cdb:remote-run db:get-tests-for-run #f run-id testnamepatt states statuses)))
 					   (if *tests-sort-reverse* (reverse tsts) tsts)))
-			       (key-vals (open-run-close db:get-key-vals #f run-id)))
+			       (key-vals (cdb:remote-run db:get-key-vals #f run-id)))
 			  (if (> (length tests) maxtests)
 			      (set! maxtests (length tests)))
 			  (if (or (not *hide-empty-runs*) ;; this reduces the data burden when set
 				  (not (null? tests)))
 			      (set! result (cons (vector run tests key-vals) result)))))
@@ -643,11 +645,11 @@
     (if runid
 	(begin
 	  (lambda (x)
 	    (on-exit (lambda ()
 		       (if *db* (sqlite3:finalize! *db*))))
-	    (open-run-close examine-run *db* runid)))
+	    (cdb:remote-run examine-run *db* runid)))
 	(begin
 	  (print "ERROR: runid is not a number " (args:get-arg "-run"))
 	  (exit 1)))))
  ((args:get-arg "-test")
     (let ((testid (string->number (args:get-arg "-test"))))

Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -56,11 +56,11 @@
 		    (else 
 		     (debug:print 0 "ERROR: synchronous must be 0,1,2,OFF,NORMAL or FULL, you provided: " syncval)
 		     #f))))
     (if val
 	(begin
-	  (debug:print-info 11 "db:set-sync, setting pragma synchronous to " val)
+	  (debug:print-info 9 "db:set-sync, setting pragma synchronous to " val)
 	  (sqlite3:execute db (conc "PRAGMA synchronous = '" val "';"))))))
 
 (define (open-db) ;;  (conc *toppath* "/megatest.db") (car *configinfo*)))
   (if (not *toppath*)
       (if (not (setup-for-run))
@@ -75,11 +75,11 @@
 					   136000)))) ;; 136000))) ;; 136000 = 2.2 minutes
     (debug:print-info 11 "open-db, dbpath=" dbpath " argv=" (argv))
     (sqlite3:set-busy-handler! db handler)
     (if (not dbexists)
 	(db:initialize db))
-    ;; (db:set-sync db)
+    (db:set-sync db)
     db))
 
 ;; keeping it around for debugging purposes only
 (define (open-run-close-no-exception-handling  proc idb . params)
   (debug:print-info 11 "open-run-close-no-exception-handling START given a db=" (if idb "yes " "no ") ", params=" params)
@@ -146,11 +146,12 @@
 		      (begin
 			(print "ERROR: your key cannot be named " keyn " as this conflicts with the same named field in the runs table")
 			(system (conc "rm -f " dbpath))
 			(exit 1)))))
 	      keys)
-    (sqlite3:execute db "PRAGMA synchronous = OFF;")
+    ;; (sqlite3:execute db "PRAGMA synchronous = OFF;")
+    (db:set-sync db)
     (sqlite3:execute db "CREATE TABLE IF NOT EXISTS keys (id INTEGER PRIMARY KEY, fieldname TEXT, fieldtype TEXT, CONSTRAINT keyconstraint UNIQUE (fieldname));")
     (for-each (lambda (key)
 		(sqlite3:execute db "INSERT INTO keys (fieldname,fieldtype) VALUES (?,?);" (key:get-fieldname key)(key:get-fieldtype key)))
 	      keys)
     (sqlite3:execute db (conc 
@@ -265,11 +266,11 @@
 	(debug:print-info 11 "open-test-db END (unsucessful)" testpath)
 	#f)))
 
 ;; find and open the testdat.db file for an existing test
 (define (db:open-test-db-by-test-id db test-id)
-  (let* ((test-path (db:test-get-rundir-from-test-id db test-id)))
+  (let* ((test-path (cdb:remote-run db:test-get-rundir-from-test-id db test-id)))
     (debug:print 3 "TEST PATH: " test-path)
     (open-test-db test-path)))
 
 (define (db:testdb-initialize db)
   (debug:print 11 "db:testdb-initialize START")
@@ -915,42 +916,11 @@
 (define (db:clean-all-caches)
   (set! *test-info* (make-hash-table))
   (set! *test-id-cache* (make-hash-table)))
 
 ;; Get test data using test_id
-(define (db:get-test-info-cached-by-id db test-id)
-  ;; is all this crap really worth it? I somehow doubt it.
-  (let* ((last-delete-str (db:get-var db "DELETED_TESTS"))
-	 (last-delete     (if (string? last-delete-str)(string->number last-delete-str) #f)))
-    (if (and last-delete (> last-delete *last-test-cache-delete*))
-	(begin
-	  (set! *test-info* (make-hash-table))
-	  (set! *test-id-cache* (make-hash-table))
-	  (set! *last-test-cache-delete* last-delete)
-	  (debug:print-info 4 "Clearing test data cache"))))
-  (if (not test-id)
-      (begin
-	(debug:print-info 4 "db:get-test-info-by-id called with test-id=" test-id)
-	#f)
-      (let* ((res (hash-table-ref/default *test-info* test-id #f)))
-	(if (and res
-		 (member (db:test-get-state res) '("RUNNING" "COMPLETED")))
-	    (db:patch-tdb-data-into-test-info db test-id res)
-	    ;; if no cached value then full read and write to cache
-	    (begin
-	      (sqlite3:for-each-row
-	       (lambda (id run-id testname state status event-time host cpuload diskfree uname rundir item-path run_duration final_logf comment)
-		 ;;                 0    1       2      3      4        5       6      7        8     9     10      11          12          13       14
-		 (set! res (vector id run-id testname state status event-time host cpuload diskfree uname rundir item-path run_duration final_logf comment)))
-	       db 
-	       "SELECT id,run_id,testname,state,status,event_time,host,cpuload,diskfree,uname,rundir,item_path,run_duration,final_logf,comment FROM tests WHERE id=?;"
-	       test-id)
-	      (if res (db:patch-tdb-data-into-test-info db test-id res))
-	      res)))))
-
-;; Get test data using test_id
-(define (db:get-test-info-not-cached-by-id db test-id)
+(define (db:get-test-info-by-id db test-id)
   (if (not test-id)
       (begin
 	(debug:print-info 4 "db:get-test-info-by-id called with test-id=" test-id)
 	#f)
       (let ((res #f))
@@ -961,12 +931,10 @@
 	 db 
 	 "SELECT id,run_id,testname,state,status,event_time,host,cpuload,diskfree,uname,rundir,item_path,run_duration,final_logf,comment FROM tests WHERE id=?;"
 	 test-id)
 	res)))
 
-(define db:get-test-info-by-id db:get-test-info-not-cached-by-id)
-
 (define (db:get-test-info db run-id testname item-path)
   (db:get-test-info-by-id db (db:get-test-id db run-id testname item-path)))
 
 (define (db:test-set-comment db test-id comment)
   (sqlite3:execute 
@@ -1000,10 +968,19 @@
 ;;======================================================================
 ;; Misc. test related queries
 ;;======================================================================
 
 (define (db:test-get-paths-matching db keynames target fnamepatt #!key (res '()))
+  (let ((paths-from-db (cdb:remote-run db:test-get-paths-matching-keynames-target db keynames target res)))
+    (if fnamepatt
+	(apply append 
+	       (map (lambda (p)
+		      (glob (conc p "/" fnamepatt)))
+		    paths-from-db))
+	paths-from-db)))
+
+(define (db:test-get-paths-matching-keynames-target db keynames target res)
   (let* ((testpatt   (if (args:get-arg "-testpatt")(args:get-arg "-testpatt") "%"))
 	 (statepatt  (if (args:get-arg ":state")   (args:get-arg ":state")    "%"))
 	 (statuspatt (if (args:get-arg ":status")  (args:get-arg ":status")   "%"))
 	 (runname    (if (args:get-arg ":runname") (args:get-arg ":runname")  "%"))
 	 (keystr (string-intersperse 
@@ -1021,16 +998,11 @@
     (sqlite3:for-each-row 
      (lambda (p)
        (set! res (cons p res)))
      db 
      qrystr)
-    (if fnamepatt
-	(apply append 
-	       (map (lambda (p)
-		      (glob (conc p "/" fnamepatt)))
-		    res))
-	res)))
+    res))
 
 ;; look through tests from matching runs for a file
 (define (db:test-get-first-path-matching db keynames target fname)
   ;; [refpaths] is the section where references to other megatest databases are stored
   (let ((mt-paths (configf:get-section "refpaths"))
@@ -1125,13 +1097,13 @@
     ((zmq)
      (handle-exceptions
       exn
       (begin
 	(thread-sleep! 5) 
-	(if (> numretries 0)(apply cdb:client-call zmq-sockets qtype immediate (- numretries 1) params)))
-      (let* ((push-socket (vector-ref zmq-sockets 0))
-	     (sub-socket  (vector-ref zmq-sockets 1))
+	(if (> numretries 0)(apply cdb:client-call serverdat qtype immediate (- numretries 1) params)))
+      (let* ((push-socket (vector-ref serverdat 0))
+	     (sub-socket  (vector-ref serverdat 1))
 	     (client-sig  (server:get-client-signature))
 	     (query-sig   (message-digest-string (md5-primitive) (conc qtype immediate params)))
 	     (zdat        (db:obj->string (vector client-sig qtype immediate query-sig params (current-seconds)))) ;; (with-output-to-string (lambda ()(serialize params))))
 	     (res  #f)
 	     (send-receive (lambda ()
@@ -1157,11 +1129,11 @@
 				    (debug:print 2 "WARNING: no reply to query " params ", trying resend")
 				    (debug:print-info 11 "re-sending message")
 				    (send-message push-socket zdat)
 				    (debug:print-info 11 "message re-sent")
 				    (loop (- n 1)))
-				  ;; (apply cdb:client-call zmq-sockets qtype immediate (- numretries 1) params))
+				  ;; (apply cdb:client-call *runremote* qtype immediate (- numretries 1) params))
 				  (begin
 				    (debug:print 0 "ERROR: cdb:client-call timed out " params ", exiting.")
 				    (exit 5))))))))
 	(debug:print-info 11 "Starting threads")
 	(let ((th1 (make-thread send-receive "send receive"))
@@ -1568,10 +1540,11 @@
 	   "SELECT id,test_id,category,variable,value,expected,tol,units,comment,status,type FROM test_data WHERE test_id=? AND category LIKE ? ORDER BY category,variable;" test-id categorypatt)
 	  (sqlite3:finalize! tdb)
 	  (reverse res))
 	'())))
 
+;; NOTE: Run this local with #f for db !!!
 (define (db:load-test-data db test-id)
   (let loop ((lin (read-line)))
     (if (not (eof-object? lin))
 	(begin
 	  (debug:print 4 lin)
@@ -1585,11 +1558,11 @@
 ;; Roll up test_data pass/fail results
 ;; look at the test_data status field, 
 ;;    if all are pass (any case) and the test status is PASS or NULL or '' then set test status to PASS.
 ;;    if one or more are fail (any case) then set test status to PASS, non "pass" or "fail" are ignored
 (define (db:test-data-rollup db test-id status)
-  (let ((tdb (open-run-close db:open-test-db-by-test-id db test-id))
+  (let ((tdb (db:open-test-db-by-test-id db test-id))
 	(fail-count 0)
 	(pass-count 0))
     (if tdb
 	(begin
 	  (sqlite3:for-each-row
@@ -1769,10 +1742,11 @@
 	 waitons)
 	(delete-duplicates result))))
 
 (define (db:teststep-set-status! db test-id teststep-name state-in status-in comment logfile)
   (debug:print 4 "test-id: " test-id " teststep-name: " teststep-name)
+  ;;                 db:open-test-db-by-test-id does cdb:remote-run
   (let* ((tdb       (db:open-test-db-by-test-id db test-id))
 	 (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")

Index: launch.scm
==================================================================
--- launch.scm
+++ launch.scm
@@ -59,20 +59,23 @@
 	       (top-path  (assoc/default 'toppath   cmdinfo))
 	       (work-area (assoc/default 'work-area cmdinfo))
 	       (test-name (assoc/default 'test-name cmdinfo))
 	       (runscript (assoc/default 'runscript cmdinfo))
 	       (ezsteps   (assoc/default 'ezsteps   cmdinfo))
-	       (runremote (assoc/default 'runremote cmdinfo))
+	       ;; (runremote (assoc/default 'runremote cmdinfo))
+	       (transport (assoc/default 'transport cmdinfo))
 	       (run-id    (assoc/default 'run-id    cmdinfo))
 	       (test-id   (assoc/default 'test-id   cmdinfo))
 	       (target    (assoc/default 'target    cmdinfo))
 	       (itemdat   (assoc/default 'itemdat   cmdinfo))
 	       (env-ovrd  (assoc/default 'env-ovrd  cmdinfo))
 	       (set-vars  (assoc/default 'set-vars  cmdinfo)) ;; pre-overrides from -setvar
 	       (runname   (assoc/default 'runname   cmdinfo))
 	       (megatest  (assoc/default 'megatest  cmdinfo))
 	       (mt-bindir-path (assoc/default 'mt-bindir-path cmdinfo))
+	       (keys      #f)
+	       (keyvals   #f)
 	       (fullrunscript (if (not runscript)
                                   #f
                                   (if (substring-index "/" runscript)
                                       runscript ;; use unadultered if contains slashes
                                       (let ((fulln (conc testpath "/" runscript)))
@@ -82,11 +85,14 @@
                                               runscript))))) ;; assume it is on the path
 	       (rollup-status 0))
 	  (debug:print 2 "Exectuing " test-name " (id: " test-id ") on " (get-host-name))
 	  ;; Setup the *runremote* global var
 	  (if *runremote* (debug:print 2 "ERROR: I'm not expecting *runremote* to be set at this time"))
-	  (set! *runremote* runremote)
+	  ;; (set! *runremote* runremote)
+	  (set! *transport-type* (string->symbol transport))
+	  (set! keys       (cdb:remote-run db:get-keys #f))
+	  (set! keyvals    (if run-id (cdb:remote-run db:get-key-vals #f run-id) #f))
 	  ;; apply pre-overrides before other variables. The pre-override vars must not
 	  ;; clobbers things from the official sources such as megatest.config and runconfigs.config
 	  (if (string? set-vars)
 	      (let ((varpairs (string-split set-vars ",")))
 		(debug:print 4 "varpairs: " varpairs)
@@ -111,23 +117,24 @@
 		(debug:print 0 "Failed to setup, exiting") 
 		;; (sqlite3:finalize! db)
 		;; (sqlite3:finalize! tdb)
 		(exit 1)))
 	  ;; Can setup as client for server mode now
-	  (server:client-setup)
+	  ;; (server:client-setup)
 
 	  (change-directory *toppath*) 
 	  (set-megatest-env-vars run-id) ;; these may be needed by the launching process
 	  (change-directory work-area) 
 
-	  (open-run-close set-run-config-vars #f run-id)
+	  (open-run-close set-run-config-vars #f run-id keys keyvals)
 	  ;; environment overrides are done *before* the remaining critical envars.
 	  (alist->env-vars env-ovrd)
 	  (set-megatest-env-vars run-id)
 	  (set-item-env-vars itemdat)
 	  (save-environment-as-files "megatest")
-	  (open-run-close test-set-meta-info #f test-id run-id test-name itemdat 0)
+	  ;; open-run-close not needed for test-set-meta-info
+	  (test-set-meta-info #f test-id run-id test-name itemdat 0)
 	  (tests:test-set-status! test-id "REMOTEHOSTSTART" "n/a" (args:get-arg "-m") #f)
 	  (if (args:get-arg "-xterm")
 	      (set! fullrunscript "xterm")
 	      (if (and fullrunscript (not (file-execute-access? fullrunscript)))
 		  (system (conc "chmod ug+x " fullrunscript))))
@@ -197,12 +204,12 @@
 						   
 						   ;; call the command using mt_ezstep
 						   (set! script (conc "mt_ezstep " stepname " " (if prevstep prevstep "-") " " stepcmd))
 
 						   (debug:print 4 "script: " script)
-
-						   (cdb:remote-run db:teststep-set-status! #f test-id stepname "start" "-" #f #f)
+						   ;; DO NOT remote
+						   (db:teststep-set-status! #f test-id stepname "start" "-" #f #f)
 						   ;; now launch
 						   (let ((pid (process-run script)))
 						     (let processloop ((i 0))
 						       (let-values (((pid-val exit-status exit-code)(process-wait pid #t)))
 								   (mutex-lock! m)
@@ -216,11 +223,11 @@
 									 (processloop (+ i 1))))
 								   ))
                                                      (let ((exinfo (vector-ref exit-info 2))
                                                            (logfna (if logpro-used (conc stepname ".html") "")))
 						       ;; testing if procedures called in a remote call cause problems (ans: no or so I suspect)
-						       (cdb:remote-run db:teststep-set-status! #f test-id stepname "end" exinfo #f logfna))
+						       (db:teststep-set-status! #f test-id stepname "end" exinfo #f logfna))
 						     (if logpro-used
 							 (cdb:test-set-log! *runremote*  test-id (conc stepname ".html")))
 						     ;; set the test final status
 						     (let* ((this-step-status (cond
 									       ((and (eq? (vector-ref exit-info 2) 2) logpro-used) 'warn)
@@ -265,11 +272,12 @@
 							    start-seconds)))))
 					(kill-tries 0))
 				   (let loop ((minutes   (calc-minutes)))
 				     (begin
 				       (set! kill-job? (test-get-kill-request test-id)) ;; run-id test-name itemdat))
-				       (open-run-close test-set-meta-info #f test-id run-id test-name itemdat minutes)
+				       ;; open-run-close not needed for test-set-meta-info
+				       (test-set-meta-info #f test-id run-id test-name itemdat minutes)
 				       (if kill-job? 
 					   (begin
 					     (mutex-lock! m)
 					     (let* ((pid (vector-ref exit-info 0)))
 					       (if (number? pid)
@@ -574,11 +582,12 @@
 	  (debug:print 0 "WARNING: No disk work area specified - running in the test directory under tmp_run")))
     (set! cmdparms (base64:base64-encode 
 		    (with-output-to-string
 		      (lambda () ;; (list 'hosts     hosts)
 			(write (list (list 'testpath  test-path)
-				     (list 'runremote *runremote*)
+				     ;; (list 'runremote *runremote*)
+				     (list 'transport (conc *transport-type*))
 				     (list 'toppath   *toppath*)
 				     (list 'work-area work-area)
 				     (list 'test-name test-name) 
 				     (list 'runscript runscript) 
 				     (list 'run-id    run-id   )

Index: megatest-version.scm
==================================================================
--- megatest-version.scm
+++ megatest-version.scm
@@ -1,7 +1,7 @@
 ;; Always use two digit decimal
 ;; 1.01, 1.02...1.10,1.11 ... 1.99,2.00..
 
 (declare (unit megatest-version))
 
-(define megatest-version 1.5212)
+(define megatest-version 1.53)
 

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -91,10 +91,12 @@
   -test-paths             : get the test paths matching target, runname, item and test
                             patterns.
   -list-disks             : list the disks available for storing runs
   -list-targets           : list the targets in runconfigs.config
   -list-db-targets        : list the target combinations used in the db
+  -show-config            : dump the internal representation of the megatest.config file
+  -show-runconfig         : dump the internal representation of the runconfigs.config file
 
 Misc 
   -rebuild-db             : bring the database schema up to date
   -update-meta            : update the tests metadata for all tests
   -env2file fname         : write the environment to fname.csh and fname.sh
@@ -103,10 +105,11 @@
   -server -|hostname      : start the server (reduces contention on megatest.db), use
                             - to automatically figure out hostname
   -transport http|zmq     : use http or zmq for transport (default is http) 
   -list-servers           : list the servers 
   -repl                   : start a repl (useful for extending megatest)
+  -load file.scm          : load and run file.scm
 
 Spreadsheet generation
   -extract-ods fname.ods  : extract an open document spreadsheet from the database
   -pathmod path           : insert path, i.e. path/runame/itempath/logfile.html
                             will clear the field if no rundir/testname/itempath/logfile
@@ -172,10 +175,11 @@
 			"-set-state-status"
 			"-debug" ;; for *verbosity* > 2
 			"-gen-megatest-test"
 			"-override-timeout"
 			"-test-files"  ;; -test-paths is for listing all
+			"-load"        ;; load and exectute a scheme file
 			) 
 		 (list  "-h"
 			"-version"
 		        "-force"
 		        "-xterm"
@@ -194,10 +198,11 @@
 			;; mist queries
 			"-list-disks"
 			"-list-targets"
 			"-list-db-targets"
 			"-show-runconfig"
+			"-show-config"
 			;; queries
 			"-test-paths" ;; get path(s) to a test, ordered by youngest first
 
 			"-runall"    ;; run all tests
 			"-remove-runs"
@@ -333,12 +338,19 @@
 		targets)
       (set! *didsomething* #t)))
 
 (if (args:get-arg "-show-runconfig")
     (begin
+      ;; keep this one local
       (pp (hash-table->alist (open-run-close setup-env-defaults #f "runconfigs.config" #f #f change-env: #f)))
       (set! *didsomething* #t)))
+
+(if (args:get-arg "-show-config")
+    (begin
+      ;; keep this one local
+      (pp (hash-table->alist (open-run-close setup-env-defaults #f "megatest.config" #f #f change-env: #f)))
+      (set! *didsomething* #t)))
 
 ;;======================================================================
 ;; Remove old run(s)
 ;;======================================================================
 
@@ -390,14 +402,14 @@
 	(let* ((db       #f)
 	       (runpatt  (args:get-arg "-list-runs"))
 	       (testpatt (if (args:get-arg "-testpatt") 
 			     (args:get-arg "-testpatt") 
 			     "%"))
-	       (runsdat  (open-run-close db:get-runs db runpatt #f #f '()))
+	       (runsdat  (cdb:remote-run db:get-runs #f runpatt #f #f '()))
 	       (runs     (db:get-rows runsdat))
 	       (header   (db:get-header runsdat))
-	       (keys     (open-run-close db:get-keys db))
+	       (keys     (cdb:remote-run db:get-keys #f))
 	       (keynames (map key:get-fieldname keys))
 	       (db-targets (args:get-arg "-list-db-targets"))
 	       (seen     (make-hash-table)))
 	  ;; Each run
 	  (for-each 
@@ -410,12 +422,12 @@
 		       (begin
 			 (hash-table-set! seen targetstr #t)
 			 ;; (print "[" targetstr "]"))))
 			 (print targetstr))))
 	       (if (not db-targets)
-		   (let* ((run-id (open-run-close db:get-value-by-header run header "id"))
-			  (tests  (open-run-close db:get-tests-for-run db run-id testpatt '() '())))
+		   (let* ((run-id (db:get-value-by-header run header "id"))
+			  (tests  (cdb:remote-run db:get-tests-for-run #f run-id testpatt '() '())))
 		     (debug:print 1 "Run: " targetstr " status: " (db:get-value-by-header run header "state")
 				  " run-id: " run-id ", number tests: " (length tests))
 		     (for-each 
 		      (lambda (test)
 			(format #t
@@ -437,11 +449,12 @@
 				     "\n         diskfree: " (db:test-get-diskfree test)
 				     "\n         uname:    " (db:test-get-uname test)
 				     "\n         rundir:   " (db:test-get-rundir test)
 				     )
 			      ;; Each test
-			      (let ((steps (open-run-close db:get-steps-for-test db (db:test-get-id test))))
+			      ;; DO NOT remote run
+			      (let ((steps (db:get-steps-for-test #f (db:test-get-id test))))
 				(for-each 
 				 (lambda (step)
 				   (format #t 
 					   "    Step: ~20a State: ~10a Status: ~10a Time ~22a\n"
 					   (db:step-get-stepname step)
@@ -554,11 +567,12 @@
 (if (or (args:get-arg "-test-files")(args:get-arg "-test-paths"))
     ;; if we are in a test use the MT_CMDINFO data
     (if (getenv "MT_CMDINFO")
 	(let* ((startingdir (current-directory))
 	       (cmdinfo   (read (open-input-string (base64:base64-decode (getenv "MT_CMDINFO")))))
-	       (runremote (assoc/default 'runremote cmdinfo))
+	       ;; (runremote (assoc/default 'runremote 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))
 	       (run-id    (assoc/default 'run-id    cmdinfo))
@@ -567,22 +581,24 @@
 	       (state     (args:get-arg ":state"))
 	       (status    (args:get-arg ":status"))
 	       (target    (args:get-arg "-target"))
 	       (toppath   (assoc/default 'toppath   cmdinfo)))
 	  (change-directory toppath)
-	  (set! *runremote* runremote)
+	  ;; (set! *runremote* runremote)
+	  (set! *transport-type* (string->symbol transport))
 	  (if (not target)
 	      (begin
 		(debug:print 0 "ERROR: -target is required.")
 		(exit 1)))
 	  (if (not (setup-for-run))
 	      (begin
 		(debug:print 0 "Failed to setup, giving up on -test-paths or -test-files, exiting")
 		(exit 1)))
-	  (let* ((keys     (open-run-close db:get-keys db))
+	  (let* ((keys     (cdb:remote-run db:get-keys db))
 		 (keynames (map key:get-fieldname keys))
-		 (paths    (open-run-close db:test-get-paths-matching db keynames target (args:get-arg "-test-files"))))
+		 ;; db:test-get-paths must not be run remote
+		 (paths    (db:test-get-paths-matching db keynames target (args:get-arg "-test-files"))))
 	    (set! *didsomething* #t)
 	    (for-each (lambda (path)
 			(print path))
 		      paths)))
 	;; else do a general-run-call
@@ -589,11 +605,12 @@
 	(general-run-call 
 	 "-test-files"
 	 "Get paths to test"
 	 (lambda (target runname keys keynames keyvallst)
 	   (let* ((db       #f)
-		  (paths    (open-run-close db:test-get-paths-matching db keynames target (args:get-arg "-test-files"))))
+		  ;; DO NOT run remote
+		  (paths    (db:test-get-paths-matching db keynames target (args:get-arg "-test-files"))))
 	     (for-each (lambda (path)
 			 (print path))
 		       paths))))))
 
 ;;======================================================================
@@ -603,11 +620,12 @@
 (if (args:get-arg "-archive")
     ;; if we are in a test use the MT_CMDINFO data
     (if (getenv "MT_CMDINFO")
 	(let* ((startingdir (current-directory))
 	       (cmdinfo   (read (open-input-string (base64:base64-decode (getenv "MT_CMDINFO")))))
-	       (runremote (assoc/default 'runremote cmdinfo))
+	       ;; (runremote (assoc/default 'runremote 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))
 	       (run-id    (assoc/default 'run-id    cmdinfo))
@@ -615,22 +633,24 @@
 	       (db        #f)
 	       (state     (args:get-arg ":state"))
 	       (status    (args:get-arg ":status"))
 	       (target    (args:get-arg "-target")))
 	  (change-directory testpath)
-	  (set! *runremote* runremote)
+	  ;; (set! *runremote* runremote)
+	  (set! *transport-type* (string->symbol transport))
 	  (if (not target)
 	      (begin
 		(debug:print 0 "ERROR: -target is required.")
 		(exit 1)))
 	  (if (not (setup-for-run))
 	      (begin
 		(debug:print 0 "Failed to setup, giving up on -archive, exiting")
 		(exit 1)))
-	  (let* ((keys     (open-run-close db:get-keys db))
+	  (let* ((keys     (cdb:remote-run db:get-keys db))
 		 (keynames (map key:get-fieldname keys))
-		 (paths    (open-run-close db:test-get-paths-matching db keynames target)))
+		 ;; DO NOT run remote
+		 (paths    (db:test-get-paths-matching db keynames target)))
 	    (set! *didsomething* #t)
 	    (for-each (lambda (path)
 			(print path))
 		      paths)))
 	;; else do a general-run-call
@@ -637,11 +657,12 @@
 	(general-run-call 
 	 "-test-paths"
 	 "Get paths to tests"
 	 (lambda (target runname keys keynames keyvallst)
 	   (let* ((db       #f)
-		  (paths    (open-run-close db:test-get-paths-matching db keynames target)))
+		  ;; DO NOT run remote
+		  (paths    (db:test-get-paths-matching db keynames target)))
 	     (for-each (lambda (path)
 			 (print path))
 		       paths))))))
 
 ;;======================================================================
@@ -657,11 +678,11 @@
 	     (outputfile (args:get-arg "-extract-ods"))
 	     (runspatt   (args:get-arg ":runname"))
 	     (pathmod    (args:get-arg "-pathmod"))
 	     (keyvalalist (keys->alist keys "%")))
 	 (debug:print 2 "Extract ods, outputfile: " outputfile " runspatt: " runspatt " keyvalalist: " keyvalalist)
-	 (open-run-close db:extract-ods-file db outputfile keyvalalist (if runspatt runspatt "%") pathmod)))))
+	 (cdb:remote-run db:extract-ods-file db outputfile keyvalalist (if runspatt runspatt "%") pathmod)))))
 
 ;;======================================================================
 ;; execute the test
 ;;    - gets called on remote host
 ;;    - receives info from the -execute param
@@ -675,44 +696,52 @@
       (set! *didsomething* #t)))
 
 ;;======================================================================
 ;; Test commands (i.e. for use inside tests)
 ;;======================================================================
+
+(define (megatest:step step state status logfile msg)
+  (if (not (getenv "MT_CMDINFO"))
+      (begin
+	(debug:print 0 "ERROR: MT_CMDINFO env var not set, -step must be called *inside* a megatest invoked environment!")
+	(exit 5))
+      (let* ((cmdinfo   (read (open-input-string (base64:base64-decode (getenv "MT_CMDINFO")))))
+	     ;; (runremote (assoc/default 'runremote 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))
+	     (run-id    (assoc/default 'run-id    cmdinfo))
+	     (test-id   (assoc/default 'test-id   cmdinfo))
+	     (itemdat   (assoc/default 'itemdat   cmdinfo))
+	     (db        #f))
+	(change-directory testpath)
+	;; (set! *runremote* runremote)
+	(set! *transport-type* (string->symbol transport))
+	(if (not (setup-for-run))
+	    (begin
+	      (debug:print 0 "Failed to setup, exiting")
+	      (exit 1)))
+	(if (and state status)
+	    ;; DO NOT remote run
+	    (db:teststep-set-status! db test-id step state status msg logfile)
+	    (begin
+	      (debug:print 0 "ERROR: You must specify :state and :status with every call to -step")
+	      (exit 6))))))
 
 (if (args:get-arg "-step")
-    (if (not (getenv "MT_CMDINFO"))
-	(begin
-	  (debug:print 0 "ERROR: MT_CMDINFO env var not set, -step must be called *inside* a megatest invoked environment!")
-	  (exit 5))
-	(let* ((step      (args:get-arg "-step"))
-	       (cmdinfo   (read (open-input-string (base64:base64-decode (getenv "MT_CMDINFO")))))
-	       (runremote (assoc/default 'runremote 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))
-	       (run-id    (assoc/default 'run-id    cmdinfo))
-	       (test-id   (assoc/default 'test-id   cmdinfo))
-	       (itemdat   (assoc/default 'itemdat   cmdinfo))
-	       (db        #f)
-	       (state    (args:get-arg ":state"))
-	       (status   (args:get-arg ":status"))
-	       (logfile  (args:get-arg "-setlog")))
-	  (change-directory testpath)
-	  (set! *runremote* runremote)
-	  (if (not (setup-for-run))
-	      (begin
-		(debug:print 0 "Failed to setup, exiting")
-		(exit 1)))
-	  (if (and state status)
-	      (open-run-close db:teststep-set-status! db test-id step state status (args:get-arg "-m") logfile)
-	      (begin
-		(debug:print 0 "ERROR: You must specify :state and :status with every call to -step")
-		(exit 6)))
-	  (if db (sqlite3:finalize! db))
-	  (set! *didsomething* #t))))
-
+    (begin
+      (megatest:step 
+       (args:get-arg "-step")
+       (args:get-arg ":state")
+       (args:get-arg ":status")
+       (args:get-arg "-setlog")
+       (args:get-arg "-m"))
+      ;; (if db (sqlite3:finalize! db))
+      (set! *didsomething* #t)))
+    
 (if (or (args:get-arg "-setlog")       ;; since setting up is so costly lets piggyback on -test-status
 	(args:get-arg "-set-toplog")
 	(args:get-arg "-test-status")
 	(args:get-arg "-set-values")
 	(args:get-arg "-load-test-data")
@@ -722,41 +751,46 @@
 	(begin
 	  (debug:print 0 "ERROR: MT_CMDINFO env var not set, commands -test-status, -runstep and -setlog must be called *inside* a megatest environment!")
 	  (exit 5))
 	(let* ((startingdir (current-directory))
 	       (cmdinfo   (read (open-input-string (base64:base64-decode (getenv "MT_CMDINFO")))))
-	       (runremote (assoc/default 'runremote cmdinfo))
+	       ;; (runremote (assoc/default 'runremote 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))
 	       (run-id    (assoc/default 'run-id    cmdinfo))
 	       (test-id   (assoc/default 'test-id   cmdinfo))
 	       (itemdat   (assoc/default 'itemdat   cmdinfo))
-	       (db        #f)
+	       (db        #f) ;; (open-db))
 	       (state     (args:get-arg ":state"))
 	       (status    (args:get-arg ":status")))
 	  (change-directory testpath)
-	  (set! *runremote* runremote)
+	  ;; (set! *runremote* runremote)
+	  (set! *transport-type* (string->symbol transport))
 	  (if (not (setup-for-run))
 	      (begin
 		(debug:print 0 "Failed to setup, exiting")
 		(exit 1)))
 
 	  ;; can setup as client for server mode now
-	  (server:client-setup)
+	  ;; (server:client-setup)
 
 	  (if (args:get-arg "-load-test-data")
 	      ;; has sub commands that are rdb:
-	      (open-run-close db:load-test-data db test-id))
+	      ;; DO NOT put this one into either cdb:remote-run or open-run-close
+	      (db:load-test-data db test-id))
 	  (if (args:get-arg "-setlog")
 	      (let ((logfname (args:get-arg "-setlog")))
 		(cdb:test-set-log! *runremote* test-id logfname)))
 	  (if (args:get-arg "-set-toplog")
-	      (open-run-close tests:test-set-toplog! db run-id test-name (args:get-arg "-set-toplog")))
+	      ;; DO NOT run remote
+	      (tests:test-set-toplog! db run-id test-name (args:get-arg "-set-toplog")))
 	  (if (args:get-arg "-summarize-items")
-	      (open-run-close tests:summarize-items db run-id test-name #t)) ;; do force here
+	      ;; DO NOT run remote
+	      (tests:summarize-items db run-id test-name #t)) ;; do force here
 	  (if (args:get-arg "-runstep")
 	      (if (null? remargs)
 		  (begin
 		    (debug:print 0 "ERROR: nothing specified to run!")
 		    (if db (sqlite3:finalize! db))
@@ -774,11 +808,12 @@
 				       (else ">&")))
 			 (fullcmd    (conc "(" (string-intersperse 
 						(cons cmd params) " ")
 					   ") " redir " " logfile)))
 		    ;; mark the start of the test
-		    (open-run-close db:teststep-set-status! db test-id stepname "start" "n/a" (args:get-arg "-m") logfile)
+		    ;; DO NOT run remote
+		    (db:teststep-set-status! db test-id stepname "start" "n/a" (args:get-arg "-m") logfile)
 		    ;; run the test step
 		    (debug:print-info 2 "Running \"" fullcmd "\"")
 		    (change-directory startingdir)
 		    (set! exitstat (system fullcmd)) ;; cmd params))
 		    (set! *globalexitstatus* exitstat)
@@ -793,11 +828,12 @@
 			  (set! exitstat (system cmd))
 			  (set! *globalexitstatus* exitstat) ;; no necessary
 			  (change-directory testpath)
 			  (cdb:test-set-log! *runremote* test-id htmllogfile)))
 		    (let ((msg (args:get-arg "-m")))
-		      (open-run-close db:teststep-set-status! db test-id stepname "end" exitstat msg logfile))
+		      ;; DO NOT run remote
+		      (db:teststep-set-status! db test-id stepname "end" exitstat msg logfile))
 		    )))
 	  (if (or (args:get-arg "-test-status")
 		  (args:get-arg "-set-values"))
 	      (let ((newstatus (cond
 				((number? status)       (if (equal? status 0) "PASS" "FAIL"))
@@ -835,11 +871,11 @@
 	  (keys #f))
       (if (not (setup-for-run))
 	  (begin
 	    (debug:print 0 "Failed to setup, exiting")
 	    (exit 1)))
-      (set! keys (open-run-close db:get-keys db))
+      (set! keys (cbd:remote-run db:get-keys db))
       (debug:print 1 "Keys: " (string-intersperse (map key:get-fieldname keys) ", "))
       (if db (sqlite3:finalize! db))
       (set! *didsomething* #t)))
 
 (if (args:get-arg "-gui")
@@ -866,10 +902,11 @@
     (begin
       (if (not (setup-for-run))
 	  (begin
 	    (debug:print 0 "Failed to setup, exiting") 
 	    (exit 1)))
+      ;; keep this one local
       (open-run-close patch-db #f)
       (set! *didsomething* #t)))
 
 ;;======================================================================
 ;; Update the tests meta data from the testconfig files
@@ -880,32 +917,37 @@
       (if (not (setup-for-run))
 	  (begin
 	    (debug:print 0 "Failed to setup, exiting") 
 	    (exit 1)))
       ;; now can find our db
+      ;; keep this one local
       (open-run-close runs:update-all-test_meta db)
       (set! *didsomething* #t)))
 
 ;;======================================================================
 ;; Start a repl
 ;;======================================================================
 
-(if (args:get-arg "-repl")
+(if (or (args:get-arg "-repl")
+	(args:get-arg "-load"))
     (let* ((toppath (setup-for-run))
 	   (db      (if toppath (open-db) #f)))
       (if db
 	  (begin
 	    (set! *db* db)
 	    (set! *client-non-blocking-mode* #t)
-	    (server:client-setup)
+	    ;; (server:client-setup)
+	    ;; (server:client-launch)
 	    (import readline)
 	    (import apropos)
 	    (gnu-history-install-file-manager
 	     (string-append
 	      (or (get-environment-variable "HOME") ".") "/.megatest_history"))
 	    (current-input-port (make-gnu-readline-port "megatest> "))
-	    (repl))
+	    (if (args:get-arg "-repl")
+		(repl)
+		(load (args:get-arg "-load"))))
 	  (exit))
       (set! *didsomething* #t)))
 
 ;;======================================================================
 ;; Exit and clean up

Index: runconfig.scm
==================================================================
--- runconfig.scm
+++ runconfig.scm
@@ -10,13 +10,14 @@
 
 (include "common_records.scm")
 
 
 
-(define (setup-env-defaults db fname run-id already-seen #!key (environ-patt #f)(change-env #t))
-  (let* ((keys    (db:get-keys db))
-	 (keyvals (if run-id (db:get-key-vals db run-id) #f))
+;; (define (setup-env-defaults db fname run-id already-seen #!key (environ-patt #f)(change-env #t))
+(define (setup-env-defaults fname run-id already-seen keys keyvals #!key (environ-patt #f)(change-env #t))
+  (let* (;; (keys    (db:get-keys db))
+	 ;; (keyvals (if run-id (db:get-key-vals db run-id) #f))
 	 (thekey  (if keyvals (string-intersperse (map (lambda (x)(if x x "-na-")) keyvals) "/")
 		      (if (args:get-arg "-reqtarg") 
 			  (args:get-arg "-reqtarg")
 			  (if (args:get-arg "-target")
 			      (args:get-arg "-target")
@@ -58,17 +59,18 @@
 		    sections)
 	  (debug:print 2 "---")
 	  (set! *already-seen-runconfig-info* #t)))
     finaldat))
 
-(define (set-run-config-vars db run-id)
+(define (set-run-config-vars db run-id keys keyvals)
   (let ((runconfigf (conc  *toppath* "/runconfigs.config"))
 	(targ       (or (args:get-arg "-target")
 			(args:get-arg "-reqtarg")
 			(db:get-target db run-id))))
     (if (file-exists? runconfigf)
-	(setup-env-defaults db runconfigf run-id #t environ-patt: (conc "(default"
-									(if targ
-									    (conc "|" targ ")")
-									    ")")))
+	(setup-env-defaults runconfigf run-id #t keys keyvals
+			    environ-patt: (conc "(default"
+						(if targ
+						    (conc "|" targ ")")
+						    ")")))
 	(debug:print 0 "WARNING: You do not have a run config file: " runconfigf))))
  

Index: runs.scm
==================================================================
--- runs.scm
+++ runs.scm
@@ -215,10 +215,11 @@
   (common:clear-caches) ;; clear all caches
   (let* ((db          #f)
 	 (keys        (cdb:remote-run db:get-keys #f))
 	 (keyvallst   (keys:target->keyval keys target))
 	 (run-id      (cdb:remote-run runs:register-run #f keys keyvallst runname "new" "n/a" user))  ;;  test-name)))
+	 (keyvals     (if run-id (cdb:remote-run db:get-key-vals #f run-id) #f))
 	 (deferred    '()) ;; delay running these since they have a waiton clause
 	 ;; keepgoing is the defacto modality now, will add hit-n-run a bit later
 	 ;; (keepgoing   (hash-table-ref/default flags "-keepgoing" #f))
 	 (runconfigf   (conc  *toppath* "/runconfigs.config"))
 	 (required-tests '())
@@ -225,11 +226,11 @@
 	 (test-records (make-hash-table)))
 
     (set-megatest-env-vars run-id) ;; these may be needed by the launching process
 
     (if (file-exists? runconfigf)
-	(open-run-close setup-env-defaults db runconfigf run-id *already-seen-runconfig-info* "pre-launch-env-vars")
+	(setup-env-defaults runconfigf run-id *already-seen-runconfig-info* keys keyvals "pre-launch-env-vars")
 	(debug:print 0 "WARNING: You do not have a run config file: " runconfigf))
     
     ;; look up all tests matching the comma separated list of globs in
     ;; test-patts (using % as wildcard)
 
@@ -884,15 +885,15 @@
 	(if (not (setup-for-run))
 	    (begin 
 	      (debug:print 0 "Failed to setup, exiting")
 	      (exit 1)))
 	(if (args:get-arg "-server")
-	    (open-run-close server:start db (args:get-arg "-server"))
- 	    (if (not (or (args:get-arg "-runall")     ;; runall and runtests are allowed to be servers
- 			 (args:get-arg "-runtests")))
-		(server:client-setup) ;; This is a duplicate startup!!!??? BUG?
-		))
+	    (open-run-close server:start db (args:get-arg "-server")))
+ 	    ;; (if (not (or (args:get-arg "-runall")     ;; runall and runtests are allowed to be servers
+ 	    ;;     	 (args:get-arg "-runtests")))
+	    ;;     (server:client-setup) ;; This is a duplicate startup!!!??? BUG?
+	    ;;     ))
 	(set! keys (open-run-close db:get-keys db))
 	;; have enough to process -target or -reqtarg here
 	(if (args:get-arg "-reqtarg")
 	    (let* ((runconfigf (conc  *toppath* "/runconfigs.config")) ;; DO NOT EVALUATE ALL 
 		   (runconfig  (read-config runconfigf #f #f environ-patt: #f))) 

Index: server.scm
==================================================================
--- server.scm
+++ server.scm
@@ -8,11 +8,11 @@
 ;;  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 ;;  PURPOSE.
 
 (require-extension (srfi 18) extras tcp s11n)
 
-(use sqlite3 srfi-1 posix regex regex-case srfi-69 hostinfo md5 message-digest)
+(use sqlite3 srfi-1 posix regex regex-case srfi-69 hostinfo md5 message-digest zmq)
 (import (prefix sqlite3 sqlite3:))
 
 (use spiffy uri-common intarweb http-client spiffy-request-vars)
 
 (declare (unit server))
@@ -129,12 +129,13 @@
   ;; (send-message pubsock 
   (case *transport-type*
     ((fs) result)
     ((http)(db:obj->string (vector success/fail query-sig result)))
     ((zmq)
-     (send-message pubsock target send-more: #t)
-     (send-message pubsock (db:obj->string (vector success/fail query-sig result))))
+     (let ((pub-socket (vector-ref *runremote* 1)))
+       (send-message pub-socket return-addr send-more: #t)
+       (send-message pub-socket (db:obj->string (vector success/fail query-sig result)))))
     (else 
      (debug:print 0 "ERROR: unrecognised transport type: " *transport-type*)
      result)))
 
 ;;======================================================================
@@ -154,58 +155,51 @@
 (define (server:client-logout serverdat)
   (let ((ok (and (socket? serverdat)
 		 (cdb:logout serverdat *toppath* (server:get-client-signature)))))
     ok))
 
-(define (server:client-connect iface port)
-  (let* ((login-res   #f)
-	 (serverdat   (list iface port)))
-    (set! login-res (server:client-login serverdat))
-    (if (and (not (null? login-res))
-	     (car login-res))
-	(begin
-	  (debug:print-info 2 "Logged in and connected to " iface ":" port)
-	  (set! *runremote* serverdat)
-	  serverdat)
-	(begin
-	  (debug:print-info 2 "Failed to login or connect to " iface ":" port)
-	  (set! *runremote* #f)
-	  #f))))
-
 ;; Do all the connection work, look up the transport type and set up the
 ;; connection if required.
 ;;
+;; There are two scenarios. 
+;;   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 mush figure out
+;;      *transport-type* and *runremote* from the monitor.db
+;;
 (define (server:client-setup #!key (numtries 50))
   (if (not *toppath*)
       (if (not (setup-for-run))
 	  (begin
 	    (debug:print 0 "ERROR: failed to find megatest.config, exiting")
 	    (exit))))
-  (debug:print-info 11 "*transport-type* is " *transport-type*)
-  (let* ((hostinfo   (if (not *transport-type*) ;; If we dont' already have transport type set then figure it out
-			 (open-run-close tasks:get-best-server tasks:open-db)
-			 #f)))
+  (debug:print-info 11 "*transport-type* is " *transport-type* ", *runremote* is " *runremote*)
+  (let* ((hostinfo  (if (not *transport-type*) ;; If we dont' already have transport type set then figure it out
+			(open-run-close tasks:get-best-server tasks:open-db)
+			#f)))
     ;; if have hostinfo then extract the transport type 
     ;; else fall back to fs
     (debug:print-info 11 "CLIENT SETUP, hostinfo=" hostinfo)
     (set! *transport-type* (if hostinfo 
-			       (string->symbol (tasks:hostinfo-get-transport hostinfo))
+    			       (string->symbol (tasks:hostinfo-get-transport hostinfo))
 			       'fs))
+    ;; ;; DEBUG STUFF
+    ;; (if (eq? *transport-type* 'fs)(begin (print "ERROR!!!!!!! refusing to run with transport " *transport-type*)(exit 99)))
+    
     (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
-     (set! *transport-type* 'fs)
-     (set! *megatest-db*    (open-db))))))
-
+      ((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* " attempting to continue with fs")
+       (set! *transport-type* 'fs)
+       (set! *megatest-db*    (open-db))))))
 
 
 ;; all routes though here end in exit ...
 (define (server:launch transport)
   (if (not *toppath*)

Index: tasks.scm
==================================================================
--- tasks.scm
+++ tasks.scm
@@ -194,13 +194,13 @@
     (sqlite3:for-each-row
      (lambda (id interface port pubport transport pid hostname)
        (set! res (cons (vector id interface port pubport transport pid hostname) res))
        (debug:print-info 2 "Found existing server " hostname ":" port " registered in db"))
      mdb
+     ;;          strftime('%s','now')-heartbeat < 10 AND
      "SELECT id,interface,port,pubport,transport,pid,hostname FROM servers
-         WHERE strftime('%s','now')-heartbeat < 10
-               AND mt_version=? ORDER BY start_time ASC LIMIT 1;" megatest-version)
+               WHERE mt_version=? ORDER BY start_time DESC LIMIT 1;" megatest-version)
     ;; for now we are keeping only one server registered in the db, return #f or first server found
     (if (null? res) #f (car res))))
 
 ;; BUG: This logic is probably needed unless methodology changes completely...
 ;;

Index: tests.scm
==================================================================
--- tests.scm
+++ tests.scm
@@ -484,36 +484,34 @@
 	   (set! res count))
 	 tdb
 	 "SELECT count(id) FROM test_rundat;")
 	res))
   0)
+
+(define (db:update-central-meta-info db test-id cpuload diskfree minutes num-records uname hostname)
+  (sqlite3:execute db "UPDATE tests SET cpuload=?,diskfree=? WHERE id=?;"
+		   cpuload
+		   diskfree
+		   test-id)
+  (if minutes (sqlite3:execute db "UPDATE tests SET run_duration=? WHERE id=?;" minutes test-id))
+  (if (eq? num-records 0)
+      (sqlite3:execute db "UPDATE tests SET uname=?,host=? WHERE id=?;"
+		       uname hostname test-id)))
 
 (define (test-set-meta-info db test-id run-id testname itemdat minutes)
+  ;; DOES cdb:remote-run under the hood!
   (let* ((tdb         (db:open-test-db-by-test-id db test-id))
 	 (num-records (test:tdb-get-rundat-count tdb))
-	 (item-path   (item-list->path itemdat))
 	 (cpuload  (get-cpu-load))
 	 (diskfree (get-df (current-directory))))
     (if (eq? (modulo num-records 10) 0) ;; every ten records update central
-	(begin
-	  (sqlite3:execute db "UPDATE tests SET cpuload=?,diskfree=? WHERE run_id=? AND testname=? AND item_path=?;"
-			   cpuload
-			   diskfree
-			   run-id
-			   testname
-			   item-path)
-	  (if minutes (sqlite3:execute db "UPDATE tests SET run_duration=? WHERE id=?;" minutes test-id))
-	  (if (eq? num-records 0)
-	      (let ((uname (get-uname "-srvpio"))
-		    (hostname (get-host-name)))
-		(sqlite3:execute db "UPDATE tests SET uname=?,host=? WHERE run_id=? AND testname=? AND item_path=?;"
-				 uname hostname run-id testname item-path)))))
-                
+	(let ((uname    (get-uname "-srvpio"))
+	      (hostname (get-host-name)))
+	  (cdb:remote-run db:update-central-meta-info db test-id cpuload diskfree minutes num-records uname hostname)))
     (sqlite3:execute tdb "INSERT INTO test_rundat (update_time,cpuload,diskfree,run_duration) VALUES (strftime('%s','now'),?,?,?);"
 		     cpuload diskfree minutes)))
 	  
-
 ;;======================================================================
 ;; A R C H I V I N G
 ;;======================================================================
 
 (define (test:archive db test-id)

Index: tests/fullrun/config/mt_include_1.config
==================================================================
--- tests/fullrun/config/mt_include_1.config
+++ tests/fullrun/config/mt_include_1.config
@@ -1,8 +1,8 @@
 [setup]
 # exectutable /path/to/megatest
-max_concurrent_jobs 50
+max_concurrent_jobs 60
 linktree #{getenv MT_RUN_AREA_HOME}/tmp/mt_links
 
 [jobtools]
 useshell yes
 # ## launcher launches jobs, the job is managed on the target host

Index: zmq-transport.scm
==================================================================
--- zmq-transport.scm
+++ zmq-transport.scm
@@ -73,11 +73,12 @@
   (if (not *toppath*)
       (if (not (setup-for-run))
 	  (begin
 	    (debug:print 0 "ERROR: cannot find megatest.config, cannot start server, exiting")
 	    (exit))))
-  (let* ((zmq-sdat1       #f)
+  (let* ((db              (open-db)) ;; here we *do not* want to be opening and closing the db
+	 (zmq-sdat1       #f)
 	 (zmq-sdat2       #f)
 	 (pull-socket     #f)
 	 (pub-socket      #f)
 	 (p1              #f)
 	 (p2              #f)
@@ -102,10 +103,12 @@
     (set! zmq-sdat2    (cadr  zmq-sockets-dat))
     (set! pub-socket   (cadr  zmq-sdat2))
     (set! p2           (caddr zmq-sdat2))
 
     (set! *cache-on* #t)
+
+    (set! *runremote* (vector pull-socket pub-socket)) ;; overloading the use of *runremote* BUG!?
 
     ;; what to do when we quit
     ;;
 ;;     (on-exit (lambda ()
 ;; 	       (if (and *toppath* *server-info*)
@@ -136,11 +139,13 @@
 	      (mutex-lock! *heartbeat-mutex*)
 	      (set! *last-db-access* (current-seconds))
 	      (mutex-unlock! *heartbeat-mutex*)))
 	(if #t ;; (cdb:packet-get-immediate packet) ;; process immediately or put in queue
 	    (begin
-	      (open-run-close db:process-queue #f pub-socket (cons packet queue-lst))
+	      (db:process-queue-item db packet)
+	      ;; (open-run-close db:process-queue #f pub-socket (cons packet queue-lst))
+	      
 	      (loop '()))
 	    (loop (cons packet queue-lst)))))))
 
 ;; run zmq-transport:keep-running in a parallel thread to monitor that the db is being 
 ;; used and to shutdown after sometime if it is not.
@@ -280,15 +285,15 @@
 
 (define (zmq-transport:client-connect iface pullport pubport)
   (let* ((push-socket (zmq-transport:client-socket-connect iface pullport type: 'push))
 	 (sub-socket  (zmq-transport:client-socket-connect iface pubport
 						    type: 'sub
-						    subscriptions: (list (zmq-transport:get-client-signature) "all")))
+						    subscriptions: (list (server:get-client-signature) "all")))
 	 (zmq-sockets (vector push-socket sub-socket))
 	 (login-res   #f))
     (debug:print-info 11 "zmq-transport:client-connect started. Next is login")
-    (set! login-res (zmq-transport:client-login zmq-sockets))
+    (set! login-res (server:client-login zmq-sockets))
     (if (and (not (null? login-res))
 	     (car login-res))
 	(begin
 	  (debug:print-info 2 "Logged in and connected to " iface ":" pullport "/" pubport ".")
 	  (set! *runremote* zmq-sockets)
@@ -381,16 +386,16 @@
 	     (th2 (make-thread (lambda ()
 				 (zmq-transport:run 
 				  (if (args:get-arg "-server")
 				      (args:get-arg "-server")
 				      "-"))) "Server run"))
-	     (th3 (make-thread (lambda ()(zmq-transport:keep-running)) "Keep running"))
+	     ;; (th3 (make-thread (lambda ()(zmq-transport:keep-running)) "Keep running"))
 	     )
 	(set! *client-non-blocking-mode* #t)
 	;; (thread-start! th1)
 	(thread-start! th2)
-	(thread-start! th3)
+	;; (thread-start! th3)
 	(set! *didsomething* #t)
 	;; (thread-join! th3)
 	(thread-join! th2)
 	)
       (debug:print 0 "ERROR: Failed to setup for megatest")))