@@ -98,16 +98,16 @@
 	(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 run-id r/w proc . params)
+(define (db:with-db dbstruct 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)))
-    (db:delay-if-busy dbdat)
+	 (db    (db:dbdat-get-db dbdat area-dat)))
+    (db:delay-if-busy dbdat area-dat)
     (handle-exceptions
      exn
      (begin
        (debug:print 0 "ERROR: sqlite3 issue in db:with-db, dbstruct=" dbstruct ", run-id=" run-id ", proc=" proc ", params=" params " error: " ((condition-property-accessor 'exn 'message) exn))
        (print-call-chain (current-error-port)))
@@ -140,14 +140,16 @@
 ;;     (filedb:get-path db id)))
 
 ;; NB// #f => return dbdir only
 ;;      (was planned to be;  zeroth db with name=main.db)
 ;;
-(define (db:dbfile-path run-id)
+(define (db:dbfile-path run-id area-dat)
   (let* (;; (toppath      (dbr:dbstruct-get-path  dbstruct))
-	 (link-tree-path  (configf:lookup *configdat* "setup" "linktree"))
-	 (dbpath          (configf:lookup *configdat* "setup" "dbdir"))
+	 (configdat       (megatest:area-configdat area-dat))
+	 (toppath         (megatest:area-path      area-dat))
+	 (link-tree-path  (configf:lookup configdat "setup" "linktree"))
+	 (dbpath          (configf:lookup configdat "setup" "dbdir"))
 	 (fname           (if run-id
 			      (if (eq? run-id 0) "main.db" (conc run-id ".db"))
 			      #f))
 	 (dbdir           (if dbpath
 			      dbpath
@@ -160,12 +162,12 @@
      (if (not (directory? dbdir))(create-directory dbdir #t)))
     (if fname
 	(conc dbdir fname)
 	dbdir)))
 	       
-(define (db:set-sync db)
-  (let ((syncprag (configf:lookup *configdat* "setup" "sychronous")))
+(define (db:set-sync db area-dat)
+  (let ((syncprag (configf:lookup (megatest:area-configdat area-dat) "setup" "sychronous")))
     (sqlite3:execute db (conc "PRAGMA synchronous = " (or syncprag 1) ";"))))
 
 ;; open an sql database inside a file lock
 ;;
 ;; returns: db existed-prior-to-opening
@@ -244,14 +246,14 @@
 		db)
 	      (begin
 		(dbr:dbstruct-set-inmem!  dbstruct inmem)
 		;; dec 14, 2014 - keep deleted records available. hunch is that they are needed for id placeholders
 		;; (sqlite3:execute db "DELETE FROM tests WHERE state='DELETED';") ;; they just slow us down in this context
-		(db:sync-tables db:sync-tests-only db inmem)
-		(db:delay-if-busy refdb) ;; dbpath: (db:dbdat-get-path refdb)) ;; What does delaying here achieve? 
+		(db:sync-tables area-dat db:sync-tests-only db inmem)
+		(db:delay-if-busy refdb area-dat) ;; dbpath: (db:dbdat-get-path refdb)) ;; What does delaying here achieve? 
 		(dbr:dbstruct-set-refdb!  dbstruct refdb)
-		(db:sync-tables db:sync-tests-only inmem refdb) ;; use inmem as the reference, don't read again from db
+		(db:sync-tables area-dat db:sync-tests-only inmem refdb) ;; use inmem as the reference, don't read again from db
 		;; sync once more to deal with delays?
 		;; (db:sync-tables db:sync-tests-only db inmem)
 		;; (db:sync-tables db:sync-tests-only inmem refdb)
 		inmem))))))
 
@@ -314,13 +316,13 @@
 	    (if (or (not (number? mtime))
 		    (not (number? stime))
 		    (> mtime stime)
 		    force-sync)
 		(begin
-		  (db:delay-if-busy maindb)
-		  (db:delay-if-busy olddb)
-		  (let ((num-synced (db:sync-tables (db:sync-main-list maindb) maindb olddb)))
+		  (db:delay-if-busy maindb area-dat)
+		  (db:delay-if-busy olddb area-dat)
+		  (let ((num-synced (db:sync-tables area-dat (db:sync-main-list maindb) maindb olddb)))
 		    (dbr:dbstruct-set-stime! dbstruct (current-milliseconds))
 		    num-synced)
 		  0))
 	    (begin
 	      ;; this can occur when using local access (i.e. not in a server)
@@ -332,14 +334,14 @@
 	(if (or (not (number? mtime))
 		(not (number? stime))
 		(> mtime stime)
 		force-sync)
 	    (begin
-	      (db:delay-if-busy rundb)
-	      (db:delay-if-busy olddb)
+	      (db:delay-if-busy rundb area-dat)
+	      (db:delay-if-busy olddb area-dat)
 	      (dbr:dbstruct-set-stime! dbstruct (current-milliseconds))
-	      (let ((num-synced (db:sync-tables db:sync-tests-only inmem refdb rundb olddb)))
+	      (let ((num-synced (db:sync-tables area-dat db:sync-tests-only inmem refdb rundb olddb)))
 		;; (mutex-unlock! *http-mutex*)
 		num-synced)
 	      (begin
 		;; (mutex-unlock! *http-mutex*)
 		0))))))
@@ -488,11 +490,11 @@
 	   '("jobgroup"       #f)))))
     
 ;; tbls is ( ("tablename" ( "field1" [#f|proc1] ) ( "field2" [#f|proc2] ) .... ) )
 ;; db's are dbdat's
 ;;
-(define (db:sync-tables tbls fromdb todb . slave-dbs)
+(define (db:sync-tables area-dat tbls fromdb todb . slave-dbs)
   (mutex-lock! *db-sync-mutex*)
   (handle-exceptions
    exn
    (begin
      (debug:print 0 "EXCEPTION: database probably overloaded or unreadable in db:sync-tables.")
@@ -537,11 +539,11 @@
 		 (full-ins   (conc "INSERT OR REPLACE INTO " tablename " ( " (string-intersperse (map car fields) ",") " ) "
 				   " VALUES ( " (string-intersperse (make-list num-fields "?") ",") " );"))
 		 (fromdat    '())
 		 (fromdats   '())
 		 (totrecords 0)
-		 (batch-len  (string->number (or (configf:lookup *configdat* "sync" "batchsize") "10")))
+		 (batch-len  (string->number (or (configf:lookup configdat "sync" "batchsize") "10")))
 		 (todat      (make-hash-table))
 		 (count      0))
 
 	    ;; set up the field->num table
 	    (for-each
@@ -639,45 +641,45 @@
 	 (mtdb     (if toppath (db:open-megatest-db)))
 	 (allow-cleanup (if run-ids #f #t))
 	 (run-ids  (if run-ids 
 		       run-ids
 		       (if toppath (begin
-				     (db:delay-if-busy mtdb)
+				     (db:delay-if-busy mtdb area-dat)
 				     (db:get-all-run-ids mtdb)))))
 	 (tdbdat  (tasks:open-db))
-	 (servers (tasks:get-all-servers (db:delay-if-busy tdbdat))))
+	 (servers (tasks:get-all-servers (db:delay-if-busy tdbdat area-dat))))
     
     ;; kill servers
     (if (member 'killservers options)
 	(for-each
 	 (lambda (server)
-	   (tasks:server-delete-record (db:delay-if-busy tdbdat) (vector-ref server 0) "dbmigration")
+	   (tasks:server-delete-record (db:delay-if-busy tdbdat area-dat) (vector-ref server 0) "dbmigration")
 	   (tasks:kill-server (vector-ref server 2)(vector-ref server 1)))
 	 servers))
 
     ;; clear out junk records
     ;;
     (if (member 'dejunk options)
 	(begin
-	  (db:delay-if-busy mtdb)
+	  (db:delay-if-busy mtdb area-dat)
 	  (db:clean-up mtdb)))
 
     ;; adjust test-ids to fit into proper range
     ;;
     (if (member 'adj-testids options)
 	(begin
-	  (db:delay-if-busy mtdb)
+	  (db:delay-if-busy mtdb area-dat)
 	  (db:prep-megatest.db-for-migration mtdb)))
 
     ;; sync runs, test_meta etc.
     ;;
     (if (member 'old2new options)
 	(begin
-	  (db:sync-tables (db:sync-main-list mtdb) mtdb (db:get-db dbstruct #f))
+	  (db:sync-tables area-dat (db:sync-main-list mtdb) mtdb (db:get-db dbstruct #f))
 	  (for-each 
 	   (lambda (run-id)
-	     (db:delay-if-busy mtdb)
+	     (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)))
 	       (debug:print 0 "INFO: Propagating " (length testrecs) " records for run-id=" run-id " to run specific db")
 	       (db:replace-test-records dbstruct run-id testrecs)
 	       (sqlite3:finalize! (db:dbdat-get-db (dbr:dbstruct-get-rundb dbstruct)))))
@@ -702,15 +704,15 @@
 	       ;; (db:delay-if-busy frundb)
 	       ;; (db:delay-if-busy mtdb)
 	       ;; (db:clean-up frundb)
 	       (if (eq? run-id 0)
 		   (begin
-		     (db:sync-tables (db:sync-main-list dbstruct) (db:get-db fromdb #f) mtdb)
+		     (db:sync-tables area-dat (db:sync-main-list dbstruct) (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 db:sync-tests-only (db:get-db fromdb run-id) mtdb)
+		     (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))
 		     ))))
 	   all-run-ids)
 	  ;; removed deleted runs
 	  (let ((dbdir (tasks:get-task-db-path)))
@@ -766,12 +768,12 @@
 (define open-run-close open-run-close-exception-handling)
 		;;	   open-run-close-no-exception-handling
 ;;			   open-run-close-exception-handling)
 ;;)
 
-(define (db:initialize-main-db dbdat)
-  (let* ((configdat (car *configinfo*))  ;; tut tut, global warning...
+(define (db:initialize-main-db dbdat area-dat)
+  (let* ((configdat (megatest:area-configdat area-dat)) ;; (car *configinfo*))  ;; tut tut, global warning...
 	 (keys     (keys:config-get-fields configdat))
 	 (havekeys (> (length keys) 0))
 	 (keystr   (keys->keystr keys))
 	 (fieldstr (keys->key/field keys))
 	 (db       (db:dbdat-get-db dbdat)))
@@ -1114,17 +1116,17 @@
 
 ;;======================================================================
 ;; M A I N T E N A N C E
 ;;======================================================================
 
-(define (db:have-incompletes? dbstruct run-id ovr-deadtime)
+(define (db:have-incompletes? dbstruct run-id ovr-deadtime area-dat)
   (let* ((dbdat        (db:get-db dbstruct run-id))
 	 (db           (db:dbdat-get-db dbdat))
 	 (incompleted '())
 	 (oldlaunched '())
 	 (toplevels   '())
-	 (deadtime-str (configf:lookup *configdat* "setup" "deadtime"))
+	 (deadtime-str (configf:lookup (megatest:area-configdat area-dat) "setup" "deadtime"))
 	 (deadtime     (if (and deadtime-str
 				(string->number deadtime-str))
 			   (string->number deadtime-str)
 			   7200))) ;; two hours
     (if (number? ovr-deadtime)(set! deadtime ovr-deadtime))
@@ -1133,11 +1135,11 @@
     ;;
     ;; HOWEVER: this code in run:test seems to work fine
     ;;              (> (- (current-seconds)(+ (db:test-get-event_time testdat)
     ;;                     (db:test-get-run_duration testdat)))
     ;;                    600) 
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat) 
     (sqlite3:for-each-row 
      (lambda (test-id run-dir uname testname item-path)
        (if (and (equal? uname "n/a")
 		(equal? item-path "")) ;; this is a toplevel test
 	   ;; what to do with toplevel? call rollup?
@@ -1149,11 +1151,11 @@
      "SELECT id,rundir,uname,testname,item_path FROM tests WHERE run_id=? AND (strftime('%s','now') - event_time) > (run_duration + ?) AND state IN ('RUNNING','REMOTEHOSTSTART');"
      run-id deadtime)
 
     ;; in LAUNCHED for more than one day. Could be long due to job queues TODO/BUG: Need override for this in config
     ;;
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:for-each-row
      (lambda (test-id run-dir uname testname item-path)
        (if (and (equal? uname "n/a")
 		(equal? item-path "")) ;; this is a toplevel test
 	   ;; what to do with toplevel? call rollup?
@@ -1173,17 +1175,17 @@
 ;;  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)
+(define (db:find-and-mark-incomplete dbstruct run-id ovr-deadtime area-dat)
   (let* ((dbdat        (db:get-db dbstruct run-id))
 	 (db           (db:dbdat-get-db dbdat))
 	 (incompleted '())
 	 (oldlaunched '())
 	 (toplevels   '())
-	 (deadtime-str (configf:lookup *configdat* "setup" "deadtime"))
+	 (deadtime-str (configf:lookup (megatest:area-configdat area-dat) "setup" "deadtime"))
 	 (deadtime     (if (and deadtime-str
 				(string->number deadtime-str))
 			   (string->number deadtime-str)
 			   7200))) ;; two hours
     (if (number? ovr-deadtime)(set! deadtime ovr-deadtime))
@@ -1192,11 +1194,11 @@
     ;;
     ;; HOWEVER: this code in run:test seems to work fine
     ;;              (> (- (current-seconds)(+ (db:test-get-event_time testdat)
     ;;                     (db:test-get-run_duration testdat)))
     ;;                    600) 
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:for-each-row 
      (lambda (test-id run-dir uname testname item-path)
        (if (and (equal? uname "n/a")
 		(equal? item-path "")) ;; this is a toplevel test
 	   ;; what to do with toplevel? call rollup?
@@ -1208,11 +1210,11 @@
      "SELECT id,rundir,uname,testname,item_path FROM tests WHERE run_id=? AND (strftime('%s','now') - event_time) > (run_duration + ?) AND state IN ('RUNNING','REMOTEHOSTSTART');"
      run-id deadtime)
 
     ;; in LAUNCHED for more than one day. Could be long due to job queues TODO/BUG: Need override for this in config
     ;;
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:for-each-row
      (lambda (test-id run-dir uname testname item-path)
        (if (and (equal? uname "n/a")
 		(equal? item-path "")) ;; this is a toplevel test
 	   ;; what to do with toplevel? call rollup?
@@ -1224,11 +1226,11 @@
     
     (debug:print-info 18 "Found " (length oldlaunched) " old LAUNCHED items, " (length toplevels) " old LAUNCHED toplevel tests and " (length incompleted) " tests marked RUNNING but apparently dead.")
 
     ;; These are defunct tests, do not do all the overhead of set-state-status. Force them to INCOMPLETE.
     ;;
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (let* (;; (min-incompleted (filter (lambda (x)
 	   ;;      		      (let* ((testpath (cadr x))
 	   ;;      			     (tdatpath (conc testpath "/testdat.db"))
 	   ;;      			     (dbexists (file-exists? tdatpath)))
 	   ;;      			(or (not dbexists) ;; if no file then something wrong - mark as incomplete
@@ -1245,11 +1247,11 @@
 		   (string-intersperse (map conc all-ids) ",")
 		   ");")))))
 
     ;; Now do rollups for the toplevel tests
     ;;
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (for-each
      (lambda (toptest)
        (let ((test-name (list-ref toptest 3)))
 ;;	     (run-id    (list-ref toptest 5)))
 	  (db:general-call db 'top-test-set-per-pf-counts (list test-name run-id test-name test-name test-name)))) ;; (list run-id test-name))))
@@ -1283,11 +1285,11 @@
 	       ;; delete all runs that are state='deleted'
 	       "DELETE FROM runs WHERE state='deleted';"
 	       ;; delete empty runs
 	       "DELETE FROM runs WHERE id NOT IN (SELECT DISTINCT r.id FROM runs AS r INNER JOIN tests AS t ON t.run_id=r.id);"
 	       ))))
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:with-transaction 
      db
      (lambda ()
        (sqlite3:for-each-row (lambda (tot)
 			       (debug:print-info 0 "Records count before clean: " tot))
@@ -1297,11 +1299,11 @@
 			       (debug:print-info 0 "Records count after  clean: " tot))
 			     count-stmt)))
     (map sqlite3:finalize! statements)
     (sqlite3:finalize! count-stmt)
     ;; (db:find-and-mark-incomplete db)
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:execute db "VACUUM;")))
 
 ;; Clean out old junk and vacuum the database
 ;;
 ;; Ultimately do something like this:
@@ -1324,11 +1326,11 @@
 	       ;; delete all tests that belong to runs that are 'deleted'
 	       ;; (conc "DELETE FROM tests WHERE run_id NOT IN (" (string-intersperse (map conc valid-runs) ",") ");")
 	       ;; delete all tests that are 'DELETED'
 	       "DELETE FROM tests WHERE state='DELETED';"
 	       ))))
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:with-transaction 
      db
      (lambda ()
        (sqlite3:for-each-row (lambda (tot)
 			       (debug:print-info 0 "Records count before clean: " tot))
@@ -1338,11 +1340,11 @@
 			       (debug:print-info 0 "Records count after  clean: " tot))
 			     count-stmt)))
     (map sqlite3:finalize! statements)
     (sqlite3:finalize! count-stmt)
     ;; (db:find-and-mark-incomplete db)
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:execute db "VACUUM;")))
 
 ;; Clean out old junk and vacuum the database
 ;;
 ;; Ultimately do something like this:
@@ -1371,11 +1373,11 @@
     (sqlite3:for-each-row
      (lambda (run-id)
        (set! dead-runs (cons run-id dead-runs)))
        db
        "SELECT id FROM runs WHERE state='deleted';")
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:with-transaction 
      db
      (lambda ()
        (sqlite3:for-each-row (lambda (tot)
 			       (debug:print-info 0 "Records count before clean: " tot))
@@ -1385,11 +1387,11 @@
 			       (debug:print-info 0 "Records count after  clean: " tot))
 			     count-stmt)))
     (map sqlite3:finalize! statements)
     (sqlite3:finalize! count-stmt)
     ;; (db:find-and-mark-incomplete db)
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:execute db "VACUUM;")
     dead-runs))
 
 ;;======================================================================
 ;; M E T A   G E T   A N D   S E T   V A R S
@@ -1398,18 +1400,18 @@
 ;; returns number if string->number is successful, string otherwise
 ;; also updates *global-delta*
 ;;
 ;; Operates on megatestdb
 ;;
-(define (db:get-var dbstruct var)
+(define (db:get-var dbstruct var area-dat)
   (let* ((start-ms (current-milliseconds))
-         (throttle (let ((t  (config-lookup *configdat* "setup" "throttle")))
+         (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))
 	 (db       (db:dbdat-get-db dbdat)))
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:for-each-row
      (lambda (val)
        (set! res val))
      db
      "SELECT val FROM metadat WHERE var=?;" var)
@@ -1428,11 +1430,11 @@
     res))
 
 (define (db:set-var dbstruct var val)
   (let ((dbdat (db:get-db dbstruct #f))
 	(db    (db:dbdat-get-db dbdat)))
-    (db:delay-if-busy 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)
   ;; (db:delay-if-busy)
   (db:with-db dbstruct #f #t 
@@ -1543,23 +1545,23 @@
 	 (key=?str  (string-intersperse (map (lambda (k)(conc k "=?")) keys) " AND ")))
     (debug:print 3 "keys: " keys " allvals: " allvals " keyvals: " keyvals " key=?str is " key=?str)
     (debug:print 2 "NOTE: using target " (string-intersperse (map cadr keyvals) "/") " for this run")
     (if (and runname (null? (filter (lambda (x)(not x)) keyvals))) ;; there must be a better way to "apply and"
 	(let ((res #f))
-	  (db:delay-if-busy dbdat)
+	  (db:delay-if-busy dbdat area-dat)
 	  (apply sqlite3:execute db (conc "INSERT OR IGNORE INTO runs (runname,state,status,owner,event_time" comma keystr ") VALUES (?,?,?,?,strftime('%s','now')" comma valslots ");")
 		 allvals)
-	  (db:delay-if-busy dbdat)
+	  (db:delay-if-busy dbdat area-dat)
 	  (apply sqlite3:for-each-row 
 		 (lambda (id)
 		   (set! res id))
 		 db
 		 (let ((qry (conc "SELECT id FROM runs WHERE (runname=? " andstr key=?str ");")))
 					;(debug:print 4 "qry: " qry) 
 		   qry)
 		 qryvals)
-	  (db:delay-if-busy dbdat)
+	  (db:delay-if-busy dbdat area-dat)
 	  (sqlite3:execute db "UPDATE runs SET state=?,status=?,event_time=strftime('%s','now') WHERE id=? AND state='deleted';" state status res)
 	  res) 
 	(begin
 	  (debug:print 0 "ERROR: Called without all necessary keys")
 	  #f))))
@@ -1719,11 +1721,11 @@
 	 (totals       (make-hash-table))
 	 (curr         (make-hash-table))
 	 (res          '())
 	 (runs-info    '()))
     ;; First get all the runname/run-ids
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (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';")
@@ -1811,11 +1813,11 @@
 	 (remfields (list "id" "runname" "state" "status" "owner" "event_time"))
 	 (header    (append keys remfields))
 	 (keystr    (conc (keys->keystr keys) ","
 			  (string-intersperse remfields ","))))
     (debug:print-info 11 "db:get-run-info run-id: " run-id " header: " header " keystr: " keystr)
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:for-each-row
      (lambda (a . x)
        (set! res (apply vector a x)))
      db 
      (conc "SELECT " keystr " FROM runs WHERE id=? AND state != 'deleted';")
@@ -1839,15 +1841,15 @@
   ;; First set any related tests to DELETED
   (let* ((rdbdat (db:get-db dbstruct run-id))
 	 (rdb    (db:dbdat-get-db rdbdat))
 	 (dbdat  (db:get-db dbstruct #f))
 	 (db     (db:dbdat-get-db dbdat)))
-    (db:delay-if-busy rdbdat)
+    (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)
+    (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)
   (db:with-db
    dbstruct
@@ -1872,11 +1874,11 @@
        (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))
 	 (db    (db:dbdat-get-db dbdat)))
-    (db:delay-if-busy 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)
@@ -1906,11 +1908,11 @@
 	 (dbdat  (db:get-db dbstruct #f))
 	 (db     (db:dbdat-get-db dbdat)))
     (for-each 
      (lambda (key)
        (let ((qry (conc "SELECT " key " FROM runs WHERE id=?;")))
-	 (db:delay-if-busy dbdat)
+	 (db:delay-if-busy dbdat area-dat)
 	 (sqlite3:for-each-row 
 	  (lambda (key-val)
 	    (set! res (cons (list key key-val) res)))
 	  db qry run-id)))
      keys)
@@ -1923,11 +1925,11 @@
 	 (dbdat  (db:get-db dbstruct #f))
 	 (db     (db:dbdat-get-db dbdat)))
     (for-each 
      (lambda (key)
        (let ((qry (conc "SELECT " key " FROM runs WHERE id=?;")))
-	 (db:delay-if-busy dbdat)
+	 (db:delay-if-busy dbdat area-dat)
 	 (sqlite3:for-each-row 
 	  (lambda (key-val)
 	    (set! res (cons key-val res)))
 	  db qry run-id)))
      keys)
@@ -2237,11 +2239,11 @@
 	 (db    (db:dbdat-get-db dbdat)))
   (if (not jobgroup)
       0 ;; 
       (let ((testnames '()))
 	;; get the testnames
-	(db:delay-if-busy dbdat)
+	(db:delay-if-busy dbdat area-dat)
 	(sqlite3:for-each-row
 	 (lambda (testname)
 	   (set! testnames (cons testname testnames)))
 	 db
 	 "SELECT testname FROM test_meta WHERE jobgroup=?"
@@ -2339,11 +2341,11 @@
   (let* ((dbdat (if (vector? dbstruct)
 		    (db:get-db dbstruct run-id)
 		    dbstruct)) ;; still settling on when to use dbstruct or dbdat
 	 (db    (db:dbdat-get-db dbdat))
 	 (res '()))
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (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)))
@@ -2534,11 +2536,11 @@
 (define (db:test-data-rollup dbstruct run-id test-id status)
   (let* ((dbdat      (db:get-db dbstruct run-id))
 	 (db         (db:dbdat-get-db dbdat))
 	 (fail-count 0)
 	 (pass-count 0))
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (sqlite3:for-each-row
      (lambda (fcount pcount)
        (set! fail-count fcount)
        (set! pass-count pcount))
      db 
@@ -2603,11 +2605,11 @@
 			 ((>=) (if (>= value expected) "pass" "fail"))
 			 ((<=) (if (<= value expected) "pass" "fail"))
 			 (else (conc "ERROR: bad tol comparator " tol))))))
 	 (debug:print 4 "AFTER2: category: " category " variable: " variable " value: " value 
 		      ", expected: " expected " tol: " tol " units: " units " status: " status " comment: " comment)
-	 (db:delay-if-busy dbdat)
+	 (db:delay-if-busy dbdat area-dat)
 	 (sqlite3:execute db "INSERT OR REPLACE INTO test_data (test_id,category,variable,value,expected,tol,units,comment,status,type) VALUES (?,?,?,?,?,?,?,?,?,?);"
 			  test-id category variable value expected tol units (if comment comment "") status type)))
      csvlist)))
 
 ;;======================================================================
@@ -2846,11 +2848,11 @@
   (let ((query (let ((q (alist-ref (if (string? stmtname)
 				       (string->symbol stmtname)
 				       stmtname)
 				   db:queries)))
  		 (if q (car q) #f))))
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (apply sqlite3:execute (db:dbdat-get-db dbdat) query params)
     #t)) ;; BUG or Sillyness, why do I return #t instead of the query result?
 
 ;; get the previous records for when these tests were run where all keys match but runname
 ;; NB// Merge this with test:get-previous-test-run-records? This one looks for all matching tests
@@ -2865,11 +2867,11 @@
 	 (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)
 	 (tests-hash (make-hash-table)))
     ;; first look up the key values from the run selected by run-id
-    (db:delay-if-busy dbdat)
+    (db:delay-if-busy dbdat area-dat)
     (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)
@@ -2904,12 +2906,12 @@
 		   results)
 		  (if (null? tal)
 		      (map cdr (hash-table->alist tests-hash)) ;; return a list of the most recent tests
 		      (loop (car tal)(cdr tal))))))))))
 
-(define (db:delay-if-busy dbdat #!key (count 6))
-  (if (not (configf:lookup *configdat* "server" "delay-on-busy"))
+(define (db:delay-if-busy dbdat area-dat #!key (count 6))
+  (if (not (configf:lookup (megatest:area-configdat area-dat) "server" "delay-on-busy"))
       (and dbdat (db:dbdat-get-db dbdat))
       (if dbdat
 	  (let* ((dbpath (db:dbdat-get-path dbdat))
 		 (db     (db:dbdat-get-db   dbdat)) ;; we'll return this so (db:delay--if-busy can be called inline
 		 (dbfj   (conc dbpath "-journal")))
@@ -2916,31 +2918,31 @@
 	    (if (handle-exceptions
 		 exn
 		 (begin
 		   (debug:print-info 0 "WARNING: failed to test for existance of " dbfj)
 		   (thread-sleep! 1)
-		   (db:delay-if-busy count (- count 1)))
+		   (db:delay-if-busy dbdat area-dat count: (- count 1)))
 		 (file-exists? dbfj))
 		(case count
 		  ((6)
 		   (thread-sleep! 0.2)
-		   (db:delay-if-busy count: 5))
+		   (db:delay-if-busy dbdat area-dat count: 5))
 		  ((5)
 		   (thread-sleep! 0.4)
-		   (db:delay-if-busy count: 4))
+		   (db:delay-if-busy dbdat area-dat count: 4))
 		  ((4)
 		   (thread-sleep! 0.8)
-		   (db:delay-if-busy count: 3))
+		   (db:delay-if-busy dbdat area-dat count: 3))
 		  ((3)
 		   (thread-sleep! 1.6)
-		   (db:delay-if-busy count: 2))
+		   (db:delay-if-busy dbdat area-dat count: 2))
 		  ((2)
 		   (thread-sleep! 3.2)
-		   (db:delay-if-busy count: 1))
+		   (db:delay-if-busy dbdat area-dat count: 1))
 		  ((1)
 		   (thread-sleep! 6.4)
-		   (db:delay-if-busy count: 0))
+		   (db:delay-if-busy dbdat area-dat count: 0))
 		  (else
 		   (debug:print-info 0 "delaying db access due to high database load.")
 		   (thread-sleep! 12.8))))
 	    db)
 	  "bogus result from db:delay-if-busy")))