Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -90,13 +90,14 @@
 (define (db:hoh-get dat key1 key2)
   (let* ((subhash (hash-table-ref/default dat key1 #f)))
     (and subhash
 	 (hash-table-ref/default subhash key2 #f))))
 
-(define (db:get-cache-stmth dbstruct db stmt)
-  (let* ((stmt-cache        (dbr:dbstruct-stmt-cache dbstruct))
-	 (stmth             (db:hoh-get stmt-cache db stmt)))
+(define (db:get-cache-stmth dbdat run-id db stmt)
+  (let* (;; (dbdat       (dbfile:get-dbdat dbstruct run-id))
+	 (stmt-cache  (dbr:dbdat-stmt-cache dbdat))
+	 (stmth       (db:hoh-get stmt-cache db stmt)))
     (or stmth
 	(let* ((newstmth (sqlite3:prepare db stmt)))
 	  (db:hoh-set! stmt-cache db stmt newstmth)
 	  newstmth))))
 
@@ -183,11 +184,13 @@
 		     ", arguments: " ((condition-property-accessor 'exn 'arguments) exn)
 		     ", location: "  ((condition-property-accessor 'exn 'location)  exn)
 		     ))
 
 (define (db:open-db dbstruct run-id)
-  (dbfile:open-db dbstruct run-id db:initialize-main-db))
+  (let* ((dbdat (dbfile:open-db dbstruct run-id db:initialize-main-db)))
+    (set! *db-write-access* (not (dbr:dbdat-read-only dbdat)))
+    dbdat))
 
 ;; (db:with-db dbstruct run-id sqlite3:exec "select blah fgrom 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)
@@ -211,11 +214,11 @@
     (if (common:low-noise-print 600 (conc "parallel-api-requests" *max-api-process-requests*))
 	(debug:print-info 2 *default-log-port* "Parallel api request count: " *api-process-request-count* " max parallel requests: " *max-api-process-requests*))
     (condition-case
      (begin
        (if use-mutex (mutex-lock! *db-with-db-mutex*))
-       (let ((res (apply proc db params)))
+       (let ((res (apply proc dbdat db params)))
 	 (if use-mutex (mutex-unlock! *db-with-db-mutex*))
 	 ;; (if (vector? dbstruct)(db:done-with dbstruct run-id r/w))
 	 (if dbdat (stack-push! (dbr:subdb-dbstack subdb) dbdat))
 	 res))
      (exn (io-error)
@@ -1221,11 +1224,11 @@
                                END;" )))
 
 (define (db:create-all-triggers dbstruct)
 (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
 (db:create-triggers db))))
 
 (define (db:create-triggers db)
     (for-each (lambda (key)
               (sqlite3:execute db (cadr key)))
@@ -1232,11 +1235,11 @@
           db:trigger-list))
 
 (define (db:drop-all-triggers dbstruct)
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
      (db:drop-triggers db))))
 
 (define (db:is-trigger-dropped db tbl-name)
   (let* ((trigger-name (if (equal? tbl-name "test_steps")
 			   "update_teststeps_trigger" 
@@ -1607,11 +1610,11 @@
 (define (db:test-set-archive-block-id dbstruct run-id test-id archive-block-id)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:execute db "UPDATE tests SET archived=? WHERE id=?;"
 		      archive-block-id test-id))))
  
 ;; Look up the archive block info given a block-id
 ;;
@@ -1618,11 +1621,11 @@
 (define (db:test-get-archive-block-info dbstruct archive-block-id)
   (db:with-db
    dbstruct
    #f
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((res #f))
        (sqlite3:for-each-row 
 	;;        0         1           2        3          4           5
 	(lambda (id archive-disk-id disk-path last-du last-du-time creation-time)
 	  (set! res (vector id archive-disk-id disk-path last-du last-du-time creation-time)))
@@ -1688,11 +1691,11 @@
 				(string->number deadtime-str))
 			   (string->number deadtime-str)
 			   72000))) ;; twenty hours
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (if (number? ovr-deadtime)(set! deadtime ovr-deadtime))
        
        ;; in RUNNING or REMOTEHOSTSTART for more than 10 minutes
        ;;
        ;; HOWEVER: this code in run:test seems to work fine
@@ -1771,23 +1774,23 @@
     (debug:print-info 4  *default-log-port* "running-deadtime = " running-deadtime)
     (debug:print-info 4  *default-log-port* "deadtime-trim = " deadtime-trim)
 
     (db:with-db 
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (let* ((stmth1 (db:get-cache-stmth
-		       dbstruct db
+		       dbdat run-id db
 		       "SELECT id,rundir,uname,testname,item_path,event_time,run_duration FROM tests 
                            WHERE run_id=? AND (strftime('%s','now') - event_time) > (run_duration + ?)
                                           AND state IN ('RUNNING');"))
 	      (stmth2 (db:get-cache-stmth
-		       dbstruct db
+		       dbdat run-id db
 		       "SELECT id,rundir,uname,testname,item_path,event_time,run_duration FROM tests 
                            WHERE run_id=? AND (strftime('%s','now') - event_time) > (run_duration + ?)
                                           AND state IN ('REMOTEHOSTSTART');"))
 	      (stmth3 (db:get-cache-stmth
-		       dbstruct db
+		       dbdat run-id db
 		       "SELECT id,rundir,uname,testname,item_path FROM tests
                            WHERE run_id=? AND (strftime('%s','now') - event_time) > 86400
                                           AND state IN ('LAUNCHED');")))
 	 ;; in RUNNING or REMOTEHOSTSTART for more than 10 minutes
 	 ;;
@@ -2049,11 +2052,11 @@
 ;;
 (define (db:get-var dbstruct var)
   (let* ((res      #f))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row
         (lambda (val)
           (set! res val))
         db
         "SELECT val FROM metadat WHERE var=?;" var)
@@ -2063,16 +2066,16 @@
              (if valnum (set! res valnum))))
        res))))
 
 (define (db:inc-var dbstruct var)
   (db:with-db dbstruct #f #t 
-	      (lambda (db)
+	      (lambda (dbdat db)
 		(sqlite3:execute db "UPDATE metadat SET val=val+1 WHERE var=?;" var))))
 
 (define (db:dec-var dbstruct var)
   (db:with-db dbstruct #f #t 
-	      (lambda (db)
+	      (lambda (dbdat db)
 		(sqlite3:execute db "UPDATE metadat SET val=val-1 WHERE var=?;" var))))
 
 ;; This was part of db:get-var. It was used to estimate the load on
 ;; the database files.
 ;;
@@ -2085,21 +2088,21 @@
 ;; 	  (debug:print-info 4 *default-log-port* "launch throttle factor=" *global-delta*)
 ;; 	  (set! *last-global-delta-printed* *global-delta*)))
 
 (define (db:set-var dbstruct var val)
   (db:with-db dbstruct #f #t 
-	      (lambda (db)
+	      (lambda (dbdat db)
 		(sqlite3:execute db "INSERT OR REPLACE INTO metadat (var,val) VALUES (?,?);" var val))))
 
 (define (db:add-var dbstruct var val)
   (db:with-db dbstruct #f #t 
-	      (lambda (db)
+	      (lambda (dbdat db)
 		(sqlite3:execute db "UPDATE metadat SET val=val+? WHERE var=?;" val var))))
 
 (define (db:del-var dbstruct var)
   (db:with-db dbstruct #f #t 
-	      (lambda (db)
+	      (lambda (dbdat db)
 		(sqlite3:execute db "DELETE FROM metadat WHERE var=?;" var))))
 
 ;;======================================================================
 ;; no-sync.db - small bits of data to be shared between servers
 ;;======================================================================
@@ -2177,11 +2180,11 @@
 
 (define (db:get-keys dbstruct)
   (if *db-keys* *db-keys* 
       (let ((res '()))
 	(db:with-db dbstruct #f #f
-		    (lambda (db)
+		    (lambda (dbdat db)
 		      (sqlite3:for-each-row 
 		       (lambda (key)
 			 (set! res (cons key res)))
 		       db
 		       "SELECT fieldname FROM keys ORDER BY id DESC;")))
@@ -2228,11 +2231,11 @@
 ;(print qry)
 (db:with-db 
    dbstruct
    #f ;; this is for the main runs db
    #f ;; does not modify db
-   (lambda (db)
+   (lambda (dbdat db)
             (sqlite3:for-each-row
 	(lambda (runname runtime target )
 	  (set! res (cons (vector runname runtime target) res)))
 	db
         qry 
@@ -2245,11 +2248,11 @@
 (define (db:get-run-name-from-id dbstruct run-id)
   (db:with-db 
    dbstruct
    #f ;; this is for the main runs db
    #f ;; does not modify db
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((res #f))
        (sqlite3:for-each-row
 	(lambda (runname)
 	  (set! res runname))
 	db
@@ -2260,11 +2263,11 @@
 (define (db:get-run-key-val dbstruct run-id key)
   (db:with-db
    dbstruct
    #f
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((res #f))
        (sqlite3:for-each-row
 	(lambda (val)
 	  (set! res val))
 	db
@@ -2309,11 +2312,11 @@
     (debug:print 3 *default-log-port* "keys: " keys " allvals: " allvals " keyvals: " keyvals " key=?str is " key=?str)
     (debug:print 2 *default-log-port* "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"
 	(db:with-db
 	 dbstruct #f #f
-	 (lambda (db)
+	 (lambda (dbdat db)
 	   (let ((res #f))
 	     (apply sqlite3:execute db (conc "INSERT OR IGNORE INTO runs (runname,state,status,owner,event_time,contour" comma keystr ") VALUES (?,?,?,?,strftime('%s','now'),?" comma valslots ");")
 		    allvals)
 	     (apply sqlite3:for-each-row 
 		    (lambda (id)
@@ -2359,11 +2362,11 @@
 			   (if (number? offset)
 			       (conc " OFFSET " offset)
 			       ""))))
     (debug:print-info 11 *default-log-port* "db:get-runs START qrystr: " qrystr " keypatts: " keypatts " offset: " offset " limit: " count)
     (db:with-db dbstruct #f #f
-		(lambda (db)		
+		(lambda (dbdat db)		
 		  (sqlite3:for-each-row
 		   (lambda (a . x)
 		     (set! res (cons (apply vector a x) res)))
 		   db
 		   qrystr
@@ -2402,11 +2405,11 @@
 				 (conc " OFFSET " offset)
 				 "")))
 	   )
     (debug:print-info 11 *default-log-port* "db:get-runs START qrystr: " qrystr " target: " target " offset: " offset " limit: " count)
     (db:with-db dbstruct #f #f
-		(lambda (db)		
+		(lambda (dbdat db)		
 		  (sqlite3:for-each-row
 		   (lambda (target id runname state status owner event_time)
 		     (set! res (cons (make-simple-run target id runname state status owner event_time) res)))
 		   db
 		   qrystr
@@ -2443,11 +2446,11 @@
 	 (seen       (make-hash-table)))
     (db:with-db
      dbstruct
      #f
      #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row
 	(lambda (a . x)
 	  (let ((targ (cons a x)))
 	    (if (not (hash-table-ref/default seen targ #f))
 		(begin
@@ -2462,11 +2465,11 @@
 (define (db:get-num-runs dbstruct runpatt)
   (db:with-db
    dbstruct
    #f
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((numruns 0))
        (debug:print-info 11 *default-log-port* "db:get-num-runs START " runpatt)
        (sqlite3:for-each-row 
 	(lambda (count)
 	  (set! numruns count))
@@ -2479,11 +2482,11 @@
 (define (db:get-runs-cnt-by-patt dbstruct runpatt targetpatt keys)
   (db:with-db
    dbstruct
    #f
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((numruns 0)
            (qry-str #f)
            (key-patt "")
 	     	   (keyvals  (if targetpatt (keys:target->keyval keys targetpatt) '())))
      
@@ -2517,11 +2520,11 @@
 (define (db:get-raw-run-stats dbstruct run-id)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:fold-row
 	(lambda (res state status count)
 	  (cons (list state status count) res))
 	'()
 	db
@@ -2536,11 +2539,11 @@
   (db:with-db
    dbstruct
    #f
    #f
 
-   (lambda (db)
+   (lambda (dbdat db)
      ;; remove previous data
      
      (let* ((stmt1 (sqlite3:prepare db "DELETE FROM run_stats WHERE run_id=? AND state=? AND status=?;"))
 	    (stmt2 (sqlite3:prepare db "INSERT INTO run_stats (run_id,state,status,count) VALUES (?,?,?,?);"))
 	    (res
@@ -2560,11 +2563,11 @@
 (define (db:get-main-run-stats dbstruct run-id)
   (db:with-db
    dbstruct
    #f ;; this data comes from main
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:fold-row
 	(lambda (res state status count)
 	  (cons (list state status count) res))
 	'()
 	db
@@ -2593,11 +2596,11 @@
 (define (db:get-all-run-ids dbstruct)
   (db:with-db
    dbstruct
    #f
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((run-ids '()))
        (sqlite3:for-each-row
 	(lambda (run-id)
 	  (set! run-ids (cons run-id run-ids)))
 	db
@@ -2617,11 +2620,11 @@
 	 (res          '())
 	 (runs-info    '()))
     ;; First get all the runname/run-ids
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row
 	(lambda (run-id runname)
 	  (set! runs-info (cons (list run-id runname) runs-info)))
 	db
 	"SELECT id,runname FROM runs WHERE state != 'deleted' ORDER BY event_time DESC;"))) ;; If you change this to the more logical ASC please adjust calls to db:get-run-stats
@@ -2633,11 +2636,11 @@
 	      (run-name (cadr run-info)))
 	 (db:with-db
 	  dbstruct
 	  run-id
 	  #f
-	  (lambda (db)
+	  (lambda (dbdat db)
 	    (sqlite3:for-each-row
 	     (lambda (state status count)
 	       (let ((netstate (if (equal? state "COMPLETED") status state)))
 		 (if (string? netstate)
 		     (begin
@@ -2695,11 +2698,11 @@
     ;(print "runs:get-runs-by-patt qry=" qry-str " " runnamepatt)
 
     (vector header 
             (reverse
              (db:with-db dbstruct #f #f ;; reads db, does not write to it.
-                         (lambda (db)
+                         (lambda (dbdat db)
                            (sqlite3:fold-row
                             (lambda (res . r)
                               (cons (list->vector r) res))
                             '()
                             db
@@ -2721,11 +2724,11 @@
 			  (string-intersperse remfields ","))))
     (debug:print-info 11 *default-log-port* "db:get-run-info run-id: " run-id " header: " header " keystr: " keystr)
     
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row
 	(lambda (a . x)
 	  (set! res (apply vector a x)))
 	db 
 	(conc "SELECT " keystr " FROM runs WHERE id=?;")
@@ -2736,19 +2739,19 @@
       finalres)))
 
 (define (db:set-comment-for-run dbstruct run-id comment)
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat 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)
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:with-transaction
       db
       (lambda ()
         (sqlite3:execute db "DELETE FROM test_steps WHERE test_id IN (SELECT id FROM tests WHERE run_id=?);" run-id)
         (sqlite3:execute db "DELETE FROM test_data WHERE test_id IN (SELECT id FROM tests WHERE run_id=?);"  run-id)
@@ -2757,17 +2760,17 @@
         (sqlite3:execute db "UPDATE runs SET state='deleted',comment='' WHERE id=?;" run-id))))))
 
 (define (db:update-run-event_time dbstruct run-id)
   (db:with-db
    dbstruct #f #t
-   (lambda (db)
+   (lambda (dbdat 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)
   (db:with-db
    dbstruct #f #t
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((newlockval (if lock "locked"
 			   (if unlock
 			       "unlocked"
 			       "locked")))) ;; semi-failsafe
        (sqlite3:execute db "UPDATE runs SET state=? WHERE id=?;" newlockval run-id)
@@ -2776,28 +2779,28 @@
        (debug:print-info 1 *default-log-port* "" newlockval " run number " run-id)))))
 
 (define (db:set-run-status dbstruct run-id status msg)
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
        (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:set-run-state-status dbstruct run-id state status )
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
           (sqlite3:execute db "UPDATE runs SET status=?,state=? WHERE id=?;" status state run-id))))
 
 
 
 (define (db:get-run-status dbstruct run-id)
   (let ((res "n/a"))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row 
 	(lambda (status)
 	  (set! res status))
 	db
 	"SELECT status FROM runs WHERE id=?;" 
@@ -2806,11 +2809,11 @@
 
 (define (db:get-run-state dbstruct run-id)
   (let ((res "n/a"))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row 
 	(lambda (status)
 	  (set! res status))
 	db
 	"SELECT state FROM runs WHERE id=?;" 
@@ -2827,11 +2830,11 @@
 (define (db:get-key-val-pairs dbstruct run-id)
   (let* ((keys (db:get-keys dbstruct))
 	 (res  '()))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (for-each 
 	(lambda (key)
 	  (let ((qry (conc "SELECT " key " FROM runs WHERE id=?;")))
 	    (sqlite3:for-each-row 
 	     (lambda (key-val)
@@ -2844,11 +2847,11 @@
 (define (db:get-key-vals dbstruct run-id)
   (let* ((keys (db:get-keys dbstruct))
 	 (res  '()))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (for-each 
 	(lambda (key)
 	  (let ((qry (conc "SELECT " key " FROM runs WHERE id=?;")))
 	    ;; (db:delay-if-busy dbdat)
 	    (sqlite3:for-each-row 
@@ -2876,11 +2879,11 @@
     (let ((prev-run-ids '()))
       (if (null? keyvals)
           '()
           (begin
             (db:with-db dbstruct #f #f ;; #f means work with the zeroth db - i.e. the runs db
-                        (lambda (db)
+                        (lambda (dbdat db)
                           (apply sqlite3:for-each-row
                                  (lambda (id)
                                    (set! prev-run-ids (cons id prev-run-ids)))
                                  db
                                  (conc "SELECT id FROM runs WHERE " qrystr " AND state != 'deleted' AND id != ?;")
@@ -2971,11 +2974,11 @@
 				(if offset (conc " OFFSET " offset) " ")
 				";"
 				)))
     (debug:print-info 8 *default-log-port* "db:get-tests-for-run run-id=" run-id ", qry=" qry)
     (let* ((res (db:with-db dbstruct run-id #f
-			    (lambda (db)
+			    (lambda (dbdat db)
 			      ;; (let* ((stmth (db:get-cache-stmth dbstruct db qry))) ;; due to use of last-update we can't efficiently cache this query
 				(reverse
 				 (sqlite3:fold-row
 				  (lambda (res . row)
 				    ;; id run-id testname state status event-time host cpuload
@@ -3008,11 +3011,11 @@
 ;; 3. convert for-each-row to fold
 ;;
 ;; (define (db:get-tests-for-run-state-status dbstruct run-id testpatt)
 ;;   (db:with-db
 ;;    dbstruct run-id #f
-;;    (lambda (db)
+;;    (lambda (dbdat db)
 ;;      (let* ((res            '())
 ;; 	    (stmt-cache      (dbr:dbstruct-stmt-cache dbstruct))
 ;; 	    (stmth           (let* ((sh (db:hoh-get stmt-cache db testpatt)))
 ;; 			       (or sh
 ;; 				   (let* ((tests-match-qry (tests:match->sqlqry testpatt))
@@ -3038,11 +3041,11 @@
 				" AND last_update > ? "
 				(if tests-match-qry (conc " AND (" tests-match-qry ") ") "")
 				)))
     (debug:print-info 8 *default-log-port* "db:get-tests-for-run qry=" qry)
     (db:with-db dbstruct run-id #f
-		(lambda (db)
+		(lambda (dbdat db)
 		  (sqlite3:fold-row
 		   (lambda (res id testname item-path state status event-time run-duration)
 		     ;;            id,run_id,testname,state,status,event_time,host,cpuload,diskfree,uname,rundir,item_path,run_duration,final_logf,comment
 		     (cons (vector id run-id testname state status event-time  ""     -1      -1       ""    "-"  item-path run-duration  "-"         "-") res))
 		   '()
@@ -3052,11 +3055,11 @@
 		   (or last-update 0))))))
 
 (define (db:get-testinfo-state-status dbstruct run-id test-id)
   (let ((res            #f))
     (db:with-db dbstruct run-id #f
-		(lambda (db)
+		(lambda (dbdat db)
 		  (sqlite3:for-each-row
 		   (lambda (run-id testname item-path state status)
 		     ;; id,run_id,testname,state,status,event_time,host,cpuload,diskfree,uname,rundir,item_path,run_duration,final_logf,comment
 		     (set! res (vector test-id run-id testname state status -1 "" -1 -1 "" "-" item-path -1 "-" "-")))
 		   db 
@@ -3091,11 +3094,11 @@
 (define (db:delete-test-records dbstruct run-id test-id)
   (db:general-call dbstruct 'delete-test-step-records (list test-id))
   (db:general-call dbstruct 'delete-test-data-records (list test-id))
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:execute db "UPDATE tests SET state='DELETED',status='n/a',comment='' WHERE id=?;" test-id))))
 
 ;; 
 (define (db:delete-old-deleted-test-records dbstruct)
   (let ((targtime (- (current-seconds)
@@ -3103,11 +3106,11 @@
 			 (* 30 24 60 60))))) ;; one month in the past
     (db:with-db
      dbstruct
      0
      #t
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:with-transaction
 	db
 	(lambda ()
 	  (sqlite3:execute db "DELETE FROM test_steps WHERE test_id IN (SELECT id FROM tests WHERE state='DELETED' AND event_time<?);" targtime)
 	  (sqlite3:execute db "DELETE FROM test_data WHERE test_id IN (SELECT id FROM tests WHERE state='DELETED' AND event_time<?);" targtime)
@@ -3134,11 +3137,11 @@
 	     (test-id (db:get-test-id dbstruct run-id testname "")))
 	 (db:with-db
 	  dbstruct
 	  run-id
 	  #t
-	  (lambda (db)
+	  (lambda (dbdat db)
 	    (sqlite3:execute db qry
 			     (or newstate  currstate "NOT_STARTED")
 			     (or newstatus currstate "UNKNOWN")
 			     run-id testname)))
 	 (if test-id
@@ -3157,11 +3160,11 @@
   (db:with-db
    dbstruct
    ;; run-id
    #f
    #t
-   (lambda (db)
+   (lambda (dbdat db)
      (cond
       ((and newstate newstatus newcomment)
        (sqlite3:execute db "UPDATE tests SET state=?,status=?,comment=? WHERE id=?;" newstate newstatus newcomment ;; (sdb:qry 'getid newcomment)
 			test-id))
       ((and newstate newstatus)
@@ -3181,22 +3184,22 @@
 		  "SELECT count(id) FROM tests WHERE state in ('RUNNING','LAUNCHED','REMOTEHOSTSTART') AND NOT (uname = 'n/a' AND item_path = '');")) ;; )
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
-     (let* ((stmth (db:get-cache-stmth dbstruct  db qry)))
+   (lambda (dbdat db)
+     (let* ((stmth (db:get-cache-stmth dbdat run-id db qry)))
        (sqlite3:first-result stmth))))))
 
 ;; NEW BEHAVIOR: Count tests running in only one run!
 ;;
 (define (db:get-count-tests-actually-running dbstruct run-id)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:first-result
       db
       ;; WARNING BUG EDIT ME - merged from v1.55 - not sure what is right here ...
       ;; "SELECT count(id) FROM tests WHERE state in ('RUNNING','LAUNCHED','REMOTEHOSTSTART') AND run_id NOT IN (SELECT id FROM runs WHERE state='deleted') AND NOT (uname = 'n/a' AND item_path = '');")
       "SELECT count(id) FROM tests WHERE state in ('RUNNING','REMOTEHOSTSTART','LAUNCHED') AND run_id=?;" 
@@ -3211,12 +3214,12 @@
 		  "SELECT count(id) FROM tests WHERE state in ('RUNNING','LAUNCHED','REMOTEHOSTSTART') AND run_id=?;")) ;; )
     (db:with-db
      dbstruct
      run-id
      #f
-     (lambda (db)
-       (let* ((stmth (db:get-cache-stmth dbstruct db qry)))
+     (lambda (dbdat db)
+       (let* ((stmth (db:get-cache-stmth dbdat run-id db qry)))
 	 (sqlite3:first-result stmth run-id))))))
 
 ;; For a given testname how many items are running? Used to determine
 ;; probability for regenerating html
 ;;
@@ -3223,22 +3226,22 @@
 (define (db:get-count-tests-running-for-testname dbstruct run-id testname)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let* ((stmt "SELECT count(id) FROM tests WHERE state in ('RUNNING','LAUNCHED','REMOTEHOSTSTART') AND run_id=? AND NOT (uname = 'n/a' AND item_path = '') AND testname=?;")
-	    (stmth (db:get-cache-stmth dbstruct db stmt)))
+	    (stmth (db:get-cache-stmth dbdat run-id db stmt)))
        (sqlite3:first-result
 	stmth run-id testname)))))
 
 (define (db:get-not-completed-cnt dbstruct run-id)
 (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
       ;(print "SELECT count(id) FROM tests WHERE state not in ('COMPLETED', 'DELETED') AND run_id=" run-id)  
      (sqlite3:first-result
       db
       "SELECT count(id) FROM tests WHERE state not in ('COMPLETED', 'DELETED') AND run_id=?;" run-id))))
 
@@ -3247,11 +3250,11 @@
       0 ;; 
       (let ((testnames '()))
 	;; get the testnames
 	(db:with-db
 	 dbstruct #f #f
-	 (lambda (db)
+	 (lambda (dbdat db)
 	   (sqlite3:for-each-row
 	    (lambda (testname)
 	      (set! testnames (cons testname testnames)))
 	    db
 	    "SELECT testname FROM test_meta WHERE jobgroup=?"
@@ -3260,11 +3263,11 @@
 	(if (not (null? testnames))
 	    (db:with-db
 	     dbstruct
 	     run-id
 	     #f
-	     (lambda (db)
+	     (lambda (dbdat db)
 	       (sqlite3:first-result
 		db
 		(conc "SELECT count(id) FROM tests WHERE state in ('RUNNING','LAUNCHED','REMOTEHOSTSTART') AND testname in ('"
 		      (string-intersperse testnames "','")
 		      "') AND NOT (uname = 'n/a' AND item_path='');")) ;; should this include the (uname = 'n/a' ...) ???
@@ -3279,11 +3282,11 @@
 (define (db:estimated-tests-remaining dbstruct run-id)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:first-result
       db
       "SELECT count(id) FROM tests WHERE state in ('LAUNCHED','NOT_STARTED','REMOTEHOSTSTART','RUNNING','KILLREQ') AND run_id=?;")
      run-id)))
 
@@ -3291,11 +3294,11 @@
 (define (db:get-test-id dbstruct run-id testname item-path)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (db:first-result-default
       db
       "SELECT id FROM tests WHERE testname=? AND item_path=? AND run_id=?;"
       #f ;; the default
       testname item-path run-id))))
@@ -3306,20 +3309,20 @@
 (define (db:test-set-top-process-pid dbstruct run-id test-id pid)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:execute db "UPDATE tests SET attemptnum=? WHERE id=?;"
 		      pid test-id))))
 
 (define (db:test-get-top-process-pid dbstruct run-id test-id)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (db:first-result-default 
       db
       "SELECT attemptnum FROM tests WHERE id=?;"
       #f
       test-id))))
@@ -3345,21 +3348,21 @@
 (define db:test-record-qry-selector (string-intersperse db:test-record-fields ","))
 
 (define (db:update-tesdata-on-repilcate-db dbstruct old-lt new-lt)
   (db:with-db
    dbstruct   #f   #f
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:execute db "UPDATE tests SET rundir= replace(rundir,?,?), shortdir=replace(shortdir,?,?);"
 		      old-lt new-lt  old-lt new-lt))))
 
 ;; NOTE: Use db:test-get* to access records
 ;; NOTE: This needs rundir decoding? Decide, decode here or where used? For the moment decode where used.
 (define (db:get-all-tests-info-by-run-id dbstruct run-id)
   (let* ((res '()))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (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 shortdir attemptnum archived)
 	  ;;                 0    1       2      3      4        5       6      7        8     9     10      11          12          13       14     15        16
 	  (set! res (cons (vector id run-id testname state status event-time host cpuload diskfree uname rundir item-path run-duration final-logf comment shortdir attemptnum archived)
 			  res)))
@@ -3368,11 +3371,11 @@
 	run-id)))
     res))
 
 (define (db:replace-test-records dbstruct run-id testrecs)
   (db:with-db dbstruct run-id #t 
-	      (lambda (db)
+	      (lambda (dbdat db)
 		(let* ((qmarks (string-intersperse (make-list (length db:test-record-fields) "?") ","))
 		       (qrystr (conc "INSERT OR REPLACE INTO tests (" db:test-record-qry-selector ") VALUES (" qmarks ") WHERE run_id=?;"))
 		       (qry    (sqlite3:prepare db qrystr)))
 		  (debug:print 0 *default-log-port* "INFO: migrating test records for run with id " run-id)
 		  (sqlite3:with-transaction
@@ -3432,11 +3435,11 @@
 (define (db:get-test-info-by-id dbstruct run-id test-id)
   (db:with-db
    dbstruct
    #f ;; run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((res #f))
        (sqlite3:for-each-row ;; attemptnum added to hold pid of top process (not Megatest) controlling a test
 	(lambda (id run-id testname state status event-time host cpuload diskfree uname rundir-id item-path run_duration final-logf-id comment short-dir-id attemptnum archived last-update)
 	  ;;                0    1       2      3      4        5       6      7        8     9     10      11          12          13           14         15          16
 	  (set! res (vector id run-id testname state status event-time host cpuload diskfree uname rundir-id item-path run_duration final-logf-id comment short-dir-id attemptnum archived last-update)))
@@ -3451,11 +3454,11 @@
 (define (db:get-test-info-by-ids dbstruct run-id test-ids)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((res '()))
        (sqlite3:for-each-row
 	(lambda (a . b)
 	  ;;                 0    1       2      3      4        5       6      7        8     9     10      11          12          13       14
 	  (set! res (cons (apply vector a b) res)))
@@ -3467,11 +3470,11 @@
 (define (db:get-test-info dbstruct run-id test-name item-path)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((res #f))
        (sqlite3:for-each-row
 	(lambda (a . b)
 	  (set! res (apply vector a b)))
 	db
@@ -3482,11 +3485,11 @@
 (define (db:test-get-rundir-from-test-id dbstruct run-id test-id)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (db:first-result-default
       db
       "SELECT rundir FROM tests WHERE id=?;"
       #f ;; default result
       test-id))))
@@ -3498,11 +3501,11 @@
 		      " as target from tests inner join runs on tests.run_id = runs.id where runs.runname = ? and target = ?  ;")))
   (db:with-db 
     dbstruct
     #f ;; this is for the main runs db
     #f ;; does not modify db
-    (lambda (db)
+    (lambda (dbdat db)
             (sqlite3:for-each-row
 	(lambda (test-name item-path test-time target )
 	  (set! res (cons (vector test-name item-path test-time) res)))
 	db
         qry 
@@ -3516,11 +3519,11 @@
 (define (db:teststep-set-status! dbstruct run-id test-id teststep-name state-in status-in comment logfile)
   (db:with-db
    dbstruct
    run-id
    #t
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:execute 
       db
       "INSERT OR REPLACE into test_steps (test_id,stepname,state,status,event_time,comment,logfile) VALUES(?,?,?,?,?,?,?);"
       test-id teststep-name state-in status-in (current-seconds)
       (if comment comment "")
@@ -3532,11 +3535,11 @@
   ;; TODO: figure out why status is the key field rather than state (note:  CONSTRAINT test_steps_constraint UNIQUE (test_id,stepname,state) )
   (db:with-db
    dbstruct
    run-id
    #t
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:execute 
       db
       "UPDATE test_steps set status='DELETED' where test_id=?" ;;  and run_id=? !! - run_id not in table (bummer) TODO: get run_id into schema for test_steps
       test-id))))
 
@@ -3545,11 +3548,11 @@
 (define (db:get-steps-for-test dbstruct run-id test-id)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let* ((res '()))
        (sqlite3:for-each-row 
 	(lambda (id test-id stepname state status event-time logfile comment)
 	  (set! res (cons (vector id test-id stepname state status event-time (if (string? logfile) logfile "") comment) res)))
 	db
@@ -3560,11 +3563,11 @@
  (define (db:get-steps-info-by-id dbstruct  test-step-id)
    (db:with-db
     dbstruct
     #f 
     #f
-    (lambda (db)
+    (lambda (dbdat db)
       (let* ((res (vector #f #f #f #f #f #f #f #f #f)))
         (sqlite3:for-each-row 
        (lambda (id test-id stepname state status event-time logfile comment last-update)
          (set! res (vector id test-id stepname state status event-time (if (string? logfile) logfile "") comment last-update)))
        db
@@ -3575,11 +3578,11 @@
 (define (db:get-steps-data dbstruct run-id test-id)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((res '()))
        (sqlite3:for-each-row 
 	(lambda (id test-id stepname state status event-time logfile)
 	  (set! res (cons (vector id test-id stepname state status event-time (if (string? logfile) logfile "")) res)))
 	db
@@ -3595,12 +3598,12 @@
   (let* ((stmt        "SELECT id,test_id, category, variable, value, expected, tol, units, comment, status, type, last_update FROM test_data WHERE id=? ORDER BY id ASC;")) ;; event_time DESC,id ASC;
     (db:with-db
      dbstruct
      #f 
      #f
-     (lambda (db)
-       (let* ((stmth (db:get-cache-stmth dbstruct db stmt))
+     (lambda (dbdat db)
+       (let* ((stmth (db:get-cache-stmth dbdat #f db stmt))
 	      (res   (sqlite3:fold-row
 		      (lambda (res id test-id  category variable value expected tol units comment status type last-update)
 			(vector id test-id  category variable value expected tol units comment status type last-update))
 		      (vector #f #f #f #f #f #f #f #f #f #f #f #f)
 		      stmth
@@ -3615,11 +3618,11 @@
 (define (db:test-data-rollup dbstruct run-id test-id status)
   (let* ((fail-count 0)
 	 (pass-count 0))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row
 	(lambda (fcount pcount)
 	  (set! fail-count fcount)
 	  (set! pass-count pcount))
 	db 
@@ -3714,11 +3717,11 @@
 
 (define (db:csv->test-data dbstruct run-id test-id csvdata)
   (debug:print 4 *default-log-port* "test-id " test-id ", csvdata: " csvdata)
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let* ((csvlist (csv->list (make-csv-reader
 				 (open-input-string csvdata)
 				 '((strip-leading-whitespace? #t)
 				   (strip-trailing-whitespace? #t)))))) ;; (csv->list csvdata)))
        (for-each
@@ -3777,11 +3780,11 @@
 ;;
 (define (db:read-test-data dbstruct run-id test-id categorypatt)
   (let* ((res '()))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row 
 	(lambda (id test_id category variable value expected tol units comment status type)
 	  (set! res (cons (vector id test_id category variable value expected tol units comment status type) res)))
 	db
 	"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)
@@ -3791,11 +3794,11 @@
 ;;
 (define (db:read-test-data-varpatt dbstruct run-id test-id categorypatt varpatt)
   (let* ((res '()))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row 
 	(lambda (id test_id category variable value expected tol units comment status type)
 	  (set! res (cons (vector id test_id category variable value expected tol units comment status type) res)))
 	db
 	"SELECT id,test_id,category,variable,value,expected,tol,units,comment,status,type FROM test_data WHERE test_id=? AND category LIKE ? AND variable LIKE ? ORDER BY category,variable;" test-id categorypatt varpatt)
@@ -3807,11 +3810,11 @@
 ;;======================================================================
 
 (define (db:get-run-ids-matching-target dbstruct keynames target res runname testpatt statepatt statuspatt)
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let* ((row-ids '())
 	    (keystr (string-intersperse 
 		     (map (lambda (key val)
 			    (conc key " like '" val "'"))
 			  keynames 
@@ -3834,11 +3837,11 @@
 	 (tstsqry (conc "SELECT rundir FROM tests WHERE run_id=? AND " testqry " AND state LIKE '" statepatt "' AND status LIKE '" statuspatt "' ORDER BY event_time ASC;")))
     (db:with-db
      dbstruct
      run-id
      #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row 
 	(lambda (p)
 	  (set! res (cons p res)))
 	db
 	tstsqry
@@ -3848,11 +3851,11 @@
 (define (db:test-toplevel-num-items dbstruct run-id testname)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((res 0))
        (sqlite3:for-each-row
 	(lambda (num-items)
 	  (set! res num-items))
 	db
@@ -3936,11 +3939,11 @@
     (if (member state '("LAUNCHED" "REMOTEHOSTSTART")) 
 	(db:general-call dbstruct 'set-test-start-time (list test-id)))
     (mutex-lock! *db-transaction-mutex*)
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (let ((tr-res
               (sqlite3:with-transaction
                db
                (lambda ()
                  ;; NB// Pass the db so it is part fo the transaction
@@ -4023,11 +4026,11 @@
 
 (define (db:set-state-status-and-roll-up-run dbstruct run-id curr-state curr-status)
     (mutex-lock! *db-transaction-mutex*)
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (let ((tr-res
               (sqlite3:with-transaction
                db
                (lambda ()
                    (let* ((state-status-counts  (db:get-all-state-status-counts-for-run dbstruct run-id))
@@ -4041,11 +4044,11 @@
 
 
 (define (db:get-all-state-status-counts-for-run dbstruct run-id)
  (let* ((test-count-recs (db:with-db
                                   dbstruct #f #f
-                                  (lambda (db)
+                                  (lambda (dbdat db)
                                     (sqlite3:map-row
                                      (lambda (state status count)
                                         (make-dbr:counts state: state status: status count: count))
                                      db
                                      "SELECT state,status,count(id) FROM tests WHERE run_id=?  GROUP BY state,status;"
@@ -4061,11 +4064,11 @@
   (let* ((test-info   (db:get-test-info dbstruct run-id test-name item-path))
          (item-state  (or item-state-in (db:test-get-state test-info))) 
          (item-status (or item-status-in (db:test-get-status test-info)))
          (other-items-count-recs (db:with-db
                                   dbstruct #f #f
-                                  (lambda (db)
+                                  (lambda (dbdat db)
                                     (sqlite3:map-row
                                      (lambda (state status count)
                                        (make-dbr:counts state: state status: status count: count))
                                      db
                                      ;; ignore current item because we have changed its value in the current transation so this select will see the old value.
@@ -4110,11 +4113,11 @@
 (define (db:test-get-logfile-info dbstruct run-id test-name)
   (db:with-db
    dbstruct
    run-id
    #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let ((res #f))
        (sqlite3:for-each-row 
 	(lambda (path final_logf)
 	  ;; (let ((path       (sdb:qry 'getstr path-id))
 	  ;;       (final_logf (sdb:qry 'getstr final_logf-id)))
@@ -4304,21 +4307,21 @@
 				       stmtname)
 				   db:queries)))
  		 (if q (car q) #f))))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (apply sqlite3:execute db query params)
        #t))))
 
 ;; get a summary of state and status counts to calculate a rollup
 ;;
 (define (db:get-state-status-summary dbstruct run-id testname)
   (let ((res   '()))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row
 	(lambda (state status count)
 	  (set! res (cons (vector state status count) res)))
 	db
 	"SELECT state,status,count(state) FROM tests WHERE run_id=? AND testname=? AND item_path='' GROUP BY state,status;"
@@ -4328,11 +4331,11 @@
 (define (db:get-latest-host-load dbstruct raw-hostname)
   (let* ((hostname (string-substitute "\\..*$" "" raw-hostname))
          (res  (cons -1 0)))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row
         (lambda (cpuload update-time)  (set! res (cons cpuload update-time)))
         db
         "SELECT tr.cpuload, tr.update_time FROM test_rundat tr, tests t WHERE t.host=? AND tr.cpuload != -1  AND tr.test_id=t.id ORDER BY tr.update_time DESC LIMIT 1;"
         hostname))) res ))
@@ -4373,11 +4376,11 @@
 	 (keyvals #f)
 	 (tests-hash (make-hash-table)))
     ;; first look up the key values from the run selected by run-id
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row 
 	(lambda (a . b)
 	  (set! keyvals (cons a b)))
 	db
 	(conc "SELECT " selstr " FROM runs WHERE id=? ORDER BY event_time DESC;") run-id)))
@@ -4384,11 +4387,11 @@
     (if (not keyvals)
 	'()
 	(let ((prev-run-ids '()))
 	  (db:with-db
 	   dbstruct #f #f
-	   (lambda (db)
+	   (lambda (dbdat db)
 	     (apply sqlite3:for-each-row
 		    (lambda (id)
 		      (set! prev-run-ids (cons id prev-run-ids)))
 		    db
 		    (conc "SELECT id FROM runs WHERE " qrystr " AND id != ?;") (append keyvals (list run-id)))))
@@ -4463,11 +4466,11 @@
   (let ((res '()))
     (db:with-db
      dbstruct
      run-id
      #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row 
 	(lambda (id itempath state status run_duration logf comment)
 	  (set! res (cons (vector id itempath state status run_duration logf comment) res)))
 	db
 	"SELECT id,item_path,state,status,run_duration,final_logf,comment FROM tests WHERE testname=? AND item_path != '' AND run_id=?;" ;; BUG! WHY NO run_id?
@@ -4482,11 +4485,11 @@
 ;; returns a hash table of tags to tests
 ;;
 (define (db:get-tests-tags dbstruct)
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
      (let* ((res     (make-hash-table)))
        (sqlite3:for-each-row
 	(lambda (testname tags-in)
 	  (let ((tags (string-split tags-in ",")))
 	    (for-each
@@ -4504,11 +4507,11 @@
   (let ((res   #f))
     (db:with-db
      dbstruct
      #f
      #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row
 	(lambda (id testname author owner description reviewed iterated avg_runtime avg_disk tags jobgroup)
 	  (set! res (vector id testname author owner description reviewed iterated avg_runtime avg_disk tags jobgroup)))
 	db
 	"SELECT id,testname,author,owner,description,reviewed,iterated,avg_runtime,avg_disk,tags,jobgroup FROM test_meta WHERE testname=?;"
@@ -4516,26 +4519,26 @@
        res))))
 
 ;; create a new record for a given testname
 (define (db:testmeta-add-record dbstruct testname)
   (db:with-db dbstruct #f #f 
-	      (lambda (db)
+	      (lambda (dbdat db)
 		(sqlite3:execute 
 		 db
 		 "INSERT OR IGNORE INTO test_meta (testname,author,owner,description,reviewed,iterated,avg_runtime,avg_disk,tags) VALUES (?,'','','','','','','','');" testname))))
 
 ;; update one of the testmeta fields
 (define (db:testmeta-update-field dbstruct testname field value)
   (db:with-db dbstruct #f #f 
-	      (lambda (db)
+	      (lambda (dbdat db)
 		(sqlite3:execute 
 		 db
 		 (conc "UPDATE test_meta SET " field "=? WHERE testname=?;") value testname))))
 
 (define (db:testmeta-get-all dbstruct)
   (db:with-db dbstruct #f #f 
-	      (lambda (db)
+	      (lambda (dbdat db)
 		(let ((res '()))
 		  (sqlite3:for-each-row
 		   (lambda (a . b)
 		     (set! res (cons (apply vector a b) res)))
 		   db
@@ -4786,11 +4789,11 @@
 ;;======================================================================
 (define (db:get-run-record-ids dbstruct target run keynames test-patt)
 (let ((backcons (lambda (lst item)(cons item lst))))
     (db:with-db
      dbstruct #f #f 
-     (lambda (db)
+     (lambda (dbdat db)
         (let* ((keystr (string-intersperse 
 		     (map (lambda (key val)
 			    (conc key " like '" val "'"))
 			  keynames 
 			  (string-split target "/"))
@@ -4815,11 +4818,11 @@
 (define (db:get-changed-record-ids dbstruct since-time)
   ;; no transaction, allow the db to be accessed between the big queries
   (let ((backcons (lambda (lst item)(cons item lst))))
     (db:with-db
      dbstruct #f #f 
-     (lambda (db)
+     (lambda (dbdat db)
        `((runs       . ,(sqlite3:fold-row backcons '() db "SELECT id FROM runs  WHERE last_update>=?" since-time))
 	 (tests      . ,(sqlite3:fold-row backcons '() db "SELECT id FROM tests WHERE last_update>=?" since-time))
 	 (test_steps . ,(sqlite3:fold-row backcons '() db "SELECT id FROM test_steps WHERE last_update>=?" since-time))
 	 (test_data  . ,(sqlite3:fold-row backcons '() db "SELECT id FROM test_data  WHERE last_update>=?" since-time))
 	 ;; (test_meta  . ,(fold-row backcons '() db "SELECT id FROM test_meta  WHERE last_update>?" since-time))

Index: rmt.scm
==================================================================
--- rmt.scm
+++ rmt.scm
@@ -973,12 +973,12 @@
 
 (define (rmtmod:calc-ro-mode runremote *toppath*)
   (if (and runremote
 	   (remote-ro-mode-checked runremote))
       (remote-ro-mode runremote)
-      (let* ((dbfile  (conc *toppath* "/megatest.db"))
-	     (ro-mode (not (file-write-access? dbfile)))) ;; TODO: use dbstruct or runremote to figure this out in future
+      (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)

Index: runs.scm
==================================================================
--- runs.scm
+++ runs.scm
@@ -508,12 +508,12 @@
   (let* ((keys               (keys:config-get-fields *configdat*))
 	 (keyvals            (keys:target->keyval keys target))
 	 (run-id             (rmt:register-run keyvals runname "new" "n/a" user (args:get-arg "-contour")))  ;;  test-name)))
 	 ;; (deferred          '()) ;; delay running these since they have a waiton clause
 	 (runconfigf         (conc  *toppath* "/runconfigs.config"))
-         (dbfile             (conc  *toppath* "/megatest.db"))
-         (readonly-mode      (not (file-write-access? dbfile)))
+         (mtconfig           (conc  *toppath* "/megatest.config"))
+         (readonly-mode      (not (file-write-access? mtconfig)))
 	 (test-records       (make-hash-table))
 	 ;; need to process runconfigs before generating these lists
 	 (all-tests-registry #f)  ;; (tests:get-all)) ;; (tests:get-valid-tests (make-hash-table) test-search-path)) ;; all valid tests to check waiton names
 	 (all-test-names     #f)  ;; (hash-table-keys all-tests-registry))
 	 (test-names         #f)  ;; Generated by a call to (tests:filter-test-names all-test-names test-patts))

Index: tasks.scm
==================================================================
--- tasks.scm
+++ tasks.scm
@@ -327,11 +327,11 @@
 
 ;; register a task
 (define (tasks:add dbstruct action owner target runname testpatt params)
   (db:with-db 
    dbstruct #f #t
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:execute db "INSERT INTO tasks_queue (action,owner,state,target,name,testpatt,params,creation_time,execution_time)
                              VALUES (?,?,'new',?,?,?,?,strftime('%s','now'),0);" 
 		      action
 		      owner
 		      target
@@ -362,11 +362,11 @@
 (define (tasks:snag-a-task dbstruct)
   (let ((res    #f)
 	(keytxt (conc (current-process-id) "-" (get-host-name) "-" (car (user-information (current-user-id))))))
     (db:with-db
      dbstruct #f #t
-     (lambda (db)
+     (lambda (dat db)
        ;; first randomly set a new to pid-hostname-hostname
        (sqlite3:execute
 	db 
 	"UPDATE tasks_queue SET keylock=? WHERE id IN
            (SELECT id FROM tasks_queue 
@@ -389,11 +389,11 @@
 
 (define (tasks:reset-stuck-tasks dbstruct)
   (let ((res '()))
     (db:with-db
      dbstruct #f #t
-     (lambda (db)
+     (lambda (dat db)
        (sqlite3:for-each-row
 	(lambda (id delta)
 	  (set! res (cons id res)))
 	db
 	"SELECT id,strftime('%s','now')-execution_time AS delta FROM tasks_queue WHERE state='inprogress' AND delta>700 ORDER BY delta DESC LIMIT 2;")
@@ -406,11 +406,11 @@
 ;;
 (define (tasks:get-tasks dbstruct types states)
   (let ((res '()))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row
 	(lambda (id . rem)
 	  (set! res (cons (apply vector id rem) res)))
 	db
 	(conc "SELECT id,action,owner,state,target,name,test,item,params,creation_time,execution_time 
@@ -423,11 +423,11 @@
 
 (define (tasks:get-last dbstruct target runname)
   (let ((res #f))
     (db:with-db
      dbstruct #f #f
-     (lambda (db)
+     (lambda (dbdat db)
        (sqlite3:for-each-row
 	(lambda (id . rem)
 	  (set! res (apply vector id rem)))
 	db
 	(conc "SELECT id,action,owner,state,target,name,testpatt,keylock,params,creation_time,execution_time 
@@ -440,26 +440,26 @@
 
 ;; remove tasks given by a string of numbers comma separated
 (define (tasks:remove-queue-entries dbstruct task-ids)
   (db:with-db
    dbstruct #f #t
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:execute db (conc "DELETE FROM tasks_queue WHERE id IN (" task-ids ");")))))
 
-#;(define (tasks:process-queue dbstruct)
-  (let* ((task   (tasks:snag-a-task dbstruct))
-	 (action (if task (tasks:task-get-action task) #f)))
-    (if action (print "tasks:process-queue task: " task))
-    (if action
-	(case (string->symbol action)
-	  ((run)       (tasks:start-run     dbstruct task))
-	  ((remove)    (tasks:remove-runs   dbstruct task))
-	  ((lock)      (tasks:lock-runs     dbstruct task))
-	  ;; ((monitor)   (tasks:start-monitor db task))
-	  #;((rollup)    (tasks:rollup-runs   dbstruct task))
-	  ((updatemeta)(tasks:update-meta   dbstruct task))
-	  #;((kill)      (tasks:kill-monitors dbstruct task))))))
+;; (define (tasks:process-queue dbstruct)
+;;   (let* ((task   (tasks:snag-a-task dbstruct))
+;; 	 (action (if task (tasks:task-get-action task) #f)))
+;;     (if action (print "tasks:process-queue task: " task))
+;;     (if action
+;; 	(case (string->symbol action)
+;; 	  ((run)       (tasks:start-run     dbstruct task))
+;; 	  ((remove)    (tasks:remove-runs   dbstruct task))
+;; 	  ((lock)      (tasks:lock-runs     dbstruct task))
+;; 	  ;; ((monitor)   (tasks:start-monitor db task))
+;; 	  #;((rollup)    (tasks:rollup-runs   dbstruct task))
+;; 	  ((updatemeta)(tasks:update-meta   dbstruct task))
+;; 	  #;((kill)      (tasks:kill-monitors dbstruct task))))))
 
 (define (tasks:tasks->text tasks)
   (let ((fmtstr "~10a~10a~10a~12a~20a~12a~12a~10a"))
     (conc (format #f fmtstr "id" "action" "owner" "state" "target" "runname" "testpatts" "params") "\n"
 	  (string-intersperse 
@@ -477,11 +477,11 @@
 		tasks) "\n"))))
    
 (define (tasks:set-state dbstruct task-id state)
   (db:with-db 
    dbstruct #f #t
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:execute db "UPDATE tasks_queue SET state=? WHERE id=?;" 
 		      state 
 		      task-id))))
 
 ;;======================================================================
@@ -489,27 +489,27 @@
 ;;======================================================================
 
 (define (tasks:param-key->id dbstruct task-params)
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
      (handle-exceptions
       exn
       #f
       (sqlite3:first-result db "SELECT id FROM tasks_queue WHERE params LIKE ?;"
 			    task-params)))))
 
 (define (tasks:set-state-given-param-key dbstruct param-key new-state)
   (db:with-db
    dbstruct #f #t
-   (lambda (db)
+   (lambda (dbdat db)
      (sqlite3:execute db "UPDATE tasks_queue SET state=? WHERE params LIKE ?;" new-state param-key))))
 
 (define (tasks:get-records-given-param-key dbstruct param-key state-patt action-patt test-patt)
   (db:with-db
    dbstruct #f #f
-   (lambda (db)
+   (lambda (dbdat db)
      (handle-exceptions
       exn
       '()
       (sqlite3:first-row db "SELECT id,action,owner,state,target,name,testpatt,keylock,params WHERE
                                params LIKE ? AND state LIKE ? AND action LIKE ? AND testpatt LIKE ?;"