Index: api.scm
==================================================================
--- api.scm
+++ api.scm
@@ -99,11 +99,11 @@
 ;; These are called by the server on recipt of /api calls
 ;;    - keep it simple, only return the actual result of the call, i.e. no meta info here
 ;;
 ;;    - returns #( flag result )
 ;;
-(define (api:execute-requests dbstruct dat)
+(define (api:execute-requests dbstruct area-dat dat)
   (handle-exceptions
    exn
    (let ((call-chain (get-call-chain)))
      (print-call-chain (current-error-port))
      (debug:print 0 " message: " ((condition-property-accessor 'exn 'message) exn))       
@@ -125,130 +125,130 @@
 	    ;; SERVERS
 	    ((start-server)                    (apply server:kind-run params))
 	    ((kill-server)                     (set! *server-run* #f))
 
 	    ;; TESTS
-	    ((test-set-state-status-by-id)     (apply db:test-set-state-status-by-id dbstruct params))
-	    ((delete-test-records)             (apply db:delete-test-records dbstruct params))
-	    ((delete-old-deleted-test-records) (apply db:delete-old-deleted-test-records dbstruct params))
-	    ((test-set-status-state)           (apply db:test-set-status-state dbstruct params))
-	    ((test-set-top-process-pid)        (apply db:test-set-top-process-pid dbstruct params))
-	    ((roll-up-pass-fail-counts)        (apply db:roll-up-pass-fail-counts dbstruct params))
-	    ((update-fail-pass-counts)         (apply db:general-call dbstruct 'update-pass-fail-counts params))
-	    ((test-set-archive-block-id)       (apply db:test-set-archive-block-id dbstruct params))
+	    ((test-set-state-status-by-id)     (apply db:test-set-state-status-by-id dbstruct area-dat params))
+	    ((delete-test-records)             (apply db:delete-test-records dbstruct area-dat params))
+	    ((delete-old-deleted-test-records) (apply db:delete-old-deleted-test-records dbstruct area-dat params))
+	    ((test-set-status-state)           (apply db:test-set-status-state dbstruct area-dat params))
+	    ((test-set-top-process-pid)        (apply db:test-set-top-process-pid dbstruct area-dat params))
+	    ((roll-up-pass-fail-counts)        (apply db:roll-up-pass-fail-counts dbstruct area-dat params))
+	    ((update-fail-pass-counts)         (apply db:general-call dbstruct area-dat 'update-pass-fail-counts params))
+	    ((test-set-archive-block-id)       (apply db:test-set-archive-block-id dbstruct area-dat params))
 
 	    ;; RUNS
-	    ((register-run)                 (apply db:register-run dbstruct params))
-	    ((set-tests-state-status)       (apply db:set-tests-state-status dbstruct params))
-	    ((delete-run)                   (apply db:delete-run dbstruct params))
-	    ((lock/unlock-run)              (apply db:lock/unlock-run dbstruct params))
-	    ((update-run-event_time)        (apply db:update-run-event_time dbstruct params))
+	    ((register-run)                 (apply db:register-run dbstruct area-dat params))
+	    ((set-tests-state-status)       (apply db:set-tests-state-status dbstruct area-dat params))
+	    ((delete-run)                   (apply db:delete-run dbstruct area-dat params))
+	    ((lock/unlock-run)              (apply db:lock/unlock-run dbstruct area-dat params))
+	    ((update-run-event_time)        (apply db:update-run-event_time dbstruct area-dat params))
 
 	    ;; STEPS
-	    ((teststep-set-status!)         (apply db:teststep-set-status! dbstruct params))
+	    ((teststep-set-status!)         (apply db:teststep-set-status! dbstruct area-dat params))
 
 	    ;; TEST DATA
-	    ((test-data-rollup)             (apply db:test-data-rollup dbstruct params))
-	    ((csv->test-data)               (apply db:csv->test-data dbstruct params))
+	    ((test-data-rollup)             (apply db:test-data-rollup dbstruct area-dat params))
+	    ((csv->test-data)               (apply db:csv->test-data dbstruct area-dat params))
 
 	    ;; MISC
 	    ((sync-inmem->db)               (let ((run-id (car params)))
-					      (db:sync-touched dbstruct run-id force-sync: #t)))
-	    ((mark-incomplete)              (apply db:find-and-mark-incomplete dbstruct params))
+					      (db:sync-touched dbstruct area-dat run-id force-sync: #t)))
+	    ((mark-incomplete)              (apply db:find-and-mark-incomplete dbstruct area-dat params))
 
 	    ;; TESTMETA
-	    ((testmeta-add-record)       (apply db:testmeta-add-record dbstruct params))
-	    ((testmeta-update-field)     (apply db:testmeta-update-field dbstruct params))
+	    ((testmeta-add-record)       (apply db:testmeta-add-record dbstruct area-dat params))
+	    ((testmeta-update-field)     (apply db:testmeta-update-field dbstruct area-dat params))
 
 	    ;; TASKS
-	    ((tasks-add)                 (apply tasks:add dbstruct params))   
-	    ((tasks-set-state-given-param-key) (apply tasks:set-state-given-param-key dbstruct params))
+	    ((tasks-add)                 (apply tasks:add dbstruct area-dat params))   
+	    ((tasks-set-state-given-param-key) (apply tasks:set-state-given-param-key dbstruct area-dat params))
 
 	    ;; ARCHIVES
 	    ;; ((archive-get-allocations)   
-	    ((archive-register-disk)     (apply db:archive-register-disk dbstruct params))
-	    ((archive-register-block-name)(apply db:archive-register-block-name dbstruct params))
-	    ((archive-allocate-testsuite/area-to-block)(apply db:archive-allocate-testsuite/area-to-block dbstruct block-id testsuite-name areakey))
+	    ((archive-register-disk)     (apply db:archive-register-disk dbstruct area-dat params))
+	    ((archive-register-block-name)(apply db:archive-register-block-name dbstruct area-dat params))
+	    ((archive-allocate-testsuite/area-to-block)(apply db:archive-allocate-testsuite/area-to-block dbstruct area-dat block-id testsuite-name areakey))
 
 	    ;;======================================================================
 	    ;; READ ONLY QUERIES
 	    ;;======================================================================
 
 	    ;; KEYS
-	    ((get-key-val-pairs)               (apply db:get-key-val-pairs dbstruct params))
-	    ((get-keys)                        (db:get-keys dbstruct))
+	    ((get-key-val-pairs)               (apply db:get-key-val-pairs dbstruct area-dat params))
+	    ((get-keys)                        (db:get-keys dbstruct area-dat))
 
 	    ;; ARCHIVES
-	    ((test-get-archive-block-info)     (apply db:test-get-archive-block-info dbstruct params))
+	    ((test-get-archive-block-info)     (apply db:test-get-archive-block-info dbstruct area-dat params))
 	    
 	    ;; TESTS
-	    ((test-toplevel-num-items)         (apply db:test-toplevel-num-items dbstruct params))
-	    ((get-test-info-by-id)	       (apply db:get-test-info-by-id dbstruct params))
-	    ((test-get-rundir-from-test-id)    (apply db:test-get-rundir-from-test-id dbstruct params))
-	    ((get-count-tests-running-for-testname) (apply db:get-count-tests-running-for-testname dbstruct params))
-	    ((get-count-tests-running)         (apply db:get-count-tests-running dbstruct params))
-	    ((get-count-tests-running-in-jobgroup) (apply db:get-count-tests-running-in-jobgroup dbstruct params))
-	    ;; ((delete-test-step-records)        (apply db:delete-test-step-records dbstruct params))
-	    ((get-previous-test-run-record)    (apply db:get-previous-test-run-record dbstruct params))
-	    ((get-matching-previous-test-run-records)(apply db:get-matching-previous-test-run-records dbstruct params))
-	    ((test-get-logfile-info)           (apply db:test-get-logfile-info dbstruct params))
-	    ((test-get-records-for-index-file)  (apply db:test-get-records-for-index-file dbstruct params))
-	    ((get-testinfo-state-status)       (apply db:get-testinfo-state-status dbstruct params))
-	    ((test-get-top-process-pid)        (apply db:test-get-top-process-pid dbstruct params))
-	    ((test-get-paths-matching-keynames-target-new) (apply db:test-get-paths-matching-keynames-target-new dbstruct params))
-	    ((get-prereqs-not-met)             (apply db:get-prereqs-not-met dbstruct params))
-	    ((get-count-tests-running-for-run-id) (apply db:get-count-tests-running-for-run-id dbstruct params))
-	    ((synchash-get)                    (apply synchash:server-get dbstruct params))
+	    ((test-toplevel-num-items)         (apply db:test-toplevel-num-items dbstruct area-dat params))
+	    ((get-test-info-by-id)	       (apply db:get-test-info-by-id dbstruct area-dat params))
+	    ((test-get-rundir-from-test-id)    (apply db:test-get-rundir-from-test-id dbstruct area-dat params))
+	    ((get-count-tests-running-for-testname) (apply db:get-count-tests-running-for-testname dbstruct area-dat params))
+	    ((get-count-tests-running)         (apply db:get-count-tests-running dbstruct area-dat params))
+	    ((get-count-tests-running-in-jobgroup) (apply db:get-count-tests-running-in-jobgroup dbstruct area-dat params))
+	    ;; ((delete-test-step-records)        (apply db:delete-test-step-records dbstruct area-dat params))
+	    ((get-previous-test-run-record)    (apply db:get-previous-test-run-record dbstruct area-dat params))
+	    ((get-matching-previous-test-run-records)(apply db:get-matching-previous-test-run-records dbstruct area-dat params))
+	    ((test-get-logfile-info)           (apply db:test-get-logfile-info dbstruct area-dat params))
+	    ((test-get-records-for-index-file)  (apply db:test-get-records-for-index-file dbstruct area-dat params))
+	    ((get-testinfo-state-status)       (apply db:get-testinfo-state-status dbstruct area-dat params))
+	    ((test-get-top-process-pid)        (apply db:test-get-top-process-pid dbstruct area-dat params))
+	    ((test-get-paths-matching-keynames-target-new) (apply db:test-get-paths-matching-keynames-target-new dbstruct area-dat params))
+	    ((get-prereqs-not-met)             (apply db:get-prereqs-not-met dbstruct area-dat params))
+	    ((get-count-tests-running-for-run-id) (apply db:get-count-tests-running-for-run-id dbstruct area-dat params))
+	    ((synchash-get)                    (apply synchash:server-get dbstruct area-dat params))
 
 	    ;; RUNS
-	    ((get-run-info)                 (apply db:get-run-info dbstruct params))
-	    ((get-run-status)               (apply db:get-run-status dbstruct params))
-	    ((set-run-status)               (apply db:set-run-status dbstruct params))
-	    ((get-tests-for-run)            (apply db:get-tests-for-run dbstruct params))
-	    ((get-test-id)                  (apply db:get-test-id dbstruct params))
-	    ((get-tests-for-run-mindata)    (apply db:get-tests-for-run-mindata dbstruct params))
-	    ((get-runs)                     (apply db:get-runs dbstruct params))
-	    ((get-all-run-ids)              (db:get-all-run-ids dbstruct))
-	    ((get-prev-run-ids)             (apply db:get-prev-run-ids dbstruct params))
-	    ((get-run-ids-matching-target)  (apply db:get-run-ids-matching-target dbstruct params))
-	    ((get-runs-by-patt)             (apply db:get-runs-by-patt dbstruct params))
-	    ((get-run-name-from-id)         (apply db:get-run-name-from-id dbstruct params))
+	    ((get-run-info)                 (apply db:get-run-info dbstruct area-dat params))
+	    ((get-run-status)               (apply db:get-run-status dbstruct area-dat params))
+	    ((set-run-status)               (apply db:set-run-status dbstruct area-dat params))
+	    ((get-tests-for-run)            (apply db:get-tests-for-run dbstruct area-dat params))
+	    ((get-test-id)                  (apply db:get-test-id dbstruct area-dat params))
+	    ((get-tests-for-run-mindata)    (apply db:get-tests-for-run-mindata dbstruct area-dat params))
+	    ((get-runs)                     (apply db:get-runs dbstruct area-dat params))
+	    ((get-all-run-ids)              (db:get-all-run-ids dbstruct area-dat))
+	    ((get-prev-run-ids)             (apply db:get-prev-run-ids dbstruct area-dat params))
+	    ((get-run-ids-matching-target)  (apply db:get-run-ids-matching-target dbstruct area-dat params))
+	    ((get-runs-by-patt)             (apply db:get-runs-by-patt dbstruct area-dat params))
+	    ((get-run-name-from-id)         (apply db:get-run-name-from-id dbstruct area-dat params))
 
 	    ;; STEPS
-	    ((get-steps-data)               (apply db:get-steps-data dbstruct params))
-	    ((get-steps-for-test)           (apply db:get-steps-for-test dbstruct params))
+	    ((get-steps-data)               (apply db:get-steps-data dbstruct area-dat params))
+	    ((get-steps-for-test)           (apply db:get-steps-for-test dbstruct area-dat params))
 
 	    ;; MISC
-	    ((have-incompletes?)            (apply db:have-incompletes? dbstruct params))
-	    ((login)                        (apply db:login dbstruct params))
+	    ((have-incompletes?)            (apply db:have-incompletes? dbstruct area-dat params))
+	    ((login)                        (apply db:login dbstruct area-dat params))
 	    ((general-call)                 (let ((stmtname   (car params))
 						  (run-id     (cadr params))
 						  (realparams (cddr params)))
-					      (db:with-db dbstruct run-id #t ;; these are all for modifying the db
+					      (db:with-db dbstruct area-dat run-id #t ;; these are all for modifying the db
 							  (lambda (db)
 							    (db:general-call db stmtname realparams)))))
 	    ((sdb-qry)                      (apply sdb:qry params))
 	    ((ping)                         (current-process-id))
 
 	    ;; TESTMETA
-	    ((testmeta-get-record)       (apply db:testmeta-get-record dbstruct params))
+	    ((testmeta-get-record)       (apply db:testmeta-get-record dbstruct area-dat params))
 
 	    ;; TASKS 
-	    ((find-task-queue-records)   (apply tasks:find-task-queue-records dbstruct params))))))))
+	    ((find-task-queue-records)   (apply tasks:find-task-queue-records dbstruct area-dat params))))))))
 
 
 ;; http-server  send-response
 ;;                 api:process-request
 ;;                    db:*
 ;;
 ;; NB// Runs on the server as part of the server loop
 ;;
-(define (api:process-request dbstruct $) ;; the $ is the request vars proc
+(define (api:process-request dbstruct area-dat $) ;; the $ is the request vars proc
   (let* ((cmd     ($ 'cmd))
 	 (paramsj ($ 'params))
 	 (params  (db:string->obj paramsj transport: 'http)) ;; (rmt:json-str->dat paramsj))
-	 (resdat  (api:execute-requests dbstruct (vector cmd params))) ;; #( flag result )
+	 (resdat  (api:execute-requests dbstruct area-dat (vector cmd params))) ;; #( flag result )
 	 (res     (vector-ref resdat 1)))
 
     ;; This can be here but needs controls to ensure it doesn't run more than every 4 seconds
     ;; (rmt:dat->json-str
     ;;  (if (or (string? res)

Index: client.scm
==================================================================
--- client.scm
+++ client.scm
@@ -36,13 +36,13 @@
       (let ((sig (conc (get-host-name) " " (current-process-id))))
 	(set! *my-client-signature* sig)
 	*my-client-signature*)))
 
 ;; Not currently used! But, I think it *should* be used!!!
-(define (client:logout serverdat)
+(define (client:logout serverdat area-dat)
   (let ((ok (and (socket? serverdat)
-		 (cdb:logout serverdat *toppath* (client:get-signature)))))
+		 (cdb:logout serverdat (megatest:area-path area-dat) (client:get-signature)))))
     ok))
 
 (define (client:connect iface port)
   (case (server:get-transport)
     ((rpc)  (rpc:client-connect  iface port))

Index: dashboard-guimonitor.scm
==================================================================
--- dashboard-guimonitor.scm
+++ dashboard-guimonitor.scm
@@ -31,12 +31,13 @@
 (include "common_records.scm")
 (include "db_records.scm")
 (include "run_records.scm")
 (include "task_records.scm")
 
-(define (control-panel db tdb keys)
-  (let* ((var-params (make-hash-table)) ;; register all the widgets here for querying on run, rollup, remove?
+(define (control-panel db tdb keys area-dat)
+  (let* ((toppath    (megatest:area-path area-dat))
+	 (var-params (make-hash-table)) ;; register all the widgets here for querying on run, rollup, remove?
 	 (key-params (make-hash-table))
 	 (monitordat '()) ;; list of monitor records
 	 (keyentries (iup:frame 
 		      #:title "Keys"
 		      (apply
@@ -100,12 +101,12 @@
 			#:font "Courier New, -10"
 			#:value "None..............................................."))
 	 (lastmodtime 0)
 	 (next-touch  0) ;; the last time the "last_update" field was updated
 	 (refreshdat (lambda ()
-		       (let* ((monitordbpath  (conc *toppath* "/monitor.db"))
-			      (megatestdbpath (conc *toppath* "/megatest.db"))
+		       (let* ((monitordbpath  (conc toppath "/monitor.db"))
+			      (megatestdbpath (conc toppath "/megatest.db"))
 			      (modtime        (max (file-modification-time megatestdbpath)
 						   (file-modification-time monitordbpath))))
 			 ;; do stuff here when the db is updated by some other process
 			 (if (> modtime lastmodtime)
 			     (let ((tlst (tasks:get-tasks tdb '() '()))

Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -57,19 +57,19 @@
 ;;    if #f     => get main db
 ;;    if db already open - return inmem
 ;;    if db not open, open inmem, rundb and sync then return inmem
 ;;    inuse gets set automatically for rundb's
 ;;
-(define (db:get-db dbstruct run-id)
+(define (db:get-db dbstruct area-dat run-id)
   (if (sqlite3:database? dbstruct) ;; pass sqlite3 databases on through
       dbstruct
       (begin
 	(mutex-lock! *rundb-mutex*)
 	(let ((dbdat (if (or (not run-id)
 			     (eq? run-id 0))
 			 (db:open-main dbstruct)
-			 (db:open-rundb dbstruct run-id)
+			 (db:open-rundb dbstruct area-dat run-id)
 			 )))
 	  ;; db prunning would go here
 	  (mutex-unlock! *rundb-mutex*)
 	  dbdat))))
 
@@ -85,11 +85,11 @@
 
 ;; mod-read:
 ;;     'mod   modified data
 ;;     'read  read data
 ;;
-(define (db:done-with dbstruct run-id mod-read)
+(define (db:done-with dbstruct area-dat run-id mod-read)
   (if (not (sqlite3:database? dbstruct))
       (begin
 	(mutex-lock! *rundb-mutex*)
 	(if (eq? mod-read 'mod)
 	    (dbr:dbstruct-set-mtime! dbstruct (current-milliseconds))
@@ -98,11 +98,11 @@
 	(mutex-unlock! *rundb-mutex*))))
 
 ;; (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 area-dat run-id r/w proc . params)
+(define (db:with-db dbstruct area-dat area-dat run-id r/w proc . params)
   (let* ((dbdat (if (vector? dbstruct)
 		    (db:get-db dbstruct run-id)
 		    dbstruct)) ;; cheat, allow for passing in a dbdat
 	 (db    (db:dbdat-get-db dbdat area-dat)))
     (db:delay-if-busy dbdat area-dat)
@@ -193,11 +193,11 @@
 	      (debug:print 0 "ERROR: no such db in non-writable dir " fname)
 	      (sqlite3:open-database fname))))))
 
 ;; This routine creates the db. It is only called if the db is not already opened
 ;; 
-(define (db:open-rundb dbstruct run-id #!key (attemptnum 0)(do-not-open #f)) ;;  (conc toppath "/megatest.db") (car configinfo)))
+(define (db:open-rundb dbstruct area-dat run-id #!key (attemptnum 0)(do-not-open #f)) ;;  (conc toppath "/megatest.db") (car configinfo)))
   (let* ((local  (dbr:dbstruct-get-local dbstruct))
 	 (rdb    (if local
 		     (dbr:dbstruct-get-localdb dbstruct run-id)
 		     (dbr:dbstruct-get-inmem dbstruct)))) ;; (dbr:dbstruct-get-runrec dbstruct run-id 'inmem)))
     (if (or rdb
@@ -213,11 +213,11 @@
 						     exn
 						     (begin
 						       (release-dot-lock dbpath)
 						       (if (> attemptnum 2)
 							   (debug:print 0 "ERROR: tried twice, cannot create/initialize db for run-id " run-id ", at path " dbpath)
-							   (db:open-rundb dbstruct run-id attemptnum (+ attemptnum 1))))
+							   (db:open-rundb dbstruct area-dat run-id attemptnum (+ attemptnum 1))))
 						     (db:initialize-run-id-db db)
 						     (sqlite3:execute 
 						      db
 						      "INSERT OR IGNORE INTO tests (id,run_id,testname,event_time,item_path,state,status) VALUES (?,?,'bogustest',strftime('%s','now'),'nowherepath','DELETED','n/a');"
 						      (* run-id 30000) ;; allow for up to 30k tests per run
@@ -257,11 +257,11 @@
 		;; (db:sync-tables db:sync-tests-only inmem refdb)
 		inmem))))))
 
 ;; This routine creates the db. It is only called if the db is not already ls opened
 ;;
-(define (db:open-main dbstruct) ;;  (conc toppath "/megatest.db") (car configinfo)))
+(define (db:open-main dbstruct area-dat) ;;  (conc toppath "/megatest.db") (car configinfo)))
   (let ((mdb (dbr:dbstruct-get-main dbstruct)))
     (if mdb
 	mdb
 	(let* ((dbpath       (db:dbfile-path 0))
 	       (dbexists     (file-exists? dbpath))
@@ -297,11 +297,11 @@
 	(set! *db-write-access* #f))
     (cons db dbpath)))
 
 ;; sync run to disk if touched
 ;;
-(define (db:sync-touched dbstruct run-id #!key (force-sync #f))
+(define (db:sync-touched dbstruct area-dat run-id #!key (force-sync #f))
   (let ((mtime  (dbr:dbstruct-get-mtime dbstruct))
 	(stime  (dbr:dbstruct-get-stime dbstruct))
 	(rundb  (dbr:dbstruct-get-rundb dbstruct))
 	(inmem  (dbr:dbstruct-get-inmem dbstruct))
 	(maindb (dbr:dbstruct-get-main  dbstruct))
@@ -345,34 +345,34 @@
 		num-synced)
 	      (begin
 		;; (mutex-unlock! *http-mutex*)
 		0))))))
 
-(define (db:close-main dbstruct)
+(define (db:close-main dbstruct area-dat)
   (let ((maindb (dbr:dbstruct-get-main dbstruct)))
     (if maindb
 	(begin
 	  (sqlite3:finalize! (db:dbdat-get-db maindb))
 	  (dbr:dbstruct-set-main! dbstruct #f)))))
 
-(define (db:close-run-db dbstruct run-id)
+(define (db:close-run-db dbstruct area-dat run-id)
   (let ((rdb (db:open-rundb dbstruct run-id do-not-open: #t)))
     (if (and rdb
 	     (sqlite3:database? rdb))
 	(begin
 	  (sqlite3:finalize! rdb)
 	  (dbr:dbstruct-set-localdb! dbstruct run-id #f)
 	  (dbr:dbstruct-set-inmem! dbstruct #f)))))
 
 ;; close all opened run-id dbs
-(define (db:close-all dbstruct)
+(define (db:close-all dbstruct area-dat)
   ;; finalize main.db
-  (db:sync-touched dbstruct 0 force-sync: #t)
+  (db:sync-touched dbstruct area-dat 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?
 
-  (db:close-main dbstruct)
+  (db:close-main dbstruct area-dat)
   
   (let ((locdbs (dbr:dbstruct-get-locdbs dbstruct)))
     (if (hash-table? locdbs)
 	(for-each (lambda (run-id)
 		    (db:close-run-db dbstruct run-id))
@@ -673,11 +673,11 @@
 
     ;; sync runs, test_meta etc.
     ;;
     (if (member 'old2new options)
 	(begin
-	  (db:sync-tables area-dat (db:sync-main-list mtdb) mtdb (db:get-db dbstruct #f))
+	  (db:sync-tables area-dat (db:sync-main-list mtdb) mtdb (db:get-db dbstruct area-dat #f))
 	  (for-each 
 	   (lambda (run-id)
 	     (db:delay-if-busy mtdb area-dat)
 	     (let ((testrecs (db:get-all-tests-info-by-run-id mtdb run-id))
 		   (dbstruct (if toppath (make-dbr:dbstruct path: toppath local: #t) #f)))
@@ -705,11 +705,11 @@
 	       ;; (db:delay-if-busy frundb)
 	       ;; (db:delay-if-busy mtdb)
 	       ;; (db:clean-up frundb)
 	       (if (eq? run-id 0)
 		   (begin
-		     (db:sync-tables area-dat (db:sync-main-list dbstruct) (db:get-db fromdb #f) mtdb)
+		     (db:sync-tables area-dat (db:sync-main-list dbstruct area-dat) (db:get-db fromdb #f) mtdb)
 		     (set! dead-runs (db:clean-up-maindb (db:get-db fromdb #f))))
 		   (begin
 		     ;; NB// must sync first to ensure deleted tests get marked as such in megatest.db
 		     (db:sync-tables area-dat db:sync-tests-only (db:get-db fromdb run-id) mtdb)
 		     (db:clean-up-rundb (db:get-db fromdb run-id))
@@ -957,12 +957,12 @@
 
 ;; dneeded is minimum space needed, scan for existing archives that 
 ;; are on disks with adequate space and already have this test/itempath
 ;; archived
 ;;
-(define (db:archive-get-allocations dbstruct testname itempath dneeded)
-  (let* ((dbdat        (db:get-db dbstruct #f)) ;; archive tables are in main.db
+(define (db:archive-get-allocations dbstruct area-dat testname itempath dneeded)
+  (let* ((dbdat        (db:get-db dbstruct area-dat #f)) ;; archive tables are in main.db
 	 (db           (db:dbdat-get-db dbdat))
 	 (res          '())
 	 (blocks       '())) ;; a block is an archive chunck that can be added too if there is space
     (sqlite3:for-each-row
      (lambda (id archive-disk-id disk-path last-du last-du-time)
@@ -988,12 +988,12 @@
     blocks))
     
 ;; returns id of the record, register a disk allocated to archiving and record it's last known
 ;; available space
 ;;
-(define (db:archive-register-disk dbstruct bdisk-name bdisk-path df)
-  (let* ((dbdat        (db:get-db dbstruct #f)) ;; archive tables are in main.db
+(define (db:archive-register-disk dbstruct area-dat bdisk-name bdisk-path df)
+  (let* ((dbdat        (db:get-db dbstruct area-dat #f)) ;; archive tables are in main.db
 	 (db           (db:dbdat-get-db dbdat))
 	 (res          #f))
     (sqlite3:for-each-row
      (lambda (id)
        (set! res id))
@@ -1010,18 +1010,18 @@
 	  (sqlite3:execute
 	   db
 	   "INSERT OR REPLACE INTO archive_disks (archive_area_name,disk_path,last_df)
                 VALUES (?,?,?);"
 	   bdisk-name bdisk-path df)
-	  (db:archive-register-disk dbstruct bdisk-name bdisk-path df)))))
+	  (db:archive-register-disk dbstruct area-dat bdisk-name bdisk-path df)))))
 
 ;; record an archive path created on a given archive disk (identified by it's bdisk-id)
 ;; if path starts with / then it is full, otherwise it is relative to the archive disk
 ;; preference is to store the relative path.
 ;;
-(define (db:archive-register-block-name dbstruct bdisk-id archive-path #!key (du #f))
-  (let* ((dbdat        (db:get-db dbstruct #f)) ;; archive tables are in main.db
+(define (db:archive-register-block-name dbstruct area-dat bdisk-id archive-path #!key (du #f))
+  (let* ((dbdat        (db:get-db dbstruct area-dat #f)) ;; archive tables are in main.db
 	 (db           (db:dbdat-get-db dbdat))
 	 (res          #f))
     ;; first look to see if this path is already registered
     (sqlite3:for-each-row
      (lambda (id)
@@ -1037,29 +1037,30 @@
 	  res)
 	(begin
 	  (sqlite3:execute db "INSERT OR REPLACE INTO archive_blocks (archive_disk_id,disk_path,last_du)
                                                         VALUES (?,?,?);"
 			   bdisk-id archive-path (or du 0))
-	  (db:archive-register-block-name dbstruct bdisk-id archive-path du: du)))))
+	  (db:archive-register-block-name dbstruct area-dat bdisk-id archive-path du: du)))))
 
 
 ;; The "archived" field in tests is overloaded; 0 = not archived, > 0 archived in block with given id
 ;;
-(define (db:test-set-archive-block-id dbstruct run-id test-id archive-block-id)
+(define (db:test-set-archive-block-id dbstruct area-dat run-id area-dat test-id archive-block-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
+   area-dat
    #f
    (lambda (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
 ;;
-(define (db:test-get-archive-block-info dbstruct archive-block-id)
+(define (db:test-get-archive-block-info dbstruct area-dat archive-block-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    #f
    #f
    (lambda (db)
      (let ((res #f))
        (sqlite3:for-each-row 
@@ -1118,12 +1119,12 @@
 
 ;;======================================================================
 ;; M A I N T E N A N C E
 ;;======================================================================
 
-(define (db:have-incompletes? dbstruct run-id ovr-deadtime area-dat)
-  (let* ((dbdat        (db:get-db dbstruct run-id))
+(define (db:have-incompletes? dbstruct area-dat run-id ovr-deadtime area-dat)
+  (let* ((dbdat        (db:get-db dbstruct area-dat run-id))
 	 (db           (db:dbdat-get-db dbdat))
 	 (incompleted '())
 	 (oldlaunched '())
 	 (toplevels   '())
 	 (deadtime-str (configf:lookup (megatest:area-configdat area-dat) "setup" "deadtime"))
@@ -1177,12 +1178,12 @@
 ;;  select end_time-now from
 ;;      (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 area-dat)
-  (let* ((dbdat        (db:get-db dbstruct run-id))
+(define (db:find-and-mark-incomplete dbstruct area-dat run-id ovr-deadtime area-dat)
+  (let* ((dbdat        (db:get-db dbstruct area-dat run-id))
 	 (db           (db:dbdat-get-db dbdat))
 	 (incompleted '())
 	 (oldlaunched '())
 	 (toplevels   '())
 	 (deadtime-str (configf:lookup (megatest:area-configdat area-dat) "setup" "deadtime"))
@@ -1402,16 +1403,16 @@
 ;; returns number if string->number is successful, string otherwise
 ;; also updates *global-delta*
 ;;
 ;; Operates on megatestdb
 ;;
-(define (db:get-var dbstruct var area-dat)
+(define (db:get-var dbstruct area-dat var area-dat)
   (let* ((start-ms (current-milliseconds))
          (throttle (let ((t  (config-lookup (megatest:area-configdat area-dat) "setup" "throttle")))
 		     (if t (string->number t) t)))
 	 (res      #f)
-	 (dbdat    (db:get-db dbstruct #f))
+	 (dbdat    (db:get-db dbstruct area-dat #f))
 	 (db       (db:dbdat-get-db dbdat)))
     (db:delay-if-busy dbdat area-dat)
     (sqlite3:for-each-row
      (lambda (val)
        (set! res val))
@@ -1429,19 +1430,19 @@
 	(begin
 	  (debug:print-info 4 "launch throttle factor=" *global-delta*)
 	  (set! *last-global-delta-printed* *global-delta*)))
     res))
 
-(define (db:set-var dbstruct var val)
-  (let ((dbdat (db:get-db dbstruct #f))
+(define (db:set-var dbstruct area-dat var val)
+  (let ((dbdat (db:get-db dbstruct area-dat #f))
 	(db    (db:dbdat-get-db dbdat)))
     (db:delay-if-busy dbdat area-dat)
     (sqlite3:execute db "INSERT OR REPLACE INTO metadat (var,val) VALUES (?,?);" var val)))
 
-(define (db:del-var dbstruct var)
+(define (db:del-var dbstruct area-dat var)
   ;; (db:delay-if-busy)
-  (db:with-db dbstruct #f #t 
+  (db:with-db dbstruct area-dat #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
@@ -1448,13 +1449,13 @@
 ;; change
 
 ;; why get the keys from the db? why not get from the configdat
 ;; using keys:config-get-fields?
 
-(define (db:get-keys dbstruct)
+(define (db:get-keys dbstruct area-dat)
   (let ((res '()))
-    (db:with-db dbstruct #f #f
+    (db:with-db dbstruct area-dat #f #f
 		(lambda (db)
 		  (sqlite3:for-each-row 
 		   (lambda (key)
 		     (set! res (cons key res)))
 		   db
@@ -1478,13 +1479,13 @@
 
 ;;======================================================================
 ;;  R U N S
 ;;======================================================================
 
-(define (db:get-run-name-from-id dbstruct run-id)
+(define (db:get-run-name-from-id dbstruct area-dat run-id)
   (db:with-db 
-   dbstruct
+   dbstruct area-dat
    #f ;; this is for the main runs db
    #f ;; does not modify db
    (lambda (db)
      (let ((res #f))
        (sqlite3:for-each-row
@@ -1493,13 +1494,13 @@
 	db
 	"SELECT runname FROM runs WHERE id=?;"
 	run-id)
        res))))
 
-(define (db:get-run-key-val dbstruct run-id key)
+(define (db:get-run-key-val dbstruct area-dat run-id key)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    #f
    #f
    (lambda (db)
      (let ((res #f))
        (sqlite3:for-each-row
@@ -1532,12 +1533,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* ((dbdat     (db:get-db dbstruct #f))
+(define (db:register-run dbstruct area-dat keyvals runname state status user)
+  (let* ((dbdat     (db:get-db dbstruct area-dat #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 " ""))
@@ -1571,13 +1572,13 @@
 ;; replace header and keystr with a call to runs:get-std-run-fields
 ;;
 ;; keypatts: ( (KEY1 "abc%def")(KEY2 "%") )
 ;; runpatts: patt1,patt2 ...
 ;;
-(define (db:get-runs dbstruct runpatt count offset keypatts)
+(define (db:get-runs dbstruct area-dat runpatt count offset keypatts)
   (let* ((res       '())
-	 (keys       (db:get-keys dbstruct))
+	 (keys       (db:get-keys dbstruct area-dat))
 	 (runpattstr (db:patt->like "runname" runpatt))
 	 (remfields  (list "id" "runname" "state" "status" "owner" "event_time"))
 	 (header     (append keys remfields))
 	 (keystr     (conc (keys->keystr keys) ","
 			   (string-intersperse remfields ",")))
@@ -1598,11 +1599,11 @@
 			       "")
 			   (if (number? offset)
 			       (conc " OFFSET " offset)
 			       ""))))
     (debug:print-info 11 "db:get-runs START qrystr: " qrystr " keypatts: " keypatts " offset: " offset " limit: " count)
-    (db:with-db dbstruct #f #f
+    (db:with-db dbstruct area-dat #f #f
 		(lambda (db)		
 		  (sqlite3:for-each-row
 		   (lambda (a . x)
 		     (set! res (cons (apply vector a x) res)))
 		   db
@@ -1618,11 +1619,11 @@
 ;; Use: (db:get-value-by-header (db:get-header runinfo)(db:get-rows runinfo))
 ;;  to extract info from the structure returned
 ;;
 ;; NOTE: THIS IS COMPLETELY UNFINISHED. IT GOES WITH rmt:get-get-paths-matching-keynames
 ;;
-(define (db:get-run-ids-matching dbstruct keynames target res)
+(define (db:get-run-ids-matching dbstruct area-dat keynames target res)
 ;; (define (db:get-runs-by-patt dbstruct keys runnamepatt targpatt offset limit) ;; test-name)
   (let* ((tmp      (runs:get-std-run-fields keys '("id" "runname" "state" "status" "owner" "event_time")))
 	 (keystr   (car tmp))
 	 (header   (cadr tmp))
 	 (res     '())
@@ -1644,31 +1645,31 @@
     (set! qry-str (conc "SELECT " keystr " FROM runs WHERE state != 'deleted' AND runname " runwildtype " ? " key-patt " ORDER BY event_time "
 			(if limit  (conc " LIMIT " limit)   "")
 			(if offset (conc " OFFSET " offset) "")
 			";"))
     (debug:print-info 4 "runs:get-runs-by-patt qry=" qry-str " " runnamepatt)
-    (db:with-db dbstruct #f #f ;; reads db, does not write to it.
+    (db:with-db dbstruct area-dat #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:get-db dbstruct area-dat #f)
 		   qry-str
 		   runnamepatt)))
     (vector header res)))
 
 ;; Get all targets from the db
 ;;
-(define (db:get-targets dbstruct)
+(define (db:get-targets dbstruct area-dat)
   (let* ((res       '())
-	 (keys       (db:get-keys dbstruct))
+	 (keys       (db:get-keys dbstruct area-dat))
 	 (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:with-db
-     dbstruct
+     dbstruct area-dat
      #f
      #f
      (lambda (db)
        (sqlite3:for-each-row
 	(lambda (a . x)
@@ -1681,13 +1682,13 @@
 	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)
+(define (db:get-num-runs dbstruct area-dat runpatt)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    #f
    #f
    (lambda (db)
      (let ((numruns 0))
        (debug:print-info 11 "db:get-num-runs START " runpatt)
@@ -1697,13 +1698,13 @@
 	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)
+(define (db:get-all-run-ids dbstruct area-dat)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    #f
    #f
    (lambda (db)
      (let ((run-ids '()))
        (sqlite3:for-each-row
@@ -1715,12 +1716,12 @@
 
 ;; get some basic run stats
 ;;
 ;; ( (runname (( state  count ) ... ))
 ;;   (   ...  
-(define (db:get-run-stats dbstruct)
-  (let* ((dbdat        (db:get-db dbstruct #f))
+(define (db:get-run-stats dbstruct area-dat)
+  (let* ((dbdat        (db:get-db dbstruct area-dat #f))
 	 (db           (db:dbdat-get-db dbdat))
 	 (totals       (make-hash-table))
 	 (curr         (make-hash-table))
 	 (res          '())
 	 (runs-info    '()))
@@ -1736,11 +1737,11 @@
      (lambda (run-info)
        ;; get the net state/status counts for this run
        (let* ((run-id   (car  run-info))
 	      (run-name (cadr run-info)))
 	 (db:with-db
-	  dbstruct
+	  dbstruct area-dat
 	  run-id
 	  #f
 	  (lambda (db)
 	    (sqlite3:for-each-row
 	     (lambda (state status count)
@@ -1767,11 +1768,11 @@
 ;; register a test run with the db
 ;;
 ;; Use: (db:get-value-by-header (db:get-header runinfo)(db:get-rows runinfo))
 ;;  to extract info from the structure returned
 ;;
-(define (db:get-runs-by-patt dbstruct keys runnamepatt targpatt offset limit) ;; test-name)
+(define (db:get-runs-by-patt dbstruct area-dat keys runnamepatt targpatt offset limit) ;; test-name)
   (let* ((tmp      (runs:get-std-run-fields keys '("id" "runname" "state" "status" "owner" "event_time")))
 	 (keystr   (car tmp))
 	 (header   (cadr tmp))
 	 (res     '())
 	 (key-patt "")
@@ -1792,11 +1793,11 @@
     (set! qry-str (conc "SELECT " keystr " FROM runs WHERE state != 'deleted' AND runname " runwildtype " ? " key-patt " ORDER BY event_time "
 			(if limit  (conc " LIMIT " limit)   "")
 			(if offset (conc " OFFSET " offset) "")
 			";"))
     (debug:print-info 4 "runs:get-runs-by-patt qry=" qry-str " " runnamepatt)
-    (db:with-db dbstruct #f #f ;; reads db, does not write to it.
+    (db:with-db dbstruct area-dat #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
@@ -1803,17 +1804,17 @@
 		   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)
+(define (db:get-run-info dbstruct area-dat run-id)
   ;;(if (hash-table-ref/default *run-info-cache* run-id #f)
   ;;    (hash-table-ref *run-info-cache* run-id)
-  (let* ((dbdat     (db:get-db dbstruct #f))
+  (let* ((dbdat     (db:get-db dbstruct area-dat #f))
 	 (db        (db:dbdat-get-db dbdat))
 	 (res       (vector #f #f #f #f))
-	 (keys      (db:get-keys dbstruct))
+	 (keys      (db:get-keys dbstruct area-dat))
 	 (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)
@@ -1827,44 +1828,44 @@
     (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)
+(define (db:set-comment-for-run dbstruct area-dat run-id comment)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    #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)
+(define (db:delete-run dbstruct area-dat run-id)
   ;; First set any related tests to DELETED
-  (let* ((rdbdat (db:get-db dbstruct run-id))
+  (let* ((rdbdat (db:get-db dbstruct area-dat run-id))
 	 (rdb    (db:dbdat-get-db rdbdat))
-	 (dbdat  (db:get-db dbstruct #f))
+	 (dbdat  (db:get-db dbstruct area-dat #f))
 	 (db     (db:dbdat-get-db dbdat)))
     (db:delay-if-busy rdbdat area-dat)
     (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 area-dat)
     (sqlite3:execute db "UPDATE runs SET state='deleted',comment='' WHERE id=?;" run-id)))
 
-(define (db:update-run-event_time dbstruct run-id)
+(define (db:update-run-event_time dbstruct area-dat run-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    #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)
+(define (db:lock/unlock-run dbstruct area-dat run-id lock unlock user)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    #f
    #t
    (lambda (db)
      (let ((newlockval (if lock "locked"
 			   (if unlock
@@ -1873,22 +1874,22 @@
        (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* ((dbdat (db:get-db dbstruct #f))
+(define (db:set-run-status dbstruct area-dat run-id status msg)
+  (let* ((dbdat (db:get-db dbstruct area-dat #f))
 	 (db    (db:dbdat-get-db dbdat)))
     (db:delay-if-busy dbdat area-dat)
     (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)
+(define (db:get-run-status dbstruct area-dat run-id)
   (let ((res "n/a"))
     (db:with-db
-     dbstruct
+     dbstruct area-dat
      #f
      #f
      (lambda (db)
        (sqlite3:for-each-row 
 	(lambda (status)
@@ -1902,14 +1903,14 @@
 ;; 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))
+(define (db:get-key-val-pairs dbstruct area-dat run-id)
+  (let* ((keys (db:get-keys dbstruct area-dat))
 	 (res  '())
-	 (dbdat  (db:get-db dbstruct #f))
+	 (dbdat  (db:get-db dbstruct area-dat #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 area-dat)
@@ -1919,14 +1920,14 @@
 	  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))
+(define (db:get-key-vals dbstruct area-dat run-id)
+  (let* ((keys (db:get-keys dbstruct area-dat))
 	 (res  '())
-	 (dbdat  (db:get-db dbstruct #f))
+	 (dbdat  (db:get-db dbstruct area-dat #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 area-dat)
@@ -1938,24 +1939,24 @@
     (let ((final-res (reverse res)))
       (hash-table-set! *keyvals* run-id final-res)
       final-res)))
 
 ;; The target is keyval1/keyval2..., cached in *target* as it is used often
-(define (db:get-target dbstruct run-id)
-  (let* ((keyvals (db:get-key-vals dbstruct run-id))
+(define (db:get-target dbstruct area-dat run-id)
+  (let* ((keyvals (db:get-key-vals dbstruct area-dat run-id))
 	 (thekey  (string-intersperse (map (lambda (x)(if x x "-na-")) keyvals) "/")))
     thekey))
 
 ;; Get run-ids for runs with same target but different runnames and NOT run-id
 ;;
-(define (db:get-prev-run-ids dbstruct run-id)
+(define (db:get-prev-run-ids dbstruct area-dat run-id)
   (let* ((keyvals (rmt:get-key-val-pairs run-id))
 	 (kvalues (map cadr keyvals))
 	 (keys    (rmt:get-keys))
 	 (qrystr  (string-intersperse (map (lambda (x)(conc x "=?")) keys) " AND ")))
     (let ((prev-run-ids '()))
-      (db:with-db dbstruct #f #f ;; #f means work with the zeroth db - i.e. the runs db
+      (db:with-db dbstruct area-dat #f #f ;; #f means work with the zeroth db - i.e. the runs db
        (lambda (db)
 	 (apply sqlite3:for-each-row
 		(lambda (id)
 		  (set! prev-run-ids (cons id prev-run-ids)))
 		db
@@ -1968,11 +1969,11 @@
 
 ;; states and statuses are lists, turn them into ("PASS","FAIL"...) and use NOT IN
 ;; i.e. these lists define what to NOT show.
 ;; states and statuses are required to be lists, empty is ok
 ;; not-in #t = above behaviour, #f = must match
-(define (db:get-tests-for-run dbstruct run-id testpatt states statuses offset limit not-in sort-by sort-order qryvals)
+(define (db:get-tests-for-run dbstruct area-dat run-id testpatt states statuses offset limit not-in sort-by sort-order qryvals)
   (if (not (number? run-id))
       (begin ;; no need to treat this as an error by default
 	(debug:print 4 "WARNING: call to db:get-tests-for-run with bad run-id=" run-id)
 	;; (print-call-chain (current-error-port))
 	'())
@@ -2024,11 +2025,11 @@
 				    (if limit  (conc " LIMIT " limit)   " ")
 				    (if offset (conc " OFFSET " offset) " ")
 				    ";"
 				    )))
 	(debug:print-info 8 "db:get-tests-for-run run-id=" run-id ", qry=" qry)
-	(db:with-db dbstruct run-id #f
+	(db:with-db dbstruct area-dat run-id #f
 		    (lambda (db)
 		      (sqlite3:for-each-row 
 		       (lambda (a . b) ;; id run-id testname state status event-time host cpuload diskfree uname rundir item-path run-duration final-logf comment)
 			 (set! res (cons (apply vector a b) res))) ;; id run-id testname state status event-time host cpuload diskfree uname rundir item-path run-duration final-logf comment) res)))
 		       db
@@ -2051,17 +2052,17 @@
 	  -1 "" -1 -1 "" "-" 
 	  (vector-ref inrec 3) ;; item-path
 	  -1 "-" "-"))
 
 
-(define (db:get-tests-for-run-state-status dbstruct run-id testpatt)
+(define (db:get-tests-for-run-state-status dbstruct area-dat run-id testpatt)
   (let* ((res            '())
 	 (tests-match-qry (tests:match->sqlqry testpatt))
 	 (qry             (conc "SELECT id,testname,item_path,state,status FROM tests WHERE run_id=? " 
 				(if tests-match-qry (conc " AND (" tests-match-qry ") ") ""))))
     (debug:print-info 8 "db:get-tests-for-run qry=" qry)
-    (db:with-db dbstruct run-id #f
+    (db:with-db dbstruct area-dat run-id #f
 		(lambda (db)
 		  (sqlite3:for-each-row
 		   (lambda (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 (cons (vector id run-id testname state status -1         ""     -1      -1       ""    "-"  item-path -1           "-"         "-") res)))
@@ -2068,13 +2069,13 @@
 		   db 
 		   qry
 		   run-id)))
     res))
 
-(define (db:get-testinfo-state-status dbstruct run-id test-id)
+(define (db:get-testinfo-state-status dbstruct area-dat run-id test-id)
   (let ((res            #f))
-    (db:with-db dbstruct run-id #f
+    (db:with-db dbstruct area-dat run-id #f
 		(lambda (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 "-" "-")))
@@ -2084,53 +2085,53 @@
     res))
 
 ;; get a useful subset of the tests data (used in dashboard
 ;; use db:mintests-get-{id ,run_id,testname ...}
 ;; 
-(define (db:get-tests-for-runs-mindata dbstruct run-ids testpatt states statuses not-in)
+(define (db:get-tests-for-runs-mindata dbstruct area-dat run-ids testpatt states statuses not-in)
   (debug:print 0 "ERROR: BROKN!")
   ;; (db:get-tests-for-runs dbstruct run-ids testpatt states statuses not-in: not-in qryvals: "id,run_id,testname,state,status,event_time,item_path"))
 )
 
 ;; get a useful subset of the tests data (used in dashboard
 ;;
-(define (db:get-tests-for-run-mindata dbstruct run-id testpatt states statuses not-in)
-  (db:get-tests-for-run dbstruct run-id testpatt states statuses #f #f not-in #f #f "id,run_id,testname,state,status,event_time,item_path"))
+(define (db:get-tests-for-run-mindata dbstruct area-dat run-id testpatt states statuses not-in)
+  (db:get-tests-for-run dbstruct area-dat run-id testpatt states statuses #f #f not-in #f #f "id,run_id,testname,state,status,event_time,item_path"))
 
 ;; do not use.
 ;;
-(define (db:get-tests-for-runs dbstruct run-ids testpatt states statuses #!key (not-in #f)(qryvals #f))
+(define (db:get-tests-for-runs dbstruct area-dat run-ids testpatt states statuses #!key (not-in #f)(qryvals #f))
   ;; (db:delay-if-busy)
   (let ((res '()))
     (for-each 
      (lambda (run-id)
        (set! res (append 
 		  res 
-		  (db:get-tests-for-run dbstruct run-id testpatt states statuses #f #f not-in #f #f qryvals))))
+		  (db:get-tests-for-run dbstruct area-dat run-id testpatt states statuses #f #f not-in #f #f qryvals))))
      (if run-ids
 	 run-ids
-	 (db:get-all-run-ids dbstruct)))
+	 (db:get-all-run-ids dbstruct area-dat)))
     res))
 
 ;; Convert calling routines to get list of run-ids and loop, do not use the get-tests-for-runs
 ;;
 
-(define (db:delete-test-records dbstruct run-id test-id)
-  (let* ((dbdat (db:get-db dbstruct run-id))
+(define (db:delete-test-records dbstruct area-dat run-id test-id)
+  (let* ((dbdat (db:get-db dbstruct area-dat run-id))
 	 (db    (db:dbdat-get-db dbdat)))
     (db:general-call dbdat 'delete-test-step-records (list test-id))
     ;; (db:delay-if-busy)
     (db:general-call dbdat 'delete-test-data-records (list test-id))
     (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 ((run-ids  (db:get-all-run-ids dbstruct))
+(define (db:delete-old-deleted-test-records dbstruct area-dat)
+  (let ((run-ids  (db:get-all-run-ids dbstruct area-dat))
 	(targtime (- (current-seconds)(* 30 24 60 60)))) ;; one month in the past
     (for-each
      (lambda (run-id)
        (db:with-db
-	dbstruct
+	dbstruct area-dat
 	run-id
 	#t
 	(lambda (db)
 	  (sqlite3:execute db "DELETE FROM tests WHERE state='DELETED' AND event_time<?;" targtime))))
      run-ids)))
@@ -2141,30 +2142,30 @@
 ;;
 		;;  AND NOT (item_path='' AND testname in (SELECT DISTINCT testname FROM tests WHERE testname=? AND item_path != ''));")))
 		;;(debug:print 0 "QRY: " qry)
 		;; (db:delay-if-busy)
 
-(define (db:set-tests-state-status dbstruct run-id testnames currstate currstatus newstate newstatus)
+(define (db:set-tests-state-status dbstruct area-dat run-id testnames currstate currstatus newstate newstatus)
   (for-each (lambda (testname)
 	      (let ((qry (conc "UPDATE tests SET state=?,status=? WHERE "
 			       (if currstate  (conc "state='" currstate "' AND ") "")
 			       (if currstatus (conc "status='" currstatus "' AND ") "")
 			       " run_id=? AND testname LIKE ?;")))
 		(db:with-db
-		 dbstruct
+		 dbstruct area-dat
 		 run-id
 		 #t
 		 (lambda (db)
 		   (sqlite3:execute db qry newstate newstatus run-id testname)))))
 	    testnames))
 
 ;; speed up for common cases with a little logic
 ;; NB// Ultimately this will be deprecated in deference to mt:test-set-state-status-by-id
 ;;
-(define (db:test-set-state-status-by-id dbstruct run-id test-id newstate newstatus newcomment)
+(define (db:test-set-state-status-by-id dbstruct area-dat run-id test-id newstate newstatus newcomment)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #t
    (lambda (db)
      (cond
       ((and newstate newstatus newcomment)
@@ -2179,13 +2180,13 @@
 				       test-id))))
      (mt:process-triggers run-id test-id newstate newstatus))))
 
 ;; NEW BEHAVIOR: Count tests running in only one run!
 ;;
-(define (db:get-count-tests-running dbstruct run-id)
+(define (db:get-count-tests-running dbstruct area-dat run-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (sqlite3:first-result 
       db
@@ -2195,13 +2196,13 @@
       ;; "SELECT count(id) FROM tests WHERE state in ('RUNNING','LAUNCHED','REMOTEHOSTSTART') AND run_id=?;" 
       ))))
 
 ;; NEW BEHAVIOR: Count tests running in only one run!
 ;;
-(define (db:get-count-tests-actually-running dbstruct run-id)
+(define (db:get-count-tests-actually-running dbstruct area-dat run-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (sqlite3:first-result
       db
@@ -2211,13 +2212,13 @@
       run-id)))) ;; NOT IN (SELECT id FROM runs WHERE state='deleted');")
 
 ;; NEW BEHAVIOR: Look only at single run with run-id
 ;; 
 ;; (define (db:get-running-stats dbstruct run-id)
-(define (db:get-count-tests-running-for-run-id dbstruct run-id)
+(define (db:get-count-tests-running-for-run-id dbstruct area-dat run-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (sqlite3:first-result
       db
@@ -2224,22 +2225,22 @@
       "SELECT count(id) FROM tests WHERE state in ('RUNNING','LAUNCHED','REMOTEHOSTSTART') AND run_id=? AND NOT (uname = 'n/a' AND item_path = '');" run-id))))
 
 ;; For a given testname how many items are running? Used to determine
 ;; probability for regenerating html
 ;; 
-(define (db:get-count-tests-running-for-testname dbstruct run-id testname)
+(define (db:get-count-tests-running-for-testname dbstruct area-dat run-id testname)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (sqlite3:first-result
       db
       "SELECT count(id) FROM tests WHERE state in ('RUNNING','LAUNCHED','REMOTEHOSTSTART') AND run_id=? AND NOT (uname = 'n/a' AND item_path = '') AND testname=?;" run-id testname))))
 
-(define (db:get-count-tests-running-in-jobgroup dbstruct run-id jobgroup)
-  (let* ((dbdat (db:get-db dbstruct #f))
+(define (db:get-count-tests-running-in-jobgroup dbstruct area-dat run-id jobgroup)
+  (let* ((dbdat (db:get-db dbstruct area-dat #f))
 	 (db    (db:dbdat-get-db dbdat)))
   (if (not jobgroup)
       0 ;; 
       (let ((testnames '()))
 	;; get the testnames
@@ -2251,11 +2252,11 @@
 	 "SELECT testname FROM test_meta WHERE jobgroup=?"
 	 jobgroup)
 	;; get the jobcount NB// EXTEND THIS TO OPPERATE OVER ALL RUNS?
 	(if (not (null? testnames))
 	    (db:with-db
-	     dbstruct
+	     dbstruct area-dat
 	     run-id
 	     #f
 	     (lambda (db)
 	       (sqlite3:first-result
 		db
@@ -2267,24 +2268,24 @@
              ;; AND testname in (SELECT testname FROM test_meta WHERE jobgroup=?)
              ;; AND NOT (uname = 'n/a' AND item_path = '');"
 
 ;; done with run when:
 ;;   0 tests in LAUNCHED, NOT_STARTED, REMOTEHOSTSTART, RUNNING
-(define (db:estimated-tests-remaining dbstruct run-id)
+(define (db:estimated-tests-remaining dbstruct area-dat run-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (sqlite3:first-result
       db
       "SELECT count(id) FROM tests WHERE state in ('LAUNCHED','NOT_STARTED','REMOTEHOSTSTART','RUNNING','KILLREQ');"))))
 
 ;; map run-id, testname item-path to test-id
-(define (db:get-test-id dbstruct run-id testname item-path)
+(define (db:get-test-id dbstruct area-dat run-id testname item-path)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (db:first-result-default
       db
@@ -2293,22 +2294,22 @@
       testname item-path))))
 
 ;; overload the unused attemptnum field for the process id of the runscript or 
 ;; ezsteps step script in progress
 ;;
-(define (db:test-set-top-process-pid dbstruct run-id test-id pid)
+(define (db:test-set-top-process-pid dbstruct area-dat run-id test-id pid)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (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)
+(define (db:test-get-top-process-pid dbstruct area-dat run-id test-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (db:first-result-default 
       db
@@ -2337,13 +2338,13 @@
 (define db:test-record-qry-selector (string-intersperse db:test-record-fields ","))
 
 
 ;; 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)
+(define (db:get-all-tests-info-by-run-id dbstruct area-dat run-id)
   (let* ((dbdat (if (vector? dbstruct)
-		    (db:get-db dbstruct run-id)
+		    (db:get-db dbstruct area-dat run-id)
 		    dbstruct)) ;; still settling on when to use dbstruct or dbdat
 	 (db    (db:dbdat-get-db dbdat))
 	 (res '()))
     (db:delay-if-busy dbdat area-dat)
     (sqlite3:for-each-row
@@ -2354,12 +2355,12 @@
      db
      (conc "SELECT " db:test-record-qry-selector " FROM tests WHERE state != 'DELETED' AND run_id=?;")
      run-id)
     res))
 
-(define (db:replace-test-records dbstruct run-id testrecs)
-  (db:with-db dbstruct run-id #t 
+(define (db:replace-test-records dbstruct area-dat run-id testrecs)
+  (db:with-db dbstruct area-dat run-id #t 
 	      (lambda (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 ");"))
 		       (qry    (sqlite3:prepare db qrystr)))
 		  (debug:print 0 "INFO: migrating test records for run with id " run-id)
@@ -2414,13 +2415,13 @@
        (let ((testrecs (db:get-all-tests-info-by-run-id mtdb run-id)))
 	 (db:prep-megatest.db-adj-test-ids (db:dbdat-get-db mtdb) run-id testrecs)))
      run-ids)))
 
 ;; Get test data using test_id
-(define (db:get-test-info-by-id dbstruct run-id test-id)
+(define (db:get-test-info-by-id dbstruct area-dat run-id test-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (let ((res #f))
        (sqlite3:for-each-row ;; attemptnum added to hold pid of top process (not Megatest) controlling a test
@@ -2433,13 +2434,13 @@
        res))))
 
 ;; Use db:test-get* to access
 ;; Get test data using test_ids. NB// Only works within a single run!!
 ;;
-(define (db:get-test-info-by-ids dbstruct run-id test-ids)
+(define (db:get-test-info-by-ids dbstruct area-dat run-id test-ids)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (let ((res '()))
        (sqlite3:for-each-row
@@ -2449,13 +2450,13 @@
 	db
 	(conc "SELECT " db:test-record-qry-selector " FROM tests WHERE id in ("
 	      (string-intersperse (map conc test-ids) ",") ");"))
        res))))
 
-(define (db:get-test-info dbstruct run-id testname item-path)
+(define (db:get-test-info dbstruct area-dat run-id testname item-path)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (let ((res #f))
        (sqlite3:for-each-row
@@ -2464,13 +2465,13 @@
 	db
 	(conc "SELECT " db:test-record-qry-selector " FROM tests WHERE testname=? AND item_path=?;")
 	test-name item-path)
        res))))
 
-(define (db:test-get-rundir-from-test-id dbstruct run-id test-id)
+(define (db:test-get-rundir-from-test-id dbstruct area-dat run-id test-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (db:first-result-default
       db
@@ -2480,13 +2481,13 @@
 
 ;;======================================================================
 ;; S T E P S
 ;;======================================================================
 
-(define (db:teststep-set-status! dbstruct run-id test-id teststep-name state-in status-in comment logfile)
+(define (db:teststep-set-status! dbstruct area-dat run-id test-id teststep-name state-in status-in comment logfile)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #t
    (lambda (db)
      (sqlite3:execute 
       db
@@ -2494,13 +2495,13 @@
       test-id teststep-name state-in status-in (current-seconds)
       (if comment comment "")
       (if logfile logfile "")))))
    
 ;; db-get-test-steps-for-run
-(define (db:get-steps-for-test dbstruct run-id test-id)
+(define (db:get-steps-for-test dbstruct area-dat run-id test-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (let* ((res '()))
        (sqlite3:for-each-row 
@@ -2509,13 +2510,13 @@
 	db
 	"SELECT id,test_id,stepname,state,status,event_time,logfile FROM test_steps WHERE status != 'DELETED' AND test_id=? ORDER BY id ASC;" ;; event_time DESC,id ASC;
 	test-id)
        (reverse res)))))
 
-(define (db:get-steps-data dbstruct run-id test-id)
+(define (db:get-steps-data dbstruct area-dat run-id test-id)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (let ((res '()))
        (sqlite3:for-each-row 
@@ -2533,12 +2534,12 @@
 ;; WARNING: Do NOT call this for the parent test on an iterated test
 ;; Roll up test_data pass/fail results
 ;; look at the test_data status field, 
 ;;    if all are pass (any case) and the test status is PASS or NULL or '' then set test status to PASS.
 ;;    if one or more are fail (any case) then set test status to PASS, non "pass" or "fail" are ignored
-(define (db:test-data-rollup dbstruct run-id test-id status)
-  (let* ((dbdat      (db:get-db dbstruct run-id))
+(define (db:test-data-rollup dbstruct area-dat run-id test-id status)
+  (let* ((dbdat      (db:get-db dbstruct area-dat run-id))
 	 (db         (db:dbdat-get-db dbdat))
 	 (fail-count 0)
 	 (pass-count 0))
     (db:delay-if-busy dbdat area-dat)
     (sqlite3:for-each-row
@@ -2552,13 +2553,13 @@
     ;; Now rollup the counts to the central megatest.db
     (db:general-call dbdat 'pass-fail-counts (list pass-count fail-count test-id))
     ;; if the test is not FAIL then set status based on the fail and pass counts.
     (db:general-call dbdat 'test_data-pf-rollup (list test-id test-id test-id test-id))))
 
-(define (db:csv->test-data dbstruct run-id test-id csvdata)
+(define (db:csv->test-data dbstruct area-dat run-id test-id csvdata)
   (debug:print 4 "test-id " test-id ", csvdata: " csvdata)
-  (let* ((dbdat   (db:get-db dbstruct run-id))
+  (let* ((dbdat   (db:get-db dbstruct area-dat run-id))
 	 (db      (db:dbdat-get-db dbdat))
 	 (csvlist (csv->list (make-csv-reader
 			      (open-input-string csvdata)
 			      '((strip-leading-whitespace? #t)
 				(strip-trailing-whitespace? #t)))))) ;; (csv->list csvdata)))
@@ -2616,12 +2617,12 @@
 
 ;;======================================================================
 ;; Misc. test related queries
 ;;======================================================================
 
-(define (db:get-run-ids-matching-target dbstruct keynames target res runname testpatt statepatt statuspatt)
-  (let* ((dbdat    (db:get-db dbstruct #f))
+(define (db:get-run-ids-matching-target dbstruct area-dat keynames target res runname testpatt statepatt statuspatt)
+  (let* ((dbdat    (db:get-db dbstruct area-dat #f))
 	 (db       (db:dbdat-get-db dbdat))
 	 (row-ids '())
 	 (keystr (string-intersperse 
 		  (map (lambda (key val)
 			 (conc key " like '" val "'"))
@@ -2636,15 +2637,15 @@
        (set! row-ids (cons rid row-ids)))
      runsqry)
     (sqlite3:finalize! runsqry)
     row-ids))
 
-(define (db:test-get-paths-matching-keynames-target-new dbstruct run-id keynames target res testpatt statepatt statuspatt runname)
+(define (db:test-get-paths-matching-keynames-target-new dbstruct area-dat run-id keynames target res testpatt statepatt statuspatt runname)
   (let* ((testqry (tests:match->sqlqry testpatt))
 	 (tstsqry (conc "SELECT rundir FROM tests WHERE " testqry " AND state LIKE '" statepatt "' AND status LIKE '" statuspatt "' ORDER BY event_time ASC;")))
     (db:with-db
-     dbstruct
+     dbstruct area-dat
      run-id
      #f
      (lambda (db)
        (sqlite3:for-each-row 
 	(lambda (p)
@@ -2651,13 +2652,13 @@
 	  (set! res (cons p res)))
 	db
 	tstsqry)
        res))))
 
-(define (db:test-toplevel-num-items dbstruct run-id testname)
+(define (db:test-toplevel-num-items dbstruct area-dat run-id testname)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (let ((res 0))
        (sqlite3:for-each-row
@@ -2703,34 +2704,34 @@
 	   (debug:print 0 "ERROR: reception failed. Received " msg " but cannot translate it.")
 	   msg))) ;; crude reply for when things go awry
     ((zmq nmsg)(with-input-from-string msg (lambda ()(deserialize))))
     (else msg)))
 
-(define (db:test-set-status-state dbstruct run-id test-id status state msg)
-  (let ((dbdat  (db:get-db dbstruct run-id)))
+(define (db:test-set-status-state dbstruct area-dat run-id test-id status state msg)
+  (let ((dbdat  (db:get-db dbstruct area-dat run-id)))
     (if (member state '("LAUNCHED" "REMOTEHOSTSTART"))
 	(db:general-call dbdat 'set-test-start-time (list test-id)))
     (if msg
 	(db:general-call dbdat 'state-status-msg (list state status msg test-id))
 	(db:general-call dbdat 'state-status     (list state status test-id)))))
 
-(define (db:roll-up-pass-fail-counts dbstruct run-id test-name item-path status)
+(define (db:roll-up-pass-fail-counts dbstruct area-dat run-id test-name item-path status)
   (if (and (not (equal? item-path ""))
 	   (member status '("PASS" "WARN" "FAIL" "WAIVED" "RUNNING" "CHECK" "SKIP" "LAUNCHED")))
-      (let ((dbdat (db:get-db dbstruct run-id)))
+      (let ((dbdat (db:get-db dbstruct area-dat run-id)))
 	(db:general-call dbdat 'update-pass-fail-counts (list test-name test-name test-name))
 	(if (equal? status "RUNNING")
 	    (db:general-call dbdat 'top-test-set-running (list test-name))
 	    (if (equal? status "LAUNCHED")
 		(db:general-call dbdat 'top-test-set (list "LAUNCHED" test-name))
 		(db:general-call dbdat 'top-test-set-per-pf-counts (list test-name run-id test-name test-name test-name))))
 	#f)
       #f))
 
-(define (db:test-get-logfile-info dbstruct run-id test-name)
+(define (db:test-get-logfile-info dbstruct area-dat run-id test-name)
   (db:with-db
-   dbstruct
+   dbstruct area-dat
    run-id
    #f
    (lambda (db)
      (let ((res #f))
        (sqlite3:for-each-row 
@@ -2832,11 +2833,11 @@
 			       sync
 			       set-verbosity
 			       killserver
 			       ))
 
-(define (db:login dbstruct area-dat calling-path calling-version run-id client-signature)
+(define (db:login dbstruct area-dat area-dat calling-path calling-version run-id client-signature)
   (cond 
    ((not (equal? calling-path (megatest:area-path area-dat)))
     (list #f "Login failed due to mismatch paths: " calling-path ", " (megatest:area-path area-dat)))
    ((not (equal? *run-id* run-id))
     (list #f "Login failed due to mismatch run-id: " run-id ", " *run-id*))
@@ -2860,12 +2861,12 @@
 ;; NB// Merge this with test:get-previous-test-run-records? This one looks for all matching tests
 ;; can use wildcards. Also can likely be factored in with get test paths?
 ;;
 ;; Run this remotely!!
 ;;
-(define (db:get-matching-previous-test-run-records dbstruct run-id test-name item-path)
-  (let* ((dbdat   (db:get-db dbstruct #f))
+(define (db:get-matching-previous-test-run-records dbstruct area-dat run-id test-name item-path)
+  (let* ((dbdat   (db:get-db dbstruct area-dat #f))
 	 (db      (db:dbdat-get-db dbdat))
 	 (keys    (db:get-keys db))
 	 (selstr  (string-intersperse (map (lambda (x)(vector-ref x 0)) keys) ","))
 	 (qrystr  (string-intersperse (map (lambda (x)(conc (vector-ref x 0) "=?")) keys) " AND "))
 	 (keyvals #f)
@@ -2890,11 +2891,11 @@
 	  (debug:print 4 "selstr: " selstr ", qrystr: " qrystr ", keyvals: " keyvals 
 		       ", previous run ids found: " prev-run-ids)
 	  (if (null? prev-run-ids) '()  ;; no previous runs? return null
 	      (let loop ((hed (car prev-run-ids))
 			 (tal (cdr prev-run-ids)))
-		(let ((results (db:get-tests-for-run dbstruct run-id hed (conc test-name "/" item-path) '() '() #f #f #f #f #f #f)))
+		(let ((results (db:get-tests-for-run dbstruct area-dat run-id hed (conc test-name "/" item-path) '() '() #f #f #f #f #f #f)))
 		  (debug:print 4 "Got tests for run-id " run-id ", test-name " test-name 
 			       ", item-path " item-path " results: " (intersperse results "\n"))
 		  ;; Keep only the youngest of any test/item combination
 		  (for-each 
 		   (lambda (testdat)
@@ -2947,14 +2948,14 @@
 		   (debug:print-info 0 "delaying db access due to high database load.")
 		   (thread-sleep! 12.8))))
 	    db)
 	  "bogus result from db:delay-if-busy")))
 
-(define (db:test-get-records-for-index-file dbstruct run-id test-name)
+(define (db:test-get-records-for-index-file dbstruct area-dat run-id test-name)
   (let ((res '()))
     (db:with-db
-     dbstruct
+     dbstruct area-dat
      run-id
      #f
      (lambda (db)
        (sqlite3:for-each-row 
 	(lambda (id itempath state status run_duration logf comment)
@@ -2967,14 +2968,14 @@
 ;;======================================================================
 ;; Tests meta data
 ;;======================================================================
 
 ;; read the record given a testname
-(define (db:testmeta-get-record dbstruct testname)
+(define (db:testmeta-get-record dbstruct area-dat testname)
   (let ((res #f))
     (db:with-db
-     dbstruct
+     dbstruct area-dat
      #f
      #f
      (lambda (db)
        (sqlite3:for-each-row
 	(lambda (id testname author owner description reviewed iterated avg_runtime avg_disk tags jobgroup)
@@ -2983,27 +2984,27 @@
 	"SELECT id,testname,author,owner,description,reviewed,iterated,avg_runtime,avg_disk,tags,jobgroup FROM test_meta WHERE testname=?;"
 	testname)
        res))))
 
 ;; create a new record for a given testname
-(define (db:testmeta-add-record dbstruct testname)
-  (db:with-db dbstruct #f #f 
+(define (db:testmeta-add-record dbstruct area-dat testname)
+  (db:with-db dbstruct area-dat #f #f 
 	      (lambda (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 
+(define (db:testmeta-update-field dbstruct area-dat testname field value)
+  (db:with-db dbstruct area-dat #f #f 
 	      (lambda (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 
+(define (db:testmeta-get-all dbstruct area-dat)
+  (db:with-db dbstruct area-dat #f #f 
 	      (lambda (db)
 		(let ((res '()))
 		  (sqlite3:for-each-row
 		   (lambda (a . b)
 		     (set! res (cons (apply vector a b) res)))
@@ -3036,12 +3037,12 @@
 ;;
 ;; Note: mode 'normal means that tests must be COMPLETED and ok (i.e. PASS, WARN, CHECK, SKIP or WAIVED)
 ;;       mode 'toplevel means that tests must be COMPLETED only
 ;;       mode 'itemmatch or 'itemwait means that tests items must be COMPLETED and (PASS|WARN|WAIVED|CHECK) [[ NB// NOT IMPLEMENTED YET ]]
 ;; 
-;; (define (db:get-prereqs-not-met dbstruct run-id waitons ref-item-path mode)
-(define (db:get-prereqs-not-met dbstruct run-id waitons ref-item-path #!key (mode '(normal))(itemmap #f))
+;; (define (db:get-prereqs-not-met dbstruct area-dat run-id waitons ref-item-path mode)
+(define (db:get-prereqs-not-met dbstruct area-dat run-id waitons ref-item-path #!key (mode '(normal))(itemmap #f))
   (if (or (not waitons)
 	  (null? waitons))
       '()
       (let* ((unmet-pre-reqs '())
 	     (result         '()))
@@ -3048,11 +3049,11 @@
 	(for-each 
 	 (lambda (waitontest-name)
 	   ;; by getting the tests with matching name we are looking only at the matching test 
 	   ;; and related sub items
 	   ;; next should be using mt:get-tests-for-run?
-	   (let ((tests             (db:get-tests-for-run-state-status dbstruct run-id waitontest-name))
+	   (let ((tests             (db:get-tests-for-run-state-status dbstruct area-dat run-id waitontest-name))
 		 (ever-seen         #f)
 		 (parent-waiton-met #f)
 		 (item-waiton-met   #f))
 	     (for-each 
 	      (lambda (test)
@@ -3110,11 +3111,11 @@
 
 ;; NOT REWRITTEN YET!!!!!
 
 ;; runspatt is a comma delimited list of run patterns
 ;; keypatt-alist must contain *all* keys with an associated pattern: '( ("KEY1" "%") .. )
-(define (db:extract-ods-file dbstruct outputfile keypatt-alist runspatt pathmod)
+(define (db:extract-ods-file dbstruct area-dat outputfile keypatt-alist runspatt pathmod)
   (let* ((keysstr  (string-intersperse (map car keypatt-alist) ","))
 	 (keyqry   (string-intersperse (map (lambda (p)(conc (car p) " LIKE ? ")) keypatt-alist) " AND "))
 	 (numkeys  (length keypatt-alist))
 	 (test-ids '())
 	 (windows  (and pathmod (substring-index "\\" pathmod)))

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -1177,11 +1177,11 @@
 	     (runspatt   (or (args:get-arg "-runname")(args:get-arg ":runname")))
 	     (pathmod    (args:get-arg "-pathmod")))
 	     ;; (keyvalalist (keys->alist keys "%")))
 	 (debug:print 2 "Extract ods, outputfile: " outputfile " runspatt: " runspatt " keyvals: " keyvals)
 	 (db:extract-ods-file dbstruct outputfile keyvals (if runspatt runspatt "%") pathmod)
-	 (db:close-all dbstruct)
+	 (db:close-all dbstruct *area-dat*)
 	 (set! *didsomething* #t)))
      *area-dat*))
 
 ;;======================================================================
 ;; execute the test
@@ -1478,11 +1478,11 @@
 	       d))
 	    (current-input-port (make-gnu-readline-port "megatest> "))
 	    (if (args:get-arg "-repl")
 		(repl)
 		(load (args:get-arg "-load")))
-	    (db:close-all dbstruct))
+	    (db:close-all dbstruct *area-dat*))
 	  (exit))
       (set! *didsomething* #t)))
 
 ;;======================================================================
 ;; Wait on a run to complete

Index: server.scm
==================================================================
--- server.scm
+++ server.scm
@@ -108,11 +108,11 @@
   (let* ((configdat   (megatest:area-configdat area-dat))
 	 (toppath     (megatest:area-path      area-dat))
 	 (curr-host   (get-host-name))
 	 (curr-ip     (server:get-best-guess-address curr-host))
 	 (target-host (configf:lookup configdat "server" "homehost" ))
-	 (testsuite   (common:get-testsuite-name))
+	 (testsuite   (common:get-testsuite-name area-dat))
 	 (logfile     (conc toppath "/logs/" run-id ".log"))
 	 (cmdln (conc (common:get-megatest-exe)
 		      " -server " (or target-host "-") " -run-id " run-id (if (equal? (configf:lookup configdat "server" "daemonize") "yes")
 									      (conc " -daemonize -log " logfile)
 									      "")
@@ -142,23 +142,23 @@
 	(set! *my-client-signature* sig)
 	*my-client-signature*)))
 
 ;; kind start up of servers, wait 40 seconds before allowing another server for a given
 ;; run-id to be launched
-(define (server:kind-run run-id)
+(define (server:kind-run run-id area-dat)
   (let ((last-run-time (hash-table-ref/default *server-kind-run* run-id #f)))
     (if (or (not last-run-time)
 	    (> (- (current-seconds) last-run-time) 30))
 	(begin
-	  (server:run run-id)
+	  (server:run run-id area-dat)
 	  (hash-table-set! *server-kind-run* run-id (current-seconds))))))
 
 ;; The generic run a server command. Dispatches the call to server 0 if run-id != 0
 ;; 
-(define (server:try-running run-id)
+(define (server:try-running run-id area-dat)
   (if (eq? run-id 0)
-      (server:run run-id)
+      (server:run run-id area-dat)
       (rmt:start-server run-id)))
 
 (define (server:check-if-running run-id)
   (let ((tdbdat (tasks:open-db)))
     (let loop ((server (tasks:get-server (db:delay-if-busy tdbdat) run-id))

Index: tests/unittests/basicserver.scm
==================================================================
--- tests/unittests/basicserver.scm
+++ tests/unittests/basicserver.scm
@@ -22,11 +22,11 @@
 
 ;; Server tests go here 
 (for-each
  (lambda (run-id)
    (test #f #f (tasks:server-running-or-starting? (db:delay-if-busy (tasks:open-db)) run-id))
-   (server:kind-run run-id)
+   (server:kind-run run-id *area-dat*)
    (test "did server start within 20 seconds?"
 	 #t
 	 (let loop ((remtries 20)
 		    (running (tasks:server-running-or-starting? (db:delay-if-busy
 								 (tasks:open-db))