Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -44,18 +44,28 @@
 (define (db:get-db dbstruct run-id)
   (if (sqlite3:database? dbstruct) ;; pass sqlite3 databases on through
       dbstruct
       (begin
 	(mutex-lock! *rundb-mutex*)
-	(let ((db (if (or (not run-id)
-			  (eq? run-id 0))
-		      (db:open-main dbstruct)
-		      (db:open-rundb dbstruct run-id)
-		      )))
+	(let ((dbdat (if (or (not run-id)
+			     (eq? run-id 0))
+			 (db:open-main dbstruct)
+			 (db:open-rundb dbstruct run-id)
+			 )))
 	  ;; db prunning would go here
 	  (mutex-unlock! *rundb-mutex*)
-	  db))))
+	  dbdat))))
+
+(define (db:dbdat-get-db dbdat)
+  (if (pair? dbdat)
+      (car dbdat)
+      dbdat))
+
+(define (db:dbdat-get-path dbdat)
+  (if (pair? dbdat)
+      (cdr dbdat)
+      #f))
 
 ;; mod-read:
 ;;     'mod   modified data
 ;;     'read  read data
 ;;
@@ -71,22 +81,16 @@
 
 ;; (db:with-db dbstruct run-id sqlite3:exec "select blah from blaz;")
 ;; r/w is a flag to indicate if the db is modified by this query #t = yes, #f = no
 ;;
 (define (db:with-db dbstruct run-id r/w proc . params)
-  (let* ((db    (db:get-db dbstruct run-id))
-	 )
-    ;; (proc2 (lambda ()
+  (let* ((dbdat (db:get-db dbstruct run-id))
+	 (db    (db:dbdat-get-db dbdat)))
+    (db:delay-if-busy dbdat)
     (let ((res (apply proc db params)))
       (db:done-with dbstruct run-id r/w)
       res)))
-;;     (handle-exceptions
-;;      exn
-;;      (begin
-;;        (thread-sleep! 10)
-;;        (proc2))
-;;      (proc2))))
 
 ;;======================================================================
 ;; K E E P   F I L E D B   I N   dbstruct
 ;;======================================================================
 
@@ -181,11 +185,11 @@
 	       (write-access (file-write-access? dbpath))
 	       ;; (handler      (make-busy-timeout 136000))
 	       )
 	  (if (and dbexists (not write-access))
 	      (set! *db-write-access* #f)) ;; only unset so other db's also can use this control
-	  (dbr:dbstruct-set-rundb!  dbstruct db)
+	  (dbr:dbstruct-set-rundb!  dbstruct (cons db dbpath))
 	  (dbr:dbstruct-set-inuse!  dbstruct #t)
 	  (dbr:dbstruct-set-olddb!  dbstruct olddb)
 	  ;; (dbr:dbstruct-set-run-id! dbstruct run-id)
 	  (if local
 	      (begin
@@ -192,10 +196,11 @@
 		(dbr:dbstruct-set-localdb! dbstruct run-id db) ;; (dbr:dbstruct-set-inmem! dbstruct db) ;; direct access ...
 		db)
 	      (begin
 		(dbr:dbstruct-set-inmem!  dbstruct inmem)
 		(db:sync-tables db:sync-tests-only db inmem)
+		(db:delay-if-busy dbpath: (db:dbdat-get-path refdb))
 		(dbr:dbstruct-set-refdb!  dbstruct refdb)
 		(db:sync-tables db:sync-tests-only db refdb)
 		inmem))))))
 
 ;; This routine creates the db. It is only called if the db is not already ls opened
@@ -206,16 +211,17 @@
 	mdb
 	(let* ((dbpath       (db:dbfile-path 0))
 	       (dbexists     (file-exists? dbpath))
 	       (db           (db:lock-create-open dbpath db:initialize-main-db))
 	       (olddb        (db:open-megatest-db))
-	       (write-access (file-write-access? dbpath)))
+	       (write-access (file-write-access? dbpath))
+	       (dbdat        (cons db dbpath)))
 	  (if (and dbexists (not write-access))
 	      (set! *db-write-access* #f))
-	  (dbr:dbstruct-set-main!   dbstruct db)
-	  (dbr:dbstruct-set-olddb!  dbstruct olddb)
-	  db))))
+	  (dbr:dbstruct-set-main!   dbstruct dbdat)
+	  (dbr:dbstruct-set-olddb!  dbstruct olddb) ;; olddb is already a (cons db path)
+	  dbdat))))
 
 ;; Make the dbstruct, setup up auxillary db's and call for main db at least once
 ;;
 (define (db:setup run-id #!key (local #f))
   (let* ((dbdir    (conc (configf:lookup *configdat* "setup" "linktree") "/.db"))
@@ -232,11 +238,11 @@
 					      (db:initialize-main-db db)
 					      (db:initialize-run-id-db db))))
 	 (write-access (file-write-access? dbpath)))
     (if (and dbexists (not write-access))
 	(set! *db-write-access* #f))
-    db))
+    (cons db path)))
 
 ;; sync run to disk if touched
 ;;
 (define (db:sync-touched dbstruct run-id #!key (force-sync #f))
   (let ((mtime  (dbr:dbstruct-get-mtime dbstruct))
@@ -255,11 +261,12 @@
 	    (if (or (not (number? mtime))
 		    (not (number? stime))
 		    (> mtime stime)
 		    force-sync)
 		(begin
-		  (db:delay-if-busy)
+		  (db:delay-if-busy maindb)
+		  (db:delay-if-busy olddb)
 		  (let ((num-synced (db:sync-tables (db:sync-main-list maindb) maindb olddb)))
 		    (dbr:dbstruct-set-stime! dbstruct (current-milliseconds))
 		    num-synced)
 		  0))
 	    (begin
@@ -272,11 +279,12 @@
 	(if (or (not (number? mtime))
 		(not (number? stime))
 		(> mtime stime)
 		force-sync)
 	    (begin
-	      (db:delay-if-busy)
+	      (db:delay-if-busy rundb)
+	      (db:delay-if-busy olddb)
 	      (let ((num-synced (db:sync-tables db:sync-tests-only inmem refdb rundb olddb)))
 		(dbr:dbstruct-set-stime! dbstruct (current-milliseconds))
 		num-synced)
 	      0)))))
 
@@ -284,20 +292,22 @@
 (define (db:close-all dbstruct)
   ;; finalize main.db
   (db:sync-touched dbstruct 0 force-sync: #t)
   ;;(common:db-block-further-queries)
   ;; (mutex-lock! *db-sync-mutex*) ;; with this perhaps it isn't necessary to use the block-further-queries mechanism?
-  (sqlite3:finalize! (db:get-db dbstruct #f))
+  (sqlite3:finalize! (db:dbdat-get-db (db:get-db dbstruct #f)))
   (let* ((local (dbr:dbstruct-get-local dbstruct))
-	 (rundb (dbr:dbstruct-get-rundb dbstruct)))
+	 (rundb (db:dbdat-get-db (dbr:dbstruct-get-rundb dbstruct))))
     (if local
 	(for-each
-	 (lambda (db)
-	   (if (sqlite3:database? db)
-	       (begin
-		 (sqlite3:interrupt! db)
-		 (sqlite3:finalize! db #t))))
+	 (lambda (dbdat)
+	   (let ((db (db:dbdat-get-db dbdat)))
+	     (if (sqlite3:database? db)
+		 (begin
+		   (sqlite3:interrupt! db)
+		   (sqlite3:finalize! db #t)))))
+	 ;; TODO: Come back to this and rework to delete from hashtable when finalized
 	 (hash-table-values (dbr:dbstruct-get-locdbs dbstruct))))
     (thread-sleep! 3)
     (if (and rundb
 	     (sqlite3:database? rundb))
 	(handle-exceptions
@@ -316,11 +326,11 @@
 (define (db:open-inmem-db)
   (let* ((db      (sqlite3:open-database ":memory:"))
 	 (handler (make-busy-timeout 3600)))
     (sqlite3:set-busy-handler! db handler)
     (db:initialize-run-id-db db)
-    db))
+    (cons db #f)))
 
 ;; just tests, test_steps and test_data tables
 (define db:sync-tests-only
   (list
    ;; (list "strs"
@@ -409,13 +419,13 @@
      (debug:print 0 " status:  " ((condition-property-accessor 'sqlite3 'status) exn))
      (print-call-chain))
    (cond
     ((not fromdb) (debug:print 3 "WARNING: db:sync-tables called with fromdb missing") -1)
     ((not todb)   (debug:print 3 "WARNING: db:sync-tables called with todb missing") -2)
-    ((not (sqlite3:database? fromdb))
+    ((not (sqlite3:database? (db:dbdat-get-db fromdb)))
      (debug:print 0 "ERROR: db:sync-tables called with fromdb not a database " fromdb) -3)
-    ((not (sqlite3:database? todb))
+    ((not (sqlite3:database? (db:dbdat-get-db todb)))
      (debug:print 0 "ERROR: db:sync-tables called with todb not a database " todb) -4)
     (else
      (let ((stmts       (make-hash-table)) ;; table-field => stmt
 	   (all-stmts   '())              ;; ( ( stmt1 value1 ) ( stml2 value2 ))
 	   (numrecs     (make-hash-table))
@@ -460,11 +470,13 @@
 	     full-sel)
 
 	    ;; first pass implementation, just insert all changed rows
 	    (for-each 
 	     (lambda (targdb)
-	       (let ((stmth (sqlite3:prepare targdb full-ins)))
+	       (let ((stmth  (sqlite3:prepare targdb full-ins))
+		     (db     (db:dbdat-get-db targdb)))
+		 (db:delay-if-busy targdb)
 		 (sqlite3:with-transaction
 		  targdb
 		  (lambda ()
 		    (for-each ;; 
 		     (lambda (fromrow)
@@ -516,11 +528,11 @@
 	 (dbstruct (if toppath (make-dbr:dbstruct path: toppath) #f))
 	 (mtdb     (if toppath (db:open-megatest-db)))
 	 (run-ids  (if run-ids 
 		       run-ids
 		       (if toppath (begin
-				     (db:delay-if-busy)
+				     (db:delay-if-busy mtdb)
 				     (db:get-all-run-ids mtdb)))))
 	 (mdb     (tasks:open-db))
 	 (servers (tasks:get-all-servers mdb)))
     
     ;; kill servers
@@ -533,28 +545,28 @@
 
     ;; clear out junk records
     ;;
     (if (member 'dejunk options)
 	(begin
-	  (db:delay-if-busy)
+	  (db:delay-if-busy mtdb)
 	  (db:clean-up mtdb)))
 
     ;; adjust test-ids to fit into proper range
     ;;
     (if (member 'adj-testids options)
 	(begin
-	  (db:delay-if-busy)
+	  (db:delay-if-busy mtdb)
 	  (db:prep-megatest.db-for-migration mtdb)))
 
     ;; sync runs, test_meta etc.
     ;;
     (if (member 'old2new options)
 	(begin
 	  (db:sync-tables (db:sync-main-list mtdb) mtdb (db:get-db dbstruct #f))
 	  (for-each 
 	   (lambda (run-id)
-	     (db:delay-if-busy)
+	     (db:delay-if-busy mtdb)
 	     (let ((testrecs (db:get-all-tests-info-by-run-id mtdb run-id))
 		   (dbstruct (if toppath (make-dbr:dbstruct path: toppath local: #t) #f)))
 	       (debug:print 0 "INFO: Propagating " (length testrecs) " records for run-id=" run-id " to run specific db")
 	       (db:replace-test-records dbstruct run-id testrecs)
 	       (sqlite3:finalize! (dbr:dbstruct-get-rundb dbstruct))))
@@ -562,12 +574,14 @@
 
     ;; now ensure all newdb data are synced to megatest.db
     (if (member 'new2old options)
 	(for-each
 	 (lambda (run-id)
-	   (db:delay-if-busy)
-	   (let ((fromdb (if toppath (make-dbr:dbstruct path: toppath local: #t) #f)))
+	   (let ((fromdb (if toppath (make-dbr:dbstruct path: toppath local: #t) #f))
+		 (frundb (db:dbdat-get-db (db:get-db fromdb run-id))))
+	     (db:delay-if-busy frundb)
+	     (db:delay-if-busy mtdb)
 	     (if (eq? run-id 0)
 		 (db:sync-tables (db:sync-main-list dbstruct)(db:get-db fromdb run-id) mtdb)
 		 (db:sync-tables db:sync-tests-only (db:get-db fromdb run-id) mtdb))))
 	 run-ids))
     
@@ -578,10 +592,11 @@
 (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)
   (if (or *db-write-access*
 	  (not (member proc *db:all-write-procs*)))
       (let* ((db (cond
+		  ((pair? idb)                 (db:dbdat-get-db idb))
 		  ((sqlite3:database? idb)     idb)
 		  ((not idb)                   (debug:print 0 "ERROR: cannot open-run-close with #f anymore"))
 		  ((procedure? idb)            (idb))
 		  (else   	               (debug:print 0 "ERROR: cannot open-run-close with #f anymore"))))
 	     (res #f))
@@ -614,16 +629,17 @@
 (define open-run-close open-run-close-exception-handling)
 		;;	   open-run-close-no-exception-handling
 ;;			   open-run-close-exception-handling)
 ;;)
 
-(define (db:initialize-main-db db)
+(define (db:initialize-main-db dbdat)
   (let* ((configdat (car *configinfo*))  ;; tut tut, global warning...
 	 (keys     (keys:config-get-fields configdat))
 	 (havekeys (> (length keys) 0))
 	 (keystr   (keys->keystr keys))
-	 (fieldstr (keys->key/field keys)))
+	 (fieldstr (keys->key/field keys))
+	 (db       (db:dbdat-get-db dbdat)))
     (for-each (lambda (key)
 		(let ((keyn key))
 		  (if (member (string-downcase keyn)
 			      (list "runname" "state" "status" "owner" "event_time" "comment" "fail_count"
 				    "pass_count"))
@@ -793,11 +809,12 @@
 ;;      (select testname,item_path,event_time+run_duration as
 ;;                          end_time,strftime('%s','now') as now from tests where state in
 ;;      ('RUNNING','REMOTEHOSTSTART','LAUNCED'));
 
 (define (db:find-and-mark-incomplete dbstruct run-id ovr-deadtime)
-  (let* ((db          (db:get-db dbstruct run-id))
+  (let* ((dbdat        (db:get-db dbstruct run-id))
+	 (db           (db:dbdat-get-db dbdat))
 	 (incompleted '())
 	 (oldlaunched '())
 	 (toplevels   '())
 	 (deadtime-str (configf:lookup *configdat* "setup" "deadtime"))
 	 (deadtime     (if (and deadtime-str
@@ -810,11 +827,11 @@
     ;;
     ;; HOWEVER: this code in run:test seems to work fine
     ;;              (> (- (current-seconds)(+ (db:test-get-event_time testdat)
     ;;                     (db:test-get-run_duration testdat)))
     ;;                    600) 
-    ;; (db:delay-if-busy)
+    (db:delay-if-busy dbdat)
     (sqlite3:for-each-row 
      (lambda (test-id run-dir uname testname item-path)
        (if (and (equal? uname "n/a")
 		(equal? item-path "")) ;; this is a toplevel test
 	   ;; what to do with toplevel? call rollup?
@@ -826,11 +843,11 @@
      "SELECT id,rundir,uname,testname,item_path FROM tests WHERE run_id=? AND (strftime('%s','now') - event_time) > (run_duration + ?) AND state IN ('RUNNING','REMOTEHOSTSTART');"
      run-id deadtime)
 
     ;; in LAUNCHED for more than one day. Could be long due to job queues TODO/BUG: Need override for this in config
     ;;
-    ;; (db:delay-if-busy)
+    (db:delay-if-busy dbdat)
     (sqlite3:for-each-row
      (lambda (test-id run-dir uname testname item-path)
        (if (and (equal? uname "n/a")
 		(equal? item-path "")) ;; this is a toplevel test
 	   ;; what to do with toplevel? call rollup?
@@ -842,11 +859,11 @@
     
     (debug:print-info 18 "Found " (length oldlaunched) " old LAUNCHED items, " (length toplevels) " old LAUNCHED toplevel tests and " (length incompleted) " tests marked RUNNING but apparently dead.")
 
     ;; These are defunct tests, do not do all the overhead of set-state-status. Force them to INCOMPLETE.
     ;;
-    ;; (db:delay-if-busy)
+    (db:delay-if-busy dbdat)
     (let* (;; (min-incompleted (filter (lambda (x)
 	   ;;      		      (let* ((testpath (cadr x))
 	   ;;      			     (tdatpath (conc testpath "/testdat.db"))
 	   ;;      			     (dbexists (file-exists? tdatpath)))
 	   ;;      			(or (not dbexists) ;; if no file then something wrong - mark as incomplete
@@ -863,10 +880,11 @@
 		   (string-intersperse (map conc all-ids) ",")
 		   ");")))))
 
     ;; Now do rollups for the toplevel tests
     ;;
+    (db:delay-if-busy dbdat)
     (for-each
      (lambda (toptest)
        (let ((test-name (list-ref toptest 3)))
 ;;	     (run-id    (list-ref toptest 5)))
 	  (db:general-call db 'top-test-set-per-pf-counts (list test-name run-id test-name test-name test-name)))) ;; (list run-id test-name))))
@@ -881,13 +899,13 @@
 ;;    b. If test dir gone, delete the test record
 ;; 2. Look at run records
 ;;    a. If have tests that are not deleted, set state='unknown'
 ;;    b. ....
 ;;
-(define (db:clean-up db)
+(define (db:clean-up dbdat)
   (debug:print 0 "WARNING: db clean up not fully ported to v1.60, cleanup action will be on megatest.db")
-  (let* (;; (db         (db:get-db dbstruct #f))
+  (let* ((db         (db:dbdat-get-db dbdat))
 	 (count-stmt (sqlite3:prepare db "SELECT (SELECT count(id) FROM tests)+(SELECT count(id) FROM runs);"))
 	(statements
 	 (map (lambda (stmt)
 		(sqlite3:prepare db stmt))
 	      (list
@@ -900,10 +918,11 @@
 	       ;; delete all runs that are state='deleted'
 	       "DELETE FROM runs WHERE state='deleted';"
 	       ;; delete empty runs
 	       "DELETE FROM runs WHERE id NOT IN (SELECT DISTINCT r.id FROM runs AS r INNER JOIN tests AS t ON t.run_id=r.id);"
 	       ))))
+    (db:delay-if-busy dbdat)
     (sqlite3:with-transaction 
      db
      (lambda ()
        (sqlite3:for-each-row (lambda (tot)
 			       (debug:print-info 0 "Records count before clean: " tot))
@@ -913,10 +932,11 @@
 			       (debug:print-info 0 "Records count after  clean: " tot))
 			     count-stmt)))
     (map sqlite3:finalize! statements)
     (sqlite3:finalize! count-stmt)
     ;; (db:find-and-mark-incomplete db)
+    (db:delay-if-busy dbdat)
     (sqlite3:execute db "VACUUM;")))
 
 ;;======================================================================
 ;; M E T A   G E T   A N D   S E T   V A R S
 ;;======================================================================
@@ -928,15 +948,18 @@
 ;;
 (define (db:get-var dbstruct var)
   (let* ((start-ms (current-milliseconds))
          (throttle (let ((t  (config-lookup *configdat* "setup" "throttle")))
 		     (if t (string->number t) t)))
-	 (res      #f))
+	 (res      #f)
+	 (dbdat    (db:get-db dbstruct #f))
+	 (db       (db:dbdat-get-db dbdat)))
+    (db:delay-if-busy dbdat)
     (sqlite3:for-each-row
      (lambda (val)
        (set! res val))
-     (db:get-db dbstruct #f)
+     db
      "SELECT val FROM metadat WHERE var=?;" var)
     ;; convert to number if can
     (if (string? res)
 	(let ((valnum (string->number res)))
 	  (if valnum (set! res valnum))))
@@ -949,16 +972,20 @@
 	  (debug:print-info 4 "launch throttle factor=" *global-delta*)
 	  (set! *last-global-delta-printed* *global-delta*)))
     res))
 
 (define (db:set-var dbstruct var val)
-  ;; (db:delay-if-busy)
-  (sqlite3:execute (db:get-db dbstruct #f) "INSERT OR REPLACE INTO metadat (var,val) VALUES (?,?);" var val))
+  (let ((dbdat (db:get-db dbstruct #f))
+	(db    (db:dbdat-get-db dbdat)))
+    (db:delay-if-busy dbdat)
+    (sqlite3:execute db "INSERT OR REPLACE INTO metadat (var,val) VALUES (?,?);" var val)))
 
 (define (db:del-var dbstruct var)
   ;; (db:delay-if-busy)
-  (sqlite3:execute (db:get-db dbstruct #f) "DELETE FROM metadat WHERE var=?;" var))
+  (db:with-db dbstruct #f #t 
+	      (lambda (db)
+		(sqlite3:execute db "DELETE FROM metadat WHERE var=?;" var))))
 
 ;; use a global for some primitive caching, it is just silly to
 ;; re-read the db over and over again for the keys since they never
 ;; change
 
@@ -996,28 +1023,38 @@
 ;;======================================================================
 ;;  R U N S
 ;;======================================================================
 
 (define (db:get-run-name-from-id dbstruct run-id)
-  (let ((res #f))
-    (sqlite3:for-each-row
-     (lambda (runname)
-       (set! res runname))
-     (db:get-db dbstruct #f)
-     "SELECT runname FROM runs WHERE id=?;"
-     run-id)
-    res))
+  (db:with-db 
+   dbstruct
+   #f ;; this is for the main runs db
+   #f ;; does not modify db
+   (lambda (db)
+     (let ((res #f))
+       (sqlite3:for-each-row
+	(lambda (runname)
+	  (set! res runname))
+	db
+	"SELECT runname FROM runs WHERE id=?;"
+	run-id)
+       res))))
 
 (define (db:get-run-key-val dbstruct run-id key)
-  (let ((res #f))
-    (sqlite3:for-each-row
-     (lambda (val)
-       (set! res val))
-     (db:get-db dbstruct #f) 
-     (conc "SELECT " key " FROM runs WHERE id=?;")
-     run-id)
-    res))
+  (db:with-db
+   dbstruct
+   #f
+   #f
+   (lambda (db)
+     (let ((res #f))
+       (sqlite3:for-each-row
+	(lambda (val)
+	  (set! res val))
+	db
+	(conc "SELECT " key " FROM runs WHERE id=?;")
+	run-id)
+       res))))
 
 ;; keys list to key1,key2,key3 ...
 (define (runs:get-std-run-fields keys remfields)
   (let* ((header    (append keys remfields))
 	 (keystr    (conc (keys->keystr keys) ","
@@ -1040,11 +1077,12 @@
 
 ;; register a test run with the db, this accesses the main.db and does NOT
 ;; use server api
 ;;
 (define (db:register-run dbstruct keyvals runname state status user)
-  (let* ((db        (db:get-db dbstruct #f))
+  (let* ((dbdat     (db:get-db dbstruct #f))
+	 (db        (db:dbdat-get-db dbdat))
 	 (keys      (map car keyvals))
 	 (keystr    (keys->keystr keys))	 
 	 (comma     (if (> (length keys) 0) "," ""))
 	 (andstr    (if (> (length keys) 0) " AND " ""))
 	 (valslots  (keys->valslots keys)) ;; ?,?,? ...
@@ -1053,22 +1091,23 @@
 	 (key=?str  (string-intersperse (map (lambda (k)(conc k "=?")) keys) " AND ")))
     (debug:print 3 "keys: " keys " allvals: " allvals " keyvals: " keyvals " key=?str is " key=?str)
     (debug:print 2 "NOTE: using target " (string-intersperse (map cadr keyvals) "/") " for this run")
     (if (and runname (null? (filter (lambda (x)(not x)) keyvals))) ;; there must be a better way to "apply and"
 	(let ((res #f))
-	  ;; (db:delay-if-busy)
+	  (db:delay-if-busy dbdat)
 	  (apply sqlite3:execute db (conc "INSERT OR IGNORE INTO runs (runname,state,status,owner,event_time" comma keystr ") VALUES (?,?,?,?,strftime('%s','now')" comma valslots ");")
 		 allvals)
+	  (db:delay-if-busy dbdat)
 	  (apply sqlite3:for-each-row 
 		 (lambda (id)
 		   (set! res id))
 		 db
 		 (let ((qry (conc "SELECT id FROM runs WHERE (runname=? " andstr key=?str ");")))
 					;(debug:print 4 "qry: " qry) 
 		   qry)
 		 qryvals)
-	  ;; (db:delay-if-busy)
+	  (db:delay-if-busy dbdat)
 	  (sqlite3:execute db "UPDATE runs SET state=?,status=?,event_time=strftime('%s','now') WHERE id=? AND state='deleted';" state status res)
 	  res) 
 	(begin
 	  (debug:print 0 "ERROR: Called without all necessary keys")
 	  #f))))
@@ -1162,78 +1201,97 @@
     (vector header res)))
 
 ;; Get all targets from the db
 ;;
 (define (db:get-targets dbstruct)
-  (let* ((res       '())
+  (let* ((dbdat      (db:get-db dbstruct))
+	 (db         (db:dbdat-get-db dbdat))
+	 (res       '())
 	 (keys       (db:get-keys dbstruct))
 	 (header     keys) ;; (map key:get-fieldname keys))
 	 (keystr     (keys->keystr keys))
 	 (qrystr     (conc "SELECT " keystr " FROM runs WHERE state != 'deleted';"))
 	 (seen       (make-hash-table)))
+    (db:delay-if-busy dbdat)
     (sqlite3:for-each-row
      (lambda (a . x)
        (let ((targ (cons a x)))
 	 (if (not (hash-table-ref/default seen targ #f))
 	     (begin
 	       (hash-table-set! seen targ #t)
 	       (set! res (cons (apply vector targ) res))))))
-     (db:get-db dbstruct #f)
+     db
      qrystr)
     (debug:print-info 11 "db:get-targets END qrystr: " qrystr )
     (vector header res)))
 
 ;; just get count of runs
 (define (db:get-num-runs dbstruct runpatt)
-  (let ((numruns 0))
-    (debug:print-info 11 "db:get-num-runs START " runpatt)
-    (sqlite3:for-each-row 
-     (lambda (count)
-       (set! numruns count))
-     (db:get-db dbstruct #f)
-     "SELECT COUNT(id) FROM runs WHERE runname LIKE ? AND state != 'deleted';" runpatt)
-    (debug:print-info 11 "db:get-num-runs END " runpatt)
-    numruns))
+  (db:with-db
+   dbstruct
+   #f
+   #f
+   (lambda (db)
+     (let ((numruns 0))
+       (debug:print-info 11 "db:get-num-runs START " runpatt)
+       (sqlite3:for-each-row 
+	(lambda (count)
+	  (set! numruns count))
+	db
+	"SELECT COUNT(id) FROM runs WHERE runname LIKE ? AND state != 'deleted';" runpatt)
+       (debug:print-info 11 "db:get-num-runs END " runpatt)
+       numruns))))
 
 (define (db:get-all-run-ids dbstruct)
-  (let ((run-ids '()))
-    (sqlite3:for-each-row
-     (lambda (run-id)
-       (set! run-ids (cons run-id run-ids)))
-     (db:get-db dbstruct #f)
-     "SELECT id FROM runs WHERE state != 'deleted' ORDER BY event_time DESC;")
-    (reverse run-ids)))
+  (db:with-db
+   dbstruct
+   #f
+   #f
+   (lambda (db)
+     (let ((run-ids '()))
+       (sqlite3:for-each-row
+	(lambda (run-id)
+	  (set! run-ids (cons run-id run-ids)))
+	db
+	"SELECT id FROM runs WHERE state != 'deleted' ORDER BY event_time DESC;")
+    (reverse run-ids)))))
 
 ;; get some basic run stats
 ;;
 ;; ( (runname (( state  count ) ... ))
 ;;   (   ...  
 (define (db:get-run-stats dbstruct)
-  (let ((totals       (make-hash-table))
-	(curr         (make-hash-table))
-	(res          '())
-	(runs-info    '()))
+  (let* ((dbdat        (db:get-db dbstruct))
+	 (db           (db:dbdat-get-db dbdat))
+	 (totals       (make-hash-table))
+	 (curr         (make-hash-table))
+	 (res          '())
+	 (runs-info    '()))
     ;; First get all the runname/run-ids
+    (db:delay-if-busy dbdat)
     (sqlite3:for-each-row
      (lambda (run-id runname)
        (set! runs-info (cons (list run-id runname) runs-info)))
-     (db:get-db dbstruct #f)
+     db
      "SELECT id,runname FROM runs WHERE state != 'deleted';")
     ;; for each run get stats data
     (for-each
      (lambda (run-info)
        ;; get the net state/status counts for this run
-       (let ((run-id   (car  run-info))
-	     (run-name (cadr run-info)))
+       (let* ((rdbdat    (db:get-db dbstruct run-id))
+	      (rdb       (db:dbdat-get-db dbdat))
+	      (run-id   (car  run-info))
+	      (run-name (cadr run-info)))
+	 (db:delay-if-busy rdbdat)
 	 (sqlite3:for-each-row
 	  (lambda (state status count)
 	    (let ((netstate (if (equal? state "COMPLETED") status state)))
 	      (if (string? netstate)
 		  (begin
 		    (hash-table-set! totals netstate (+ (hash-table-ref/default totals netstate 0) count))
 		    (hash-table-set! curr   netstate (+ (hash-table-ref/default curr   netstate 0) count))))))
-	  (db:get-db dbstruct run-id)
+	  rdb
 	  "SELECT state,status,count(id) FROM tests AS t GROUP BY state,status ORDER BY state,status DESC;")
 	 ;; add the per run counts to res
 	 (for-each (lambda (state)
 		     (set! res (cons (list run-name state (hash-table-ref curr state)) res)))
 		   (sort (hash-table-keys curr) string>=))
@@ -1279,114 +1337,145 @@
     (db:with-db dbstruct #f #f ;; reads db, does not write to it.
 		(lambda (db)
 		  (sqlite3:for-each-row
 		   (lambda (a . r)
 		     (set! res (cons (list->vector (cons a r)) res)))
-		   (db:get-db dbstruct #f)
+		   db
 		   qry-str
 		   runnamepatt)))
     (vector header res)))
 
 ;; use (get-value-by-header (db:get-header runinfo)(db:get-rows runinfo))
 (define (db:get-run-info dbstruct run-id)
   ;;(if (hash-table-ref/default *run-info-cache* run-id #f)
   ;;    (hash-table-ref *run-info-cache* run-id)
-  (let* ((res       (vector #f #f #f #f))
+  (let* ((dbdat     (db:get-db dbstruct #f))
+	 (db        (db:dbdat-get-db dbdat))
+	 (res       (vector #f #f #f #f))
 	 (keys      (db:get-keys dbstruct))
 	 (remfields (list "id" "runname" "state" "status" "owner" "event_time"))
 	 (header    (append keys remfields))
 	 (keystr    (conc (keys->keystr keys) ","
 			  (string-intersperse remfields ","))))
     (debug:print-info 11 "db:get-run-info run-id: " run-id " header: " header " keystr: " keystr)
+    (db:delay-if-busy dbdat)
     (sqlite3:for-each-row
      (lambda (a . x)
        (set! res (apply vector a x)))
-     (db:get-db dbstruct #f)
+     db 
      (conc "SELECT " keystr " FROM runs WHERE id=? AND state != 'deleted';")
      run-id)
     (debug:print-info 11 "db:get-run-info run-id: " run-id " header: " header " keystr: " keystr)
     (let ((finalres (vector header res)))
       ;; (hash-table-set! *run-info-cache* run-id finalres)
       finalres)))
 
 (define (db:set-comment-for-run dbstruct run-id comment)
-  ;; (db:delay-if-busy)
-  (sqlite3:execute (db:get-db dbstruct #f) "UPDATE runs SET comment=? WHERE id=?;" comment ;; (sdb:qry 'getid comment)
-		   run-id))
+  (db:with-db
+   dbstruct
+   #f
+   #f
+   (lambda (db)
+     (sqlite3:execute db "UPDATE runs SET comment=? WHERE id=?;" comment ;; (sdb:qry 'getid comment)
+		      run-id))))
 
 ;; does not (obviously!) removed dependent data. But why not!!?
 (define (db:delete-run dbstruct run-id)
   ;; First set any related tests to DELETED
-  (let ((db (db:get-db dbstruct run-id)))
-    ;; (db:delay-if-busy)
-    (sqlite3:execute db "UPDATE tests SET state='DELETED',comment='';")
-    (sqlite3:execute db "DELETE FROM test_steps;")
-    (sqlite3:execute db "DELETE FROM test_data;")
-    (sqlite3:execute (db:get-db dbstruct #f) "UPDATE runs SET state='deleted',comment='' WHERE id=?;" run-id)))
+  (let* ((rdbdat (db:get-db dbstruct run-id))
+	 (rdb    (db:dbdat-get-db dbdat))
+	 (dbdat  (db:get-db dbstruct #f))
+	 (db     (db:dbdat-get-db dbdat)))
+    (db:delay-if-busy rdbdat)
+    (sqlite3:execute rdb "UPDATE tests SET state='DELETED',comment='';")
+    (sqlite3:execute rdb "DELETE FROM test_steps;")
+    (sqlite3:execute rdb "DELETE FROM test_data;")
+    (db:delay-if-busy dbdat)
+    (sqlite3:execute db "UPDATE runs SET state='deleted',comment='' WHERE id=?;" run-id)))
 
 (define (db:update-run-event_time dbstruct run-id)
-  ;; (db:delay-if-busy)
-  (sqlite3:execute (db:get-db dbstruct #f) "UPDATE runs SET event_time=strftime('%s','now') WHERE id=?;" run-id))
+  (db:with-db
+   dbstruct
+   #f
+   #t
+   (lambda (db)
+     (sqlite3:execute db "UPDATE runs SET event_time=strftime('%s','now') WHERE id=?;" run-id))))
 
 (define (db:lock/unlock-run dbstruct run-id lock unlock user)
-  (let ((newlockval (if lock "locked"
-			(if unlock
-			    "unlocked"
-			    "locked")))) ;; semi-failsafe
-    (sqlite3:execute (db:get-db dbstruct #f) "UPDATE runs SET state=? WHERE id=?;" newlockval run-id)
-    ;; (db:delay-if-busy)
-    (sqlite3:execute (db:get-db dbstruct #f) "INSERT INTO access_log (user,accessed,args) VALUES(?,strftime('%s','now'),?);"
-		     user (conc newlockval " " run-id))
-    (debug:print-info 1 "" newlockval " run number " run-id)))
+  (db:with-db
+   dbstruct
+   #f
+   #t
+   (lambda (db)
+     (let ((newlockval (if lock "locked"
+			   (if unlock
+			       "unlocked"
+			       "locked")))) ;; semi-failsafe
+       (sqlite3:execute db "UPDATE runs SET state=? WHERE id=?;" newlockval run-id)
+       (sqlite3:execute db "INSERT INTO access_log (user,accessed,args) VALUES(?,strftime('%s','now'),?);"
+			user (conc newlockval " " run-id))
+       (debug:print-info 1 "" newlockval " run number " run-id)))))
 
 (define (db:set-run-status dbstruct run-id status msg)
-  (let ((db (db:get-db dbstruct #f)))
+  (let* ((dbdat (db:get-db dbstruct #f))
+	 (db    (db:dbdat-get-db dbdat)))
+    (db:delay-if-busy dbdat)
     (if msg
 	(sqlite3:execute db "UPDATE runs SET status=?,comment=? WHERE id=?;" status msg run-id)
 	(sqlite3:execute db "UPDATE runs SET status=? WHERE id=?;" status run-id))))
 
 (define (db:get-run-status dbstruct run-id)
   (let ((res "n/a"))
-    (sqlite3:for-each-row 
-     (lambda (status)
-       (set! res status))
-     (db:get-db dbstruct #f)
-     "SELECT status FROM runs WHERE id=?;" 
-     run-id)
-    res))
+    (db:with-db
+     dbstruct
+     #f
+     #f
+     (lambda (db)
+       (sqlite3:for-each-row 
+	(lambda (status)
+	  (set! res status))
+	db
+	"SELECT status FROM runs WHERE id=?;" 
+	run-id)
+       res))))
 
 ;;======================================================================
 ;; K E Y S
 ;;======================================================================
 
 ;; get key val pairs for a given run-id
 ;; ( (FIELDNAME1 keyval1) (FIELDNAME2 keyval2) ... )
 (define (db:get-key-val-pairs dbstruct run-id)
   (let* ((keys (db:get-keys dbstruct))
-	 (res  '()))
+	 (res  '())
+	 (dbdat  (db:get-db dbstruct #f))
+	 (db     (db:dbdat-get-db dbdat)))
     (for-each 
      (lambda (key)
        (let ((qry (conc "SELECT " key " FROM runs WHERE id=?;")))
-	 ;; (debug:print 0 "qry: " qry)
+	 (db:delay-if-busy dbdat)
 	 (sqlite3:for-each-row 
 	  (lambda (key-val)
 	    (set! res (cons (list key key-val) res)))
-	  (db:get-db dbstruct #f) qry run-id)))
+	  db qry run-id)))
      keys)
     (reverse res)))
 
 ;; get key vals for a given run-id
 (define (db:get-key-vals dbstruct run-id)
   (let* ((keys (db:get-keys dbstruct))
-	 (res  '()))
+	 (res  '())
+	 (dbdat  (db:get-db dbstruct #f))
+	 (db     (db:dbdat-get-db dbdat)))
     (for-each 
      (lambda (key)
        (let ((qry (conc "SELECT " key " FROM runs WHERE id=?;")))
+	 (db:delay-if-busy dbdat)
 	 (sqlite3:for-each-row 
 	  (lambda (key-val)
 	    (set! res (cons key-val res)))
-	  (db:get-db dbstruct #f) qry run-id)))
+	  db qry run-id)))
      keys)
     (let ((final-res (reverse res)))
       (hash-table-set! *keyvals* run-id final-res)
       final-res)))
 
@@ -2282,35 +2371,38 @@
 ;; 						    (proc (- remtries 1)))))
 ;; 					       (apply sqlite3:execute db query params))
 ;; 					      (debug:print 0 "ERROR: too many attempts to access db were made and no sucess. query: "
 ;; 							   query ", params: " params))))
 ;; 			     (proc remtries))
-(define (db:delay-if-busy #!key (count 6))
-  (let ((dbfj (conc *toppath* "/megatest.db-journal")))
-    (if (file-exists? dbfj)
-	(case count
-	  ((6)
-	   (thread-sleep! 0.2)
-	   (db:delay-if-busy count: 5))
-	  ((5)
-	   (thread-sleep! 0.4)
-	   (db:delay-if-busy count: 4))
-	  ((4)
-	   (thread-sleep! 0.8)
-	   (db:delay-if-busy count: 3))
-	  ((3)
-	   (thread-sleep! 1.6)
-	   (db:delay-if-busy count: 2))
-	  ((2)
-	   (thread-sleep! 3.2)
-	   (db:delay-if-busy count: 1))
-	  ((1)
-	   (thread-sleep! 6.4)
-	   (db:delay-if-busy count: 0))
-	  (else
-	   (debug:print-info 0 "delaying db access due to high database load.")
-	   (thread-sleep! 12.8))))))
+(define (db:delay-if-busy dbdat #!key (count 6))
+  (if dbdat
+      (let* ((dbpath (db:dbdat-get-path dbdat))
+	     (dbfj   (conc dbpath "-journal")))
+;;		  (conc *toppath* "/megatest.db-journal"))))
+	(if (file-exists? dbfj)
+	    (case count
+	      ((6)
+	       (thread-sleep! 0.2)
+	       (db:delay-if-busy count: 5))
+	      ((5)
+	       (thread-sleep! 0.4)
+	       (db:delay-if-busy count: 4))
+	      ((4)
+	       (thread-sleep! 0.8)
+	       (db:delay-if-busy count: 3))
+	      ((3)
+	       (thread-sleep! 1.6)
+	       (db:delay-if-busy count: 2))
+	      ((2)
+	       (thread-sleep! 3.2)
+	       (db:delay-if-busy count: 1))
+	      ((1)
+	       (thread-sleep! 6.4)
+	       (db:delay-if-busy count: 0))
+	      (else
+	       (debug:print-info 0 "delaying db access due to high database load.")
+	       (thread-sleep! 12.8)))))))
 ;; (db:delay-if-busy)
 ;; (apply sqlite3:execute db query params)))
 ;; (db:delay-if-busy)
 
 (define (db:test-get-records-for-index-file dbstruct run-id test-name)

Index: db_records.scm
==================================================================
--- db_records.scm
+++ db_records.scm
@@ -13,23 +13,25 @@
 ;;
 ;;
 ;; Accessors for a dbstruct
 ;;
 
-(define-inline (dbr:dbstruct-get-main    vec)    (vector-ref  vec 0))
-(define-inline (dbr:dbstruct-get-strdb   vec)    (vector-ref  vec 1))
-(define-inline (dbr:dbstruct-get-path    vec)    (vector-ref  vec 2))
+(define-inline (dbr:dbstruct-get-main    vec)    (vector-ref  vec 0)) ;; ( db path )
+(define-inline (dbr:dbstruct-get-strdb   vec)    (vector-ref  vec 1)) ;; ( db path )
+(define-inline (dbr:dbstruct-get-path    vec)    (vector-ref  vec 2)) 
 (define-inline (dbr:dbstruct-get-local   vec)    (vector-ref  vec 3))
-(define-inline (dbr:dbstruct-get-rundb   vec)    (vector-ref  vec 4))
-(define-inline (dbr:dbstruct-get-inmem   vec)    (vector-ref  vec 5))
+(define-inline (dbr:dbstruct-get-rundb   vec)    (vector-ref  vec 4)) ;; ( db path )
+(define-inline (dbr:dbstruct-get-inmem   vec)    (vector-ref  vec 5)) ;; ( db #f )
 (define-inline (dbr:dbstruct-get-mtime   vec)    (vector-ref  vec 6))
 (define-inline (dbr:dbstruct-get-rtime   vec)    (vector-ref  vec 7))
 (define-inline (dbr:dbstruct-get-stime   vec)    (vector-ref  vec 8))
 (define-inline (dbr:dbstruct-get-inuse   vec)    (vector-ref  vec 9))
-(define-inline (dbr:dbstruct-get-refdb   vec)    (vector-ref  vec 10))
+(define-inline (dbr:dbstruct-get-refdb   vec)    (vector-ref  vec 10)) ;; ( db path )
 (define-inline (dbr:dbstruct-get-locdbs  vec)    (vector-ref  vec 11))
-(define-inline (dbr:dbstruct-get-olddb   vec)    (vector-ref  vec 12))
+(define-inline (dbr:dbstruct-get-olddb   vec)    (vector-ref  vec 12)) ;; ( db path )
+;; (define-inline (dbr:dbstruct-get-main-path vec)  (vector-ref  vec 13))
+;; (define-inline (dbr:dbstruct-get-rundb-path vec) (vector-ref  vec 14))
 ;; (define-inline (dbr:dbstruct-get-run-id  vec)    (vector-ref  vec 13))
 
 (define-inline (dbr:dbstruct-set-main!   vec val)(vector-set! vec 0 val))
 (define-inline (dbr:dbstruct-set-strdb!  vec val)(vector-set! vec 1 val))
 (define-inline (dbr:dbstruct-set-path!   vec val)(vector-set! vec 2 val))
@@ -41,16 +43,19 @@
 (define-inline (dbr:dbstruct-set-stime!  vec val)(vector-set! vec 8 val))
 (define-inline (dbr:dbstruct-set-inuse!  vec val)(vector-set! vec 9 val))
 (define-inline (dbr:dbstruct-set-refdb!  vec val)(vector-set! vec 10 val))
 (define-inline (dbr:dbstruct-set-locdbs! vec val)(vector-set! vec 11 val))
 (define-inline (dbr:dbstruct-set-olddb!  vec val)(vector-set! vec 12 val))
+(define-inline (dbr:dbstruct-set-main-path! vec val)(vector-set! vec 13 val))
+(define-inline (dbr:dbstruct-set-rundb-path! vec val)(vector-set! vec 14 val))
+
 ; (define-inline (dbr:dbstruct-set-run-id! vec val)(vector-set! vec 13 val))
 
 ;; constructor for dbstruct
 ;;
 (define (make-dbr:dbstruct #!key (path #f)(local #f))
-  (let ((v (make-vector 14 #f)))
+  (let ((v (make-vector 15 #f)))
     (dbr:dbstruct-set-path! v path)
     (dbr:dbstruct-set-local! v local)
     (dbr:dbstruct-set-locdbs! v (make-hash-table))
     v))