@@ -294,7 +294,753 @@
 	     ;; call end of eud of run detection for posthook - from merge, is it needed?
 	     ;; (launch:end-of-run-check run-id)
 	     all-ids)
 	    )))))
 
+;;======================================================================
+
+(define *send-receive-mutex* (make-mutex)) ;; should have separate mutex per run-id
+(define *ttdat* #f)
+
+;; NB// area-dat replaced by ttdat
+;; 
+(define (rmt:send-receive cmd run-id params #!key (attemptnum 1)(ttdat #f))
+  (assert (or (not run-id) (number? run-id)) "FATAL: run-id is required to be a number or #f")
+  (assert *toppath* "FATAL: rmt:send-receive called with *toppath* not set.")
+  (let* ((areapath      *toppath*) ;; TODO - resolve from dbstruct to be compatible with multiple areas
+	 (readonly-mode (rmtmod:calc-ro-mode ttdat *toppath*))
+	 (testsuite     (common:get-testsuite-name)))
+    (case (rmt:transport-mode)
+      ((tcp)
+       (let* ((start-time    (current-seconds)) ;; snapshot time so all use cases get same value
+	      (attemptnum    (+ 1 attemptnum))
+	      (mtexe         (common:find-local-megatest))
+	      (dbfname       (conc (dbfile:run-id->dbnum run-id)".db"))
+	      (ttdat         (rmt:set-ttdat areapath ttdat))
+	      (conn          (tt:get-conn ttdat dbfname))
+	      (is-main       (equal? dbfname "main.db")) ;; why not (not run-id) ?
+	      (server-start-proc (if is-main
+				     #f
+				     (lambda ()
+				       ;; (debug:print-info 0 *default-log-port* "starting server for dbfname: "dbfname)
+				       (rmt:start-server ;; tt:server-process-run
+					areapath
+					testsuite ;; (dbfile:testsuite-name)
+					mtexe
+					run-id)))))
+	 ;; here we look at ttdat, if dbfname is NOT main.db we check that a conn exists for it
+	 ;; and if there is no conn we first send a request to the main.db server to start a
+	 ;; server for the dbfname.
+	 #;(if (and (not is-main)(not conn)) ;; no existing connection to non-main server, call in a start up request
+	 (begin
+	 (server-start-proc)
+	 (thread-sleep! 1)))
+	 (tt:handler ttdat cmd run-id params attemptnum readonly-mode dbfname testsuite mtexe server-start-proc)))
+      ((nfs)
+       (nfs-transport-handler cmd run-id params attemptnum areapath readonly-mode testsuite))
+      (else
+       (debug:print-info 0 *default-log-port* "rmt:transport-mode is "(rmt:transport-mode))
+       (assert #f "FATAL: rmt:transport-mode set to invalid value.")))))
+
+(define (nfs-transport-handler cmd run-id params attemptnum areapath readonly-mode testsuite)
+  (let* ((keys     (common:get-fields *configdat*))
+	 (dbstruct (dbmod:nfs-get-dbstruct run-id keys (dbfile:db-init-proc) areapath)))
+    (api:dispatch-request dbstruct cmd run-id params)))
+	
+(define (rmt:get-max-query-average run-id)
+  (mutex-lock! *db-stats-mutex*)
+  (let* ((runkey (conc "run-id=" run-id " "))
+	 (cmds   (filter (lambda (x)
+			   (substring-index runkey x))
+			 (hash-table-keys *db-stats*)))
+	 (res    (if (null? cmds)
+		     (cons 'none 0)
+		     (let loop ((cmd (car cmds))
+				(tal (cdr cmds))
+				(max-cmd (car cmds))
+				(res 0))
+		       (let* ((cmd-dat (hash-table-ref *db-stats* cmd))
+			      (tot     (vector-ref cmd-dat 0))
+			      (curravg (/ (vector-ref cmd-dat 1) (vector-ref cmd-dat 0))) ;; count is never zero by construction
+			      (currmax (max res curravg))
+			      (newmax-cmd (if (> curravg res) cmd max-cmd)))
+			 (if (null? tal)
+			     (if (> tot 10)
+				 (cons newmax-cmd currmax)
+				 (cons 'none 0))
+			     (loop (car tal)(cdr tal) newmax-cmd currmax)))))))
+    (mutex-unlock! *db-stats-mutex*)
+    res))
+
+(define (rmt:open-qry-close-locally cmd run-id params #!key (remretries 5))
+  (let* ((qry-is-write    (not (member cmd api:read-only-queries)))
+	 (db-file-path    (common:make-tmpdir-name *toppath* "")) ;;  0))
+	 (dbstructs-local (db:setup))
+	 (read-only       (not (file-write-access? db-file-path)))
+	 (start           (current-milliseconds))
+	 (resdat          (if (not (and read-only qry-is-write))
+			      (let ((v (api:execute-requests dbstructs-local (vector (symbol->string cmd) params))))
+			;;	(handle-exceptions ;; there has been a long history of receiving strange errors from values returned by the client when things go wrong..
+			;;	 exn               ;;  This is an attempt to detect that situation and recover gracefully
+			;;	 (begin
+			;;	   (debug:print 0 *default-log-port* "ERROR: bad data from server " v " message: "  ((condition-property-accessor 'exn 'message) exn) ", exn=" exn)
+			;;	   (vector #t '())) ;; should always get a vector but if something goes wrong return a dummy
+				 (if (and (vector? v)
+					  (> (vector-length v) 1))
+				     (let ((newvec (vector (vector-ref v 0)(vector-ref v 1))))
+				       newvec)           ;; by copying the vector while inside the error handler we should force the detection of a corrupted record
+				     (vector #t '()))) ;; )  ;; we could also check that the returned types are valid
+			      (vector #t '())))
+	 (success        (vector-ref resdat 0))
+	 (res            (vector-ref resdat 1))
+	 (duration       (- (current-milliseconds) start)))
+    (if (and read-only qry-is-write)
+        (debug:print 0 *default-log-port* "ERROR: attempt to write to read-only database ignored. cmd=" cmd))
+    (if (not success)
+	(if (> remretries 0)
+	    (begin
+	      (debug:print-error 0 *default-log-port* "local query failed. Trying again.")
+	      (thread-sleep! (/ (random 5000) 1000)) ;; some random delay 
+	      (rmt:open-qry-close-locally cmd run-id params remretries: (- remretries 1)))
+	    (begin
+	      (debug:print-error 0 *default-log-port* "too many retries in rmt:open-qry-close-locally, giving up")
+	      #f))
+	(begin
+	  ;; (rmt:update-db-stats run-id cmd params duration)
+	  ;; mark this run as dirty if this was a write, the watchdog is responsible for syncing it
+	  (if qry-is-write
+	      (let ((start-time (current-seconds)))
+		(mutex-lock! *db-multi-sync-mutex*)
+		(set! *db-last-access* start-time)  ;; THIS IS PROBABLY USELESS? (we are on a client)
+                (mutex-unlock! *db-multi-sync-mutex*)))))
+    res))
+
+;;======================================================================
+;;
+;; A C T U A L   A P I   C A L L S  
+;;
+;;======================================================================
+
+;;======================================================================
+;;  S E R V E R
+;;======================================================================
+
+(define (rmt:kill-server run-id)
+  (rmt:send-receive 'kill-server run-id (list run-id)))
+
+(define (rmt:start-server areapath testsuite mtexe run-id) ;; run on main.db server
+  (rmt:send-receive 'start-server #f (list areapath testsuite mtexe run-id)))
+
+;;======================================================================
+;;  M I S C
+;;======================================================================
+
+(define (rmt:login run-id)
+  (rmt:send-receive 'login run-id (list *toppath* megatest-version (client:get-signature))))
+
+;; This login does no retries under the hood - it acts a bit like a ping.
+;; Deprecated for nmsg-transport.
+;;
+;; (define (rmt:login-no-auto-client-setup runremote)
+;;   (rmt:send-receive-no-auto-client-setup runremote 'login #f (list *toppath* megatest-version (client:get-signature))))
+
+
+;; given a hostname, return a pair of cpu load and update time representing latest intelligence from tests running on that host
+(define (rmt:get-latest-host-load hostname)
+  (rmt:send-receive 'get-latest-host-load #f (list hostname)))
+
+(define (rmt:sdb-qry qry val run-id)
+  ;; add caching if qry is 'getid or 'getstr
+  (rmt:send-receive 'sdb-qry run-id (list qry val)))
+
+;; NOT COMPLETED
+(define (rmt:runtests user run-id testpatt params)
+  (rmt:send-receive 'runtests run-id testpatt))
+
+(define (rmt:get-run-record-ids  target run keynames )
+  (rmt:send-receive 'get-run-record-ids #f (list target run keynames )))
+
+(define (rmt:get-changed-record-ids since-time)
+  (rmt:send-receive 'get-changed-record-ids #f (list since-time)) )
+
+(define (rmt:get-all-runids)
+  (rmt:send-receive 'get-all-run-ids #f '()) )
+
+(define (rmt:get-changed-record-run-ids since-time)
+  (rmt:send-receive 'get-changed-record-run-ids #f (list since-time)))
+
+(define (rmt:get-changed-record-test-ids run-id since-time)
+  (rmt:send-receive 'get-changed-record-test-ids run-id (list since-time run-id)))
+
+
+
+(define (rmt:drop-all-triggers)
+     (rmt:send-receive 'drop-all-triggers #f '()))
+
+(define (rmt:create-all-triggers)
+     (rmt:send-receive 'create-all-triggers #f '()))
+
+;;======================================================================
+;;  T E S T   M E T A 
+;;======================================================================
+
+(define (rmt:get-tests-tags)
+  (rmt:send-receive 'get-tests-tags #f '()))
+
+;;======================================================================
+;;  K E Y S 
+;;======================================================================
+
+;; These require run-id because the values come from the run!
+;; however the query must still apply to main.db
+;;
+(define (rmt:get-key-val-pairs run-id)
+  (rmt:send-receive 'get-key-val-pairs #f (list run-id)))
+
+(define (rmt:get-keys)
+  (if *db-keys* *db-keys* 
+     (let ((res (rmt:send-receive 'get-keys #f '())))
+       (set! *db-keys* res)
+       res)))
+
+(define (rmt:get-keys-write) ;; dummy query to force server start
+  (let ((res (rmt:send-receive 'get-keys-write #f '())))
+    (set! *db-keys* res)
+    res))
+
+;; we don't reuse run-id's (except possibly *after* a db cleanup) so it is safe
+;; to cache the resuls in a hash
+;;
+(define (rmt:get-key-vals run-id)
+  (or (hash-table-ref/default *keyvals* run-id #f)
+      (let ((res (rmt:send-receive 'get-key-vals #f (list run-id))))
+        (hash-table-set! *keyvals* run-id res)
+        res)))
+
+(define (rmt:get-targets)
+  (rmt:send-receive 'get-targets #f '()))
+
+(define (rmt:get-target run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-target #f (list run-id)))
+
+(define (rmt:get-run-times runpatt targetpatt)
+  (rmt:send-receive 'get-run-times #f (list runpatt targetpatt ))) 
+
+
+;;======================================================================
+;;  T E S T S
+;;======================================================================
+
+;; IDEA: Threadify these - they spend a lot of time waiting ...
+;;
+(define (rmt:get-tests-for-runs-mindata run-ids testpatt states status not-in)
+  (let ((multi-run-mutex (make-mutex))
+	(run-id-list (if run-ids
+			 run-ids
+			 (rmt:get-all-run-ids)))
+	(result      '()))
+    (if (null? run-id-list)
+	'()
+	(let loop ((hed     (car run-id-list))
+		   (tal     (cdr run-id-list))
+		   (threads '()))
+	  (if (> (length threads) 5)
+	      (loop hed tal (filter (lambda (th)(not (member (thread-state th) '(terminated dead)))) threads))
+	      (let* ((newthread (make-thread
+				 (lambda ()
+				   (let ((res (rmt:send-receive 'get-tests-for-run-mindata hed (list hed testpatt states status not-in))))
+				     (if (list? res)
+					 (begin
+					   (mutex-lock! multi-run-mutex)
+					   (set! result (append result res))
+					   (mutex-unlock! multi-run-mutex))
+					 (debug:print-error 0 *default-log-port* "get-tests-for-run-mindata failed for run-id " hed ", testpatt " testpatt ", states " states ", status " status ", not-in " not-in))))
+				 (conc "multi-run-thread for run-id " hed)))
+		     (newthreads (cons newthread threads)))
+		(thread-start! newthread)
+		(thread-sleep! 0.05) ;; give that thread some time to start
+		(if (null? tal)
+		    newthreads
+		    (loop (car tal)(cdr tal) newthreads))))))
+    result))
+
+;; ;; IDEA: Threadify these - they spend a lot of time waiting ...
+;; ;;
+;; (define (rmt:get-tests-for-runs-mindata run-ids testpatt states status not-in)
+;;   (let ((run-id-list (if run-ids
+;; 			 run-ids
+;; 			 (rmt:get-all-run-ids))))
+;;     (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-id-list))))
+
+(define (rmt:delete-test-records run-id test-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'delete-test-records run-id (list run-id test-id)))
+
+(define (rmt:test-set-state-status run-id test-id state status msg)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'test-set-state-status run-id (list run-id test-id state status msg)))
+
+(define (rmt:test-toplevel-num-items run-id test-name)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'test-toplevel-num-items run-id (list run-id test-name)))
+
+;; (define (rmt:get-previous-test-run-record 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)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (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)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (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)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (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)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-testinfo-state-status run-id (list run-id test-id)))
+
+(define (rmt:test-set-log! run-id test-id logf)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (if (string? logf)(rmt:general-call 'test-set-log run-id logf test-id)))
+
+(define (rmt:test-set-top-process-pid run-id test-id pid)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'test-set-top-process-pid run-id (list run-id test-id pid)))
+
+(define (rmt:test-get-top-process-pid run-id test-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'test-get-top-process-pid run-id (list run-id test-id)))
+
+(define (rmt:get-run-ids-matching-target keynames target res runname testpatt statepatt statuspatt)
+  (rmt:send-receive 'get-run-ids-matching-target #f (list keynames target res runname testpatt statepatt statuspatt)))
+
+;; NOTE: This will open and access ALL run databases. 
+;;
+(define (rmt:test-get-paths-matching-keynames-target-new keynames target res testpatt statepatt statuspatt runname)
+  (let ((run-ids (rmt:get-run-ids-matching-target keynames target res runname testpatt statepatt statuspatt)))
+    (apply append 
+	   (map (lambda (run-id)
+		  (rmt:send-receive 'test-get-paths-matching-keynames-target-new run-id (list run-id keynames target res testpatt statepatt statuspatt runname)))
+	   run-ids))))
+
+
+
+(define (rmt:get-prereqs-not-met run-id waitons ref-test-name ref-item-path #!key (mode '(normal))(itemmaps #f))
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-prereqs-not-met run-id (list run-id waitons ref-test-name ref-item-path mode itemmaps)))
+
+(define (rmt:get-count-tests-running-for-run-id run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-count-tests-running-for-run-id run-id (list run-id)))
+
+(define (rmt:get-not-completed-cnt run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-not-completed-cnt run-id (list run-id)))
+
+
+;; Statistical queries
+
+(define (rmt:get-count-tests-running run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-count-tests-running run-id (list run-id)))
+
+(define (rmt:get-count-tests-running-for-testname run-id testname)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-count-tests-running-for-testname run-id (list run-id testname)))
+
+(define (rmt:get-count-tests-running-in-jobgroup run-id jobgroup)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-count-tests-running-in-jobgroup run-id (list run-id jobgroup)))
+
+(define (rmt:set-state-status-and-roll-up-run run-id state status)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'set-state-status-and-roll-up-run run-id (list run-id state status)))
+
+
+(define (rmt:update-pass-fail-counts run-id test-name)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:general-call 'update-pass-fail-counts run-id test-name test-name test-name))
+
+(define (rmt:top-test-set-per-pf-counts run-id test-name)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'top-test-set-per-pf-counts run-id (list run-id test-name)))
+
+(define (rmt:get-raw-run-stats run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-raw-run-stats run-id (list run-id)))
+
+(define (rmt:get-test-times runname target)
+  (rmt:send-receive 'get-test-times #f (list runname target ))) 
+
+;;======================================================================
+;;  R U N S
+;;======================================================================
+
+;; BUG - LOOK AT HOW THIS WORKS!!!
+;;
+(define (rmt:get-run-info run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-run-info #f (list run-id)))
+
+(define (rmt:get-num-runs runpatt)
+  (rmt:send-receive 'get-num-runs #f (list runpatt)))
+
+(define (rmt:get-runs-cnt-by-patt runpatt targetpatt keys)
+  (rmt:send-receive 'get-runs-cnt-by-patt #f (list runpatt  targetpatt keys)))
+
+;; Use the special run-id == #f scenario here since there is no run yet
+(define (rmt:register-run keyvals runname state status user contour)
+  (rmt:send-receive 'register-run #f (list keyvals runname state status user contour)))
+    
+(define (rmt:get-run-name-from-id run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-run-name-from-id #f (list run-id)))
+
+(define (rmt:delete-run run-id)
+  (rmt:send-receive 'delete-run #f (list run-id)))
+
+(define (rmt:update-run-stats run-id stats)
+  (rmt:send-receive 'update-run-stats #f (list run-id stats)))
+
+(define (rmt:delete-old-deleted-test-records run-id)
+  (rmt:send-receive 'delete-old-deleted-test-records run-id (list run-id)))
+
+(define (rmt:get-runs runpatt count offset keypatts)
+  (rmt:send-receive 'get-runs #f (list runpatt count offset keypatts)))
+
+(define (rmt:simple-get-runs runpatt count offset target last-update)
+  (rmt:send-receive 'simple-get-runs #f (list runpatt count offset target last-update)))
+
+(define (rmt:get-all-run-ids)
+  (rmt:send-receive 'get-all-run-ids #f '()))
+
+(define (rmt:get-prev-run-ids run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-prev-run-ids #f (list run-id)))
+
+(define (rmt:lock/unlock-run run-id lock unlock user)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'lock/unlock-run #f (list run-id lock unlock user)))
+
+;; set/get status
+(define (rmt:get-run-status run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-run-status #f (list run-id)))
+
+(define (rmt:get-run-state run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-run-state #f (list run-id)))
+
+(define (rmt:get-run-state-status run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-run-state-status #f (list run-id)))
+
+(define (rmt:set-run-status run-id run-status #!key (msg #f))
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'set-run-status #f (list run-id run-status msg)))
+
+(define (rmt:set-run-state-status run-id state status )
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'set-run-state-status #f (list run-id state status)))
+
+(define (rmt:update-tesdata-on-repilcate-db old-lt new-lt)
+(rmt:send-receive 'update-tesdata-on-repilcate-db #f (list old-lt new-lt)))
+
+(define (rmt:update-run-event_time run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'update-run-event_time #f (list run-id)))
+
+(define (rmt:get-runs-by-patt  keys runnamepatt targpatt offset limit fields last-runs-update  #!key  (sort-order "asc")) ;; fields of #f uses default
+  (rmt:send-receive 'get-runs-by-patt #f (list keys runnamepatt targpatt offset limit fields last-runs-update sort-order)))
+
+(define (rmt:find-and-mark-incomplete run-id ovr-deadtime)
+  (assert (number? run-id) "FATAL: Run id required.")
+  ;; (if (rmt:send-receive 'have-incompletes? run-id (list run-id ovr-deadtime))
+  (rmt:send-receive 'mark-incomplete run-id (list run-id ovr-deadtime))) ;; )
+
+(define (rmt:get-main-run-stats run-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-main-run-stats #f (list run-id)))
+
+(define (rmt:get-var varname)
+  (rmt:send-receive 'get-var #f (list varname)))
+
+(define (rmt:del-var varname)
+  (rmt:send-receive 'del-var #f (list varname)))
+
+(define (rmt:set-var varname value)
+  (rmt:send-receive 'set-var #f (list varname value)))
+
+(define (rmt:inc-var varname)
+  (rmt:send-receive 'inc-var #f (list varname)))
+
+(define (rmt:dec-var varname)
+  (rmt:send-receive 'dec-var #f (list varname)))
+
+(define (rmt:add-var varname value)
+  (rmt:send-receive 'add-var #f (list varname value)))
+
+;;======================================================================
+;; M U L T I R U N   Q U E R I E S
+;;======================================================================
+
+;; Need to move this to multi-run section and make associated changes
+(define (rmt:find-and-mark-incomplete-all-runs #!key (ovr-deadtime #f))
+  (let ((run-ids (rmt:get-all-run-ids)))
+    (for-each (lambda (run-id)
+	       (rmt:find-and-mark-incomplete run-id ovr-deadtime))
+	     run-ids)))
+
+;; get the previous record for when this test was run where all keys match but runname
+;; returns #f if no such test found, returns a single test record if found
+;; 
+;; Run this at the client end since we have to connect to multiple run-id dbs
+;;
+(define (rmt:get-previous-test-run-record run-id test-name item-path)
+  (let* ((keyvals (rmt:get-key-val-pairs run-id))
+	 (keys    (rmt:get-keys))
+	 (selstr  (string-intersperse  keys ","))
+	 (qrystr  (string-intersperse (map (lambda (x)(conc x "=?")) keys) " AND ")))
+    (if (not keyvals)
+	#f
+	(let ((prev-run-ids (rmt:get-prev-run-ids run-id)))
+	  ;; for each run starting with the most recent look to see if there is a matching test
+	  ;; if found then return that matching test record
+	  (debug:print 4 *default-log-port* "selstr: " selstr ", qrystr: " qrystr ", keyvals: " keyvals ", previous run ids found: " prev-run-ids)
+	  (if (null? prev-run-ids) #f
+	      (let loop ((hed (car prev-run-ids))
+			 (tal (cdr prev-run-ids)))
+		(let ((results (rmt:get-tests-for-run hed (conc test-name "/" item-path) '() '() ;; run-id testpatt states statuses
+						      #f #f #f               ;; offset limit not-in hide/not-hide
+						      #f #f #f #f 'normal))) ;; sort-by sort-order qryvals last-update mode
+		  (debug:print 4 *default-log-port* "Got tests for run-id " run-id ", test-name " test-name ", item-path " item-path ": " results)
+		  (if (and (null? results)
+			   (not (null? tal)))
+		      (loop (car tal)(cdr tal))
+		      (if (null? results) #f
+			  (car results))))))))))
+
+(define (rmt:get-run-stats)
+  (rmt:send-receive 'get-run-stats #f '()))
+
+;;======================================================================
+;;  S T E P S
+;;======================================================================
+
+;; Getting steps is more complicated.
+;;
+;; If given work area 
+;;  1. Find the testdat.db file
+;;  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 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)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (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 *default-log-port* "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! run-id (list run-id test-id teststep-name state-in status-in comment logfile))))
+
+
+(define (rmt:delete-steps-for-test! run-id test-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'delete-steps-for-test! run-id (list run-id test-id)))
+
+(define (rmt:get-steps-for-test run-id test-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-steps-for-test run-id (list run-id test-id)))
+
+(define (rmt:get-steps-info-by-id run-id test-step-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'get-steps-info-by-id #f (list run-id test-step-id)))
+
+;;======================================================================
+;;  T E S T   D A T A 
+;;======================================================================
+
+(define (rmt:read-test-data run-id test-id categorypatt #!key (work-area #f)) 
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'read-test-data run-id (list run-id test-id categorypatt)))
+
+(define (rmt:read-test-data-varpatt run-id test-id categorypatt varpatt #!key (work-area #f)) 
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'read-test-data-varpatt run-id (list run-id test-id categorypatt varpatt)))
+
+(define (rmt:get-data-info-by-id run-id test-data-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+   (rmt:send-receive 'get-data-info-by-id #f (list run-id test-data-id)))
+
+(define (rmt:testmeta-add-record testname)
+  (rmt:send-receive 'testmeta-add-record #f (list testname)))
+
+(define (rmt:testmeta-get-record testname)
+  (rmt:send-receive 'testmeta-get-record #f (list testname)))
+
+(define (rmt:testmeta-update-field test-name fld val)
+  (rmt:send-receive 'testmeta-update-field #f (list test-name fld val)))
+
+(define (rmt:test-data-rollup run-id test-id status)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'test-data-rollup run-id (list run-id test-id status)))
+
+(define (rmt:csv->test-data run-id test-id csvdata)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'csv->test-data run-id (list run-id test-id csvdata)))
+
+;;======================================================================
+;;  T A S K S
+;;======================================================================
+
+(define (rmt:tasks-find-task-queue-records target run-name test-patt state-patt action-patt)
+  (rmt:send-receive 'find-task-queue-records #f (list target run-name test-patt state-patt action-patt)))
+
+(define (rmt:tasks-add action owner target runname testpatt params)
+  (rmt:send-receive 'tasks-add #f (list action owner target runname testpatt params)))
+
+(define (rmt:tasks-set-state-given-param-key param-key new-state)
+  (rmt:send-receive 'tasks-set-state-given-param-key #f (list  param-key new-state)))
+
+(define (rmt:tasks-get-last target runname)
+  (rmt:send-receive 'tasks-get-last #f (list target runname)))
+
+;;======================================================================
+;; N O   S Y N C   D B 
+;;======================================================================
+
+(define (rmt:no-sync-set var val)
+  (rmt:send-receive 'no-sync-set #f `(,var ,val)))
+
+(define (rmt:no-sync-get/default var default)
+  (rmt:send-receive 'no-sync-get/default #f `(,var ,default)))
+
+(define (rmt:no-sync-del! var)
+  (rmt:send-receive 'no-sync-del! #f `(,var)))
+
+(define (rmt:no-sync-get-lock keyname)
+  (rmt:send-receive 'no-sync-get-lock #f `(,keyname)))
+
+;; process registration
+
+(define (rmt:register-process host port pid starttime status purpose dbname mtversion)
+  (rmt:send-receive 'register-process #f (list host port pid starttime status purpose dbname mtversion)))
+
+(define (rmt:set-process-done host pid reason)
+  (rmt:send-receive 'set-process-done #f (list host pid reason)))
+
+(define (rmt:set-process-status host pid newstatus)
+  (rmt:send-receive 'set-process-status #f (list host pid newstatus)))
+
+(define (rmt:get-process-options purpose dbname)
+  (rmt:get-process-options 'get-process-options #f (list purpose dbname)))
+
+;;======================================================================
+;; A R C H I V E S
+;;======================================================================
+
+(define (rmt:archive-get-allocations  testname itempath dneeded)
+  (rmt:send-receive 'archive-get-allocations #f (list testname itempath dneeded)))
+
+(define (rmt:archive-register-block-name bdisk-id archive-path)
+  (rmt:send-receive 'archive-register-block-name #f (list bdisk-id archive-path)))
+
+(define (rmt:archive-allocate-testsuite/area-to-block block-id testsuite-name areakey)
+  (rmt:send-receive 'archive-allocate-test-to-block #f (list  block-id testsuite-name areakey)))
+
+(define (rmt:archive-register-disk bdisk-name bdisk-path df)
+  (rmt:send-receive 'archive-register-disk #f (list bdisk-name bdisk-path df)))
+
+(define (rmt:test-set-archive-block-id run-id test-id archive-block-id)
+  (assert (number? run-id) "FATAL: Run id required.")
+  (rmt:send-receive 'test-set-archive-block-id run-id (list run-id test-id archive-block-id)))
+
+(define (rmt:test-get-archive-block-info archive-block-id)
+  (rmt:send-receive 'test-get-archive-block-info #f (list archive-block-id)))
+
+(define (rmtmod:calc-ro-mode runremote *toppath*)
+  (case (rmt:transport-mode)
+    ((http)
+     (if (and runremote
+	      (remote-ro-mode-checked runremote))
+	 (remote-ro-mode runremote)
+	 (let* ((mtcfgfile  (conc *toppath* "/megatest.config"))
+		(ro-mode (not (file-write-access? mtcfgfile)))) ;; TODO: use dbstruct or runremote to figure this out in future
+	   (if runremote
+	       (begin
+		 (remote-ro-mode-set! runremote ro-mode)
+		 (remote-ro-mode-checked-set! runremote #t)
+		 ro-mode)
+	       ro-mode))))
+    ((tcp)
+     (if (and runremote
+	      (tt-ro-mode-checked runremote))
+	 (tt-ro-mode runremote)
+	 (let* ((mtcfgfile  (conc *toppath* "/megatest.config"))
+		(ro-mode (not (file-write-access? mtcfgfile)))) ;; TODO: use dbstruct or runremote to figure this out in future
+	   (if runremote
+	       (begin
+		 (tt-ro-mode-set! runremote ro-mode)
+		 (tt-ro-mode-checked-set! runremote #t)
+		 ro-mode)
+	       ro-mode))))))
+
+
+;;======================================================================
+;; Maintenance
+;;======================================================================
+
+(define (rmt:find-and-mark-incomplete run-id ovr-deadtime)
+  (let* ((cfg-deadtime             (configf:lookup-number *configdat* "setup" "deadtime"))
+	 (test-stats-update-period (configf:lookup-number *configdat* "setup" "test-stats-update-period")))
+   (rmt:find-and-mark-incomplete-engine run-id ovr-deadtime cfg-deadtime test-stats-update-period)
+   ;;call end of eud of run detection for posthook
+   (launch:end-of-run-check run-id)))
+
+;;======================================================================
+;;  S U P P O R T   F U N C T I O N S
+;;======================================================================
+
+(define (rmt:on-homehost? runremote)
+  (let* ((hh-dat (remote-hh-dat runremote)))
+    (if (pair? hh-dat)
+	(cdr hh-dat)
+	(begin
+	  (debug:print-info 0 *default-log-port* "hh-dat="hh-dat)
+	  #f))))
+
+(define (make-and-init-remote areapath)
+   (case (rmt:transport-mode)
+     ((http)(make-remote))
+     ((tcp) (tt:make-remote areapath))
+     (else #f)))
+
+;; how to make area-dat
+(define (rmt:set-ttdat areapath ttdat)
+  (if ttdat
+    ttdat
+    (if *ttdat*
+       *ttdat*
+       (begin
+         (debug:print-info 2 *default-log-port* "rmt:set-ttdat: Initialize new ttdat")
+         (let* ((newremote  (make-and-init-remote areapath)))
+           (set! *ttdat* newremote)
+	   newremote
+         )
+       )
+     )
+   )
+)
 
 )