Index: client.scm
==================================================================
--- client.scm
+++ client.scm
@@ -82,11 +82,11 @@
 		    (if (< remaining-tries 8)
 			(thread-sleep! 5)
 			(thread-sleep! 1))
 		    (client:setup run-id remaining-tries: (- remaining-tries 1)))))
 	    ;; YUK: rename server-dat here
-	    (let* ((server-dat (open-run-close tasks:get-server tasks:open-db run-id)))
+	    (let* ((server-dat (tasks:get-server (tasks:get-db) run-id)))
 	      (debug:print-info 4 "client:setup server-dat=" server-dat ", remaining-tries=" remaining-tries)
 	      (if server-dat
 		  (let* ((iface     (tasks:hostinfo-get-interface server-dat))
 			 (port      (tasks:hostinfo-get-port      server-dat))
 			 (start-res (http-transport:client-connect iface port))
@@ -99,22 +99,21 @@
 			  start-res)
 			(begin    ;; login failed but have a server record, clean out the record and try again
 			  (debug:print-info 0 "client:setup, login failed, will attempt to start server ... start-res=" start-res ", run-id=" run-id ", server-dat=" server-dat)
 			  (http-transport:close-connections run-id)
 			  (hash-table-delete! *runremote* run-id)
-			  (open-run-close tasks:server-force-clean-run-record
-					  tasks:open-db
-					  run-id 
-					  (tasks:hostinfo-get-interface server-dat)
-					  (tasks:hostinfo-get-port      server-dat)
-					  " client:setup (server-dat = #t)")
+			  (tasks:server-force-clean-run-record (tasks:get-db)
+							       run-id 
+							       (tasks:hostinfo-get-interface server-dat)
+							       (tasks:hostinfo-get-port      server-dat)
+							       " client:setup (server-dat = #t)")
 			  (thread-sleep! 2)
 			  (server:try-running run-id)
 			  (thread-sleep! 10) ;; give server a little time to start up
 			  (client:setup run-id remaining-tries: (- remaining-tries 1)))))
 		  (begin    ;; no server registered
-		    (let ((num-available (open-run-close tasks:num-in-available-state tasks:open-db run-id)))
+		    (let ((num-available (tasks:num-in-available-state (tasks:get-db) run-id)))
 		      (debug:print-info 0 "client:setup, no server registered, remaining-tries=" remaining-tries " num-available=" num-available)
 		      (thread-sleep! 2) 
 		      (if (< num-available 2)
 			  (begin
 			    ;; (open-run-close tasks:server-clean-out-old-records-for-run-id tasks:open-db run-id " client:setup (server-dat=#f)")

Index: common.scm
==================================================================
--- common.scm
+++ common.scm
@@ -46,35 +46,36 @@
 (define *test-meta-updated* (make-hash-table))
 (define *globalexitstatus*  0) ;; attempt to work around possible thread issues
 (define *passnum*           0) ;; when running track calls to run-tests or similar
 (define *write-frequency*   (make-hash-table)) ;; run-id => (vector (current-seconds) 0))
 (define *alt-log-file* #f)  ;; used by -log
-(define *db-sync-mutex* (make-mutex))
 
 ;; DATABASE
 (define *dbstruct-db*  #f)
 (define *db-stats* (make-hash-table)) ;; hash of vectors < count duration-total >
 (define *db-stats-mutex*      (make-mutex))
+(define *db-sync-mutex* (make-mutex))
+(define *megatest-db*       #f)
+(define *last-db-access*    (current-seconds))  ;; update when db is accessed via server
+(define *db-write-access*   #t)
+(define *inmemdb*           #f)
+(define *task-db*           #f) ;; (vector db path-to-db)
 
 ;; SERVER
 (define *my-client-signature* #f)
 (define *transport-type*    'http)
-(define *megatest-db*       #f)
 (define *rpc:listener*      #f) ;; if set up for server communication this will hold the tcp port
 (define *runremote*         (make-hash-table)) ;; if set up for server communication this will hold <host port>
-(define *last-db-access*    (current-seconds))  ;; update when db is accessed via server
 (define *max-cache-size*    0)
 (define *logged-in-clients* (make-hash-table))
 (define *client-non-blocking-mode* #f)
 (define *server-id*         #f)
 (define *server-info*       #f)
 (define *time-to-exit*      #f)
 (define *received-response* #f)
 (define *default-numtries*  10)
 (define *server-run*        #t)
-(define *db-write-access*   #t)
-(define *inmemdb*           #f)
 (define *run-id*            #f)
 (define *server-kind-run*   (make-hash-table))
 
 (define *target*            (make-hash-table)) ;; cache the target here; target is keyval1/keyval2/.../keyvalN
 (define *keys*              (make-hash-table)) ;; cache the keys here

Index: dcommon.scm
==================================================================
--- dcommon.scm
+++ dcommon.scm
@@ -450,11 +450,11 @@
 				     #:numcol-visible 7
 				     #:numlin-visible 5
 				     ))
 	 (colnames       (list "Id" "MTver" "Pid" "Host" "Interface:OutPort" "RunTime" "State" "RunId"))
 	 (updater        (lambda ()
-			   (let ((servers (open-run-close tasks:get-all-servers tasks:open-db)))
+			   (let ((servers (tasks:get-all-servers (tasks:get-db))))
 			     (iup:attribute-set! servers-matrix "NUMLIN" (length servers))
 			     ;; (set! colnum 0)
 			     ;; (for-each (lambda (colname)
 			     ;;    	 ;; (print "colnum: " colnum " colname: " colname)
 			     ;;    	 (iup:attribute-set! servers-matrix (conc "0:" colnum) colname)

Index: http-transport.scm
==================================================================
--- http-transport.scm
+++ http-transport.scm
@@ -155,16 +155,16 @@
 	     (http-transport:try-start-server run-id
 					      ipaddrstr
 					      (portlogger:open-run-close portlogger:find-port)
 					      server-id))
 	   (begin
-	     (open-run-close tasks:server-force-clean-run-record tasks:open-db run-id ipaddrstr portnum " http-transport:try-start-server")
+	     (tasks:server-force-clean-run-record (tasks:get-db) run-id ipaddrstr portnum " http-transport:try-start-server")
 	     (print "ERROR: Tried and tried but could not start the server"))))
      ;; any error in following steps will result in a retry
      (set! *server-info* (list ipaddrstr portnum))
-     (open-run-close tasks:server-set-interface-port 
-		     tasks:open-db 
+     (tasks:server-set-interface-port 
+		     (tasks:get-db)
 		     server-id 
 		     ipaddrstr portnum)
      (debug:print 0 "INFO: Trying to start server on " ipaddrstr ":" portnum)
      ;; This starts the spiffy server
      ;; NEED WAY TO SET IP TO #f TO BIND ALL
@@ -173,11 +173,11 @@
 	 (start-server port: portnum bind-address: (if (equal? config-hostname "-")
 						       ipaddrstr
 						       config-hostname))
 	 (start-server port: portnum))
      ;;  (portlogger:open-run-close portlogger:set-port portnum "released")
-     (open-run-close tasks:server-force-clean-run-record tasks:open-db run-id ipaddrstr portnum " http-transport:try-start-server")
+     (tasks:server-force-clean-run-record (tasks:get-db) run-id ipaddrstr portnum " http-transport:try-start-server")
      (debug:print 1 "INFO: server has been stopped"))))
 
 ;;======================================================================
 ;; S E R V E R   U T I L I T I E S 
 ;;======================================================================
@@ -481,22 +481,22 @@
 	      (current-output-port *alt-log-file*)))))
   (if (server:check-if-running run-id)
       (begin
 	(debug:print 0 "INFO: Server for run-id " run-id " already running")
 	(exit 0)))
-  (let loop ((server-id (open-run-close tasks:server-lock-slot tasks:open-db run-id))
+  (let loop ((server-id (tasks:server-lock-slot (tasks:get-db) run-id))
 	     (remtries  4))
     (if (not server-id)
 	(if (> remtries 0)
 	    (begin
 	      (thread-sleep! 2)
-	      (loop (open-run-close tasks:server-lock-slot tasks:open-db run-id)
+	      (loop (tasks:server-lock-slot (tasks:get-db) run-id)
 		    (- remtries 1)))
 	    (begin
 	      ;; since we didn't get the server lock we are going to clean up and bail out
 	      (debug:print-info 2 "INFO: server pid=" (current-process-id) ", hostname=" (get-host-name) " not starting due to other candidates ahead in start queue")
-	      (open-run-close tasks:server-delete-records-for-this-pid tasks:open-db " http-transport:launch")
+	      (tasks:server-delete-records-for-this-pid tasks:get-db " http-transport:launch")
 	      ))
 	(let* ((th2 (make-thread (lambda ()
 				   (debug:print-info 0 "Server run thread started")
 				   (http-transport:run 
 				    (if (args:get-arg "-server")

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -348,11 +348,12 @@
       (hash-table-delete! args:arg-hash "-itempatt")))
 
 (on-exit (lambda ()
 	   (rmt:print-db-stats)
 	   (if *dbstruct-db* (db:close-all *dbstruct-db*))
-	   (if *megatest-db* (sqlite3:finalize! *megatest-db*))))
+	   (if *megatest-db* (sqlite3:finalize! *megatest-db*))
+	   (if *task-db*     (sqlite3:finalize! (vector-ref *task-db* 0)))))
 
 ;;======================================================================
 ;; Misc general calls
 ;;======================================================================
 

Index: rmt.scm
==================================================================
--- rmt.scm
+++ rmt.scm
@@ -63,11 +63,11 @@
 	 (connection-info (let ((cinfo (hash-table-ref/default *runremote* run-id #f)))
 			    (if cinfo
 				cinfo
 				;; NB// can cache the answer for server running for 10 seconds ...
 				;;  ;; (and (not (rmt:write-frequency-over-limit? cmd run-id))
-				(if (open-run-close tasks:server-running-or-starting? tasks:open-db run-id)
+				(if (tasks:server-running-or-starting? (tasks:get-db) run-id)
 				    (let ((res (client:setup run-id)))
 				      (if res 
 					  (hash-table-ref/default *runremote* run-id #f) ;; client:setup filled this in (hopefully)
 					  #f))
 				    #f))))

Index: server.scm
==================================================================
--- server.scm
+++ server.scm
@@ -91,11 +91,11 @@
 									      (conc " -daemonize -log " logfile)
 									      "")
 		      " -debug 4 "))) ;; (conc " >> " logfile " 2>&1 &")))))
     (debug:print 0 "INFO: Starting server (" cmdln ") as none running ...")
     (push-directory *toppath*)
-    (if (not (directory-exists? "logs"))(create-directory "logs"))
+    (if (not (directory-exists? "logs"))(create-directory "logs"))l
     ;; host.domain.tld match host?
     (if (and target-host 
 	     ;; look at target host, is it host.domain.tld or ip address and does it 
 	     ;; match current ip or hostname
 	     (not (string-match (conc "("curr-host "|" curr-host"\\..*)") target-host))
@@ -124,11 +124,11 @@
   (if (eq? run-id 0)
       (server:run run-id)
       (rmt:start-server run-id)))
 
 (define (server:check-if-running run-id)
-  (let loop ((server (open-run-close tasks:get-server tasks:open-db run-id))
+  (let loop ((server (tasks:get-server (tasks:get-db) run-id))
 	     (trycount 0))
     (if server
 	;; note: client:start will set *runremote*. this needs to be changed
 	;;       also, client:start will login to the server, also need to change that.
 	;;
@@ -140,11 +140,11 @@
 	  ;; if the server didn't respond we must remove the record
 	  (if res
 	      #t
 	      (begin
 		(debug:print-info 0 "server at " server " not responding, removing record")
-		(open-run-close tasks:server-force-clean-running-records-for-run-id tasks:open-db run-id 
+		(tasks:server-force-clean-running-records-for-run-id (tasks:get-db) run-id 
 				" server:check-if-running")
 		res)))
 	#f)))
 
 ;; called in megatest.scm, host-port is string hostname:port
@@ -153,11 +153,11 @@
   (let* ((host-port (let ((slst (string-split   host:port ":")))
 		      (if (eq? (length slst) 2)
 			  (list (car slst)(string->number (cadr slst)))
 			  #f)))
 	 (toppath       (launch:setup-for-run))
-	 (server-db-dat (if (not host-port)(open-run-close tasks:get-server tasks:open-db run-id) #f)))
+	 (server-db-dat (if (not host-port)(tasks:get-server (tasks:get-db) run-id) #f)))
     (if (not run-id)
 	  (begin
 	    (debug:print 0 "ERROR: must specify run-id when doing ping, -run-id n")
 	    (print "ERROR: No run-id")
 	    (exit 1))

Index: tasks.scm
==================================================================
--- tasks.scm
+++ tasks.scm
@@ -36,10 +36,17 @@
 		      (- count 1)))
 	      (begin
 		(if remove (system (conc "rm -rf " path)))
 		#f))
 	  #t))))
+
+(define (tasks:get-task-db-path)
+  (if *task-db*
+      (vector-ref *task-db* 1)
+      (let* ((linktree     (configf:lookup *configdat* "setup" "linktree"))
+	     (dbpath       (conc linktree "/.db/monitor.db")))
+	dbpath)))
 
 ;; If file exists AND
 ;;    file readable
 ;;         ==> open it
 ;; If file exists AND
@@ -47,12 +54,11 @@
 ;;         ==> open in-mem version
 ;; If file NOT exists
 ;;    ==> open in-mem version
 ;;
 (define (tasks:open-db)
-  (let* ((linktree     (configf:lookup *configdat* "setup" "linktree"))
-	 (dbpath       (conc linktree "/.db/monitor.db"))
+  (let* ((dbpath       (tasks:get-task-db-path))
 	 (avail        (tasks:wait-on-journal dbpath 10)) ;; wait up to about 10 seconds for the journal to go away
 	 (exists       (file-exists? dbpath))
 	 (write-access (file-write-access? dbpath))
 	 (mdb          (cond
 			((file-write-access? *toppath*)(sqlite3:open-database dbpath))
@@ -109,11 +115,19 @@
                                   logout_time TIMESTAMP DEFAULT -1,
                                 CONSTRAINT clients_constraint UNIQUE (pid,hostname));")
                                   
 	  ))
     mdb))
-    
+
+(define (tasks:get-db)
+  (if *task-db*
+      *task-db*
+      (let ((db  (tasks:open-db))
+	    (pth (tasks:get-task-db-path)))
+	(set! *task-db* (vector db pth))
+	db)))
+  
 ;;======================================================================
 ;; Server and client management
 ;;======================================================================
 
 ;; make-vector-record tasks hostinfo id interface port pubport transport pid hostname