Index: common.scm
==================================================================
--- common.scm
+++ common.scm
@@ -725,54 +725,10 @@
       (print-call-chain (current-error-port))
       #f)
     (read (open-input-string (base64:base64-decode instr))))
    (read (open-input-string (z3:decode-buffer (base64:base64-decode instr))))))
 
-;; dot-locking egg seems not to work, using this for now
-;; if lock is older than expire-time then remove it and try again
-;; to get the lock
-;;
-(define (common:simple-file-lock fname #!key (expire-time 300))
-  (let ((fmod-time (handle-exceptions
-		       ext
-		     (current-seconds)
-		     (file-modification-time fname))))
-    (if (common:file-exists? fname)
-	(if (> (- (current-seconds) fmod-time) expire-time)
-	    (begin
-	      (handle-exceptions exn #f (delete-file* fname))	
-	      (common:simple-file-lock fname expire-time: expire-time))
-	    #f)
-	(let ((key-string (conc (get-host-name) "-" (current-process-id))))
-	  (with-output-to-file fname
-	    (lambda ()
-	      (print key-string)))
-	  (thread-sleep! 0.25)
-	  (if (common:file-exists? fname)
-	      (handle-exceptions exn
-                #f 
-                (with-input-from-file fname
-	  	  (lambda ()
-		    (equal? key-string (read-line)))))
-	      #f)))))
-
-(define (common:simple-file-lock-and-wait fname #!key (expire-time 300))
-  (let ((end-time (+ expire-time (current-seconds))))
-    (let loop ((got-lock (common:simple-file-lock fname expire-time: expire-time)))
-      (if got-lock
-	  #t
-	  (if (> end-time (current-seconds))
-	      (begin
-		(thread-sleep! 3)
-		(loop (common:simple-file-lock fname expire-time: expire-time)))
-	      #f)))))
-
-(define (common:simple-file-release-lock fname)
-  (handle-exceptions
-      exn
-      #f ;; I don't really care why this failed (at least for now)
-    (delete-file* fname)))
 
 ;;======================================================================
 ;; S T A T E S   A N D   S T A T U S E S
 ;;======================================================================
 

Index: commonmod.scm
==================================================================
--- commonmod.scm
+++ commonmod.scm
@@ -17,16 +17,19 @@
 ;;     along with Megatest.  If not, see <http://www.gnu.org/licenses/>.
 
 ;;======================================================================
 
 (declare (unit commonmod))
+
+(use srfi-69)
 
 (module commonmod
 	*
-	
+
 (import scheme chicken data-structures extras files)
-(import (prefix sqlite3 sqlite3:) posix typed-records srfi-18 srfi-69
+(import (prefix sqlite3 sqlite3:)
+	posix typed-records srfi-18 srfi-69
 	md5 message-digest
 	regex srfi-1)
 
 ;;======================================================================
 ;; CONTENTS
@@ -83,10 +86,55 @@
 	'()))) ;; should it return empty list or #f to indicate not set?
 
 
 (define (get-section cfgdat section)
   (hash-table-ref/default cfgdat section '()))
+
+;; dot-locking egg seems not to work, using this for now
+;; if lock is older than expire-time then remove it and try again
+;; to get the lock
+;;
+(define (common:simple-file-lock fname #!key (expire-time 300))
+  (let ((fmod-time (handle-exceptions
+		       ext
+		     (current-seconds)
+		     (file-modification-time fname))))
+    (if (file-exists? fname) ;; (common:file-exists? fname)
+	(if (> (- (current-seconds) fmod-time) expire-time)
+	    (begin
+	      (handle-exceptions exn #f (delete-file* fname))	
+	      (common:simple-file-lock fname expire-time: expire-time))
+	    #f)
+	(let ((key-string (conc (get-host-name) "-" (current-process-id))))
+	  (with-output-to-file fname
+	    (lambda ()
+	      (print key-string)))
+	  (thread-sleep! 0.25)
+	  (if (file-exists? fname) ;; (common:file-exists? fname)
+	      (handle-exceptions exn
+                #f 
+                (with-input-from-file fname
+	  	  (lambda ()
+		    (equal? key-string (read-line)))))
+	      #f)))))
+
+(define (common:simple-file-lock-and-wait fname #!key (expire-time 300))
+  (let ((end-time (+ expire-time (current-seconds))))
+    (let loop ((got-lock (common:simple-file-lock fname expire-time: expire-time)))
+      (if got-lock
+	  #t
+	  (if (> end-time (current-seconds))
+	      (begin
+		(thread-sleep! 3)
+		(loop (common:simple-file-lock fname expire-time: expire-time)))
+	      #f)))))
+
+(define (common:simple-file-release-lock fname)
+  (handle-exceptions
+      exn
+      #f ;; I don't really care why this failed (at least for now)
+    (delete-file* fname)))
 
 ;;======================================================================
 ;; misc conversion, data manipulation functions
 ;;======================================================================
 

Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -71,10 +71,11 @@
 ;;
 (defstruct dbr:counts
   (state #f)
   (status #f)
   (count  0)) 
+
 
 ;;======================================================================
 ;; hash of hashs
 ;;======================================================================
 
@@ -128,11 +129,13 @@
    (apply sqlite3:first-result db stmt params)))
 
 (define (db:setup do-sync)
   (assert *toppath* "FATAL: db:setup called before launch:setup has been run.")
   (let* ((tmpdir (common:get-db-tmp-area)))
-    (dbfile:setup do-sync *toppath* tmpdir)))
+    (if (not *dbstruct-dbs*)
+	(dbfile:setup do-sync *toppath* tmpdir)
+	*dbstruct-dbs*)))
 
 ;; looks up subdb and returns it, if not found then set up
 ;; and then return it.
 ;;
 #;(define (db:get-db dbstruct run-id)
@@ -1917,16 +1920,18 @@
 	 (andstr    (if (> (length keys) 0) " AND " ""))
 	 (valslots  (keys->valslots keys)) ;; ?,?,? ...
 	 (allvals   (append (list runname state status user contour) (map cadr keyvals)))
 	 (qryvals   (append (list runname) (map cadr keyvals)))
 	 (key=?str  (string-intersperse (map (lambda (k)(conc k "=?")) keys) " AND ")))
+  (debug:print 0 *default-log-port* "Got here 0.")
     (debug:print 3 *default-log-port* "keys: " keys " allvals: " allvals " keyvals: " keyvals " key=?str is " key=?str)
     (debug:print 2 *default-log-port* "NOTE: using target " (string-intersperse (map cadr keyvals) "/") " for this run")
     (if (and runname (null? (filter (lambda (x)(not x)) keyvals))) ;; there must be a better way to "apply and"
 	(db:with-db
 	 dbstruct #f #f
 	 (lambda (dbdat db)
+  (debug:print 0 *default-log-port* "Got here 1.")
 	   (let ((res #f))
 	     (apply sqlite3:execute db (conc "INSERT OR IGNORE INTO runs (runname,state,status,owner,event_time,contour" comma keystr ") VALUES (?,?,?,?,strftime('%s','now'),?" comma valslots ");")
 		    allvals)
 	     (apply sqlite3:for-each-row 
 		    (lambda (id)

Index: dbfile.scm
==================================================================
--- dbfile.scm
+++ dbfile.scm
@@ -26,11 +26,12 @@
 	*
 	
   (import scheme
 	  chicken
 	  data-structures
-	  extras)
+	  extras
+	  matchable)
   
 (import (prefix sqlite3 sqlite3:)
 	posix typed-records srfi-18 srfi-1
 	srfi-69
 	stack
@@ -624,17 +625,37 @@
 ;;
 (define (db:no-sync-get-lock db keyname)
   (sqlite3:with-transaction
    db
    (lambda ()
-     (handle-exceptions
-	 exn
-	 (let ((lock-time (current-seconds)))
-	   ;; (debug:print-info 2 *default-log-port* "db:no-sync-get-lock keyname=" keyname ", lock-time=" lock-time ", exn=" exn)
-	   (sqlite3:execute db "INSERT INTO no_sync_metadat (var,val) VALUES(?,?);" keyname lock-time)
-	   `(#t . ,lock-time))
-       `(#f . ,(sqlite3:first-result db "SELECT val FROM no_sync_metadat WHERE var=?;" keyname))))))
+     (condition-case
+	 `(#f . ,(sqlite3:first-result db "SELECT val FROM no_sync_metadat WHERE var=?;" keyname))
+       
+       (exn (io-error)  (dbfile:print-err "ERROR: i/o error with no-sync db. Check permissions, disk space etc. and try again."))
+       (exn (corrupt)   (dbfile:print-err "ERROR: database no-sync db is corrupt. Repair it to proceed."))
+       (exn (busy)      (dbfile:print-err "ERROR: database no-sync db is locked. Try copying to another location, remove original and copy back."))
+       (exn (permission)(dbfile:print-err "ERROR: database no-sync db has some permissions problem."))
+       (exn (done)
+	    (let ((lock-time (current-seconds)))
+	      ;; (debug:print-info 2 *default-log-port* "db:no-sync-get-lock keyname=" keyname ", lock-time=" lock-time ", exn=" exn)
+	      (sqlite3:execute db "INSERT OR REPLACE INTO no_sync_metadat (var,val) VALUES(?,?);" keyname lock-time)
+	      `(#t . ,lock-time)))
+       (exn ()
+	    (dbfile:print-err "ERROR: Unknown error with database no-sync db message: exn="(condition->list exn)", \n" ((condition-property-accessor 'exn 'message) exn))
+	    `(#f . ,(current-seconds)))))))
+
+(define (db:no-sync-get-lock-timeout db keyname timeout)
+  (let* ((lockdat (db:no-sync-get-lock db keyname)))
+    (match lockdat
+      ((#f . lock-time)
+       (if (> (- (current-seconds) (if (string? lock-time)(string->number lock-time)lock-time)) timeout)
+	   (let ((lock-time (current-seconds)))
+	     ;; (debug:print-info 2 *default-log-port* "db:no-sync-get-lock keyname=" keyname ", lock-time=" lock-time ", exn=" exn)
+	     (sqlite3:execute db "INSERT OR REPLACE INTO no_sync_metadat (var,val) VALUES(?,?);" keyname lock-time)
+	     `(#t . ,lock-time))
+	   lockdat))
+      (else lockdat))))
 
 ;;======================================================================
 ;; sync back functions pulled from db.scm
 ;;======================================================================
 
@@ -641,18 +662,40 @@
 ;; Get a lock from the no-sync-db for the from-db, then delta sync the from-db to the to-db, otherwise return #f
 ;;
 (define (db:lock-and-delta-sync no-sync-db dbstruct from-db-file runid keys dbinit)
   (assert (not *db-sync-in-progress*) "FATAL: db:lock-and-sync called while a sync is in progress.")
   ;; (dbfile:print-err *default-log-port* "db:lock-and-delta-sync")
-  (let* ((lockdat  (db:no-sync-get-lock no-sync-db from-db-file))
+  (let* ((lock-file (conc from-db-file ".lock")))
+    (if (common:simple-file-lock lock-file)
+	(begin
+	  (dbfile:print-err "INFO: db:lock-and-delta-sync copying db "runid" at "(current-seconds))
+	  (set! *db-sync-in-progress* #t)
+	  (db:sync-touched dbstruct runid keys dbinit)
+	  (set! *db-sync-in-progress* #f)
+	  (delete-file* lock-file)
+	  #t)
+        (begin
+          (dbfile:print-err "ERROR: could not get lock for " from-db-file " from no-sync-db")
+	  #f
+	  ))))
+
+;; Get a lock from the no-sync-db for the from-db, then delta sync the from-db to the to-db, otherwise return #f
+;;
+(define (db:lock-and-delta-sync-orig no-sync-db dbstruct from-db-file runid keys dbinit)
+  (assert (not *db-sync-in-progress*) "FATAL: db:lock-and-sync called while a sync is in progress.")
+  ;; (dbfile:print-err *default-log-port* "db:lock-and-delta-sync")
+  (let* ((lockdat  (db:no-sync-get-lock-timeout no-sync-db from-db-file 60))
 	 (gotlock  (car lockdat))
 	 (locktime (cdr lockdat)))
     ;; (debug:print-info 3 *default-log-port* "db:lock-and-delta-sync: got lock?")
+    
     (if gotlock
 	(begin
           (dbfile:print-err "INFO: db:lock-and-delta-sync copying db "runid" at "(current-seconds))
+	  (set! *db-sync-in-progress* #t)
           (db:sync-touched dbstruct runid keys dbinit)
+	  (set! *db-sync-in-progress* #f)
 	  (db:no-sync-del! no-sync-db from-db-file)
 	  #t)
         (begin
           (dbfile:print-err "ERROR: could not get lock for " from-db-file " from no-sync-db")
 	  #f
@@ -1006,11 +1049,11 @@
 	  (lambda (dat)
 	    (let ((tblname (car dat))
 		  (count   (cdr dat)))
 	      (set! tot-count (+ tot-count count))
 	      (if (> count 0)
-		  (if should-print (dbfile:print-err  (format #f "    ~10a ~5a" tblname count))))))
+		  (if should-print (dbfile:print-err "FIXME: tblname: " tblname", count: "count" "))))) ;; (format #f "    ~10a ~5a" tblname count))))))
 	  (sort (hash-table->alist numrecs)(lambda (a b)(> (cdr a)(cdr b))))))
        tot-count)))))
 
 ;;======================================================================
 ;; trigger setup/takedown
@@ -1113,18 +1156,20 @@
 ;;
 (define (db:open-db dbstruct run-id dbinit)
   (let* ((dbdat (dbfile:open-db dbstruct run-id dbinit)))
     (set! *db-write-access* (not (dbr:dbdat-read-only dbdat)))
     dbdat))
+
+(define dbfile:db-init-proc (make-parameter #f))
 
 ;; (db:with-db dbstruct run-id sqlite3:exec "select blah fgrom blaz;")
 ;; r/w is a flag to indicate if the db is modified by this query #t = yes, #f = no
 ;;
 (define (db:with-db dbstruct run-id r/w proc . params)
   (let* ((have-struct (dbr:dbstruct? dbstruct))
          (dbdat     (if have-struct                ;; this stuff just allows us to call with a db handle directly
-			(db:open-db dbstruct run-id) ;; (dbfile:get-subdb dbstruct run-id)
+			(db:open-db dbstruct run-id (dbfile:db-init-proc)) ;; (dbfile:get-subdb dbstruct run-id)
 			#f))
 	 (db        (if have-struct                ;; this stuff just allows us to call with a db handle directly
 			(dbr:dbdat-dbh dbdat)
 			dbstruct))
 	 (fname     (if dbdat

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -40,10 +40,11 @@
 (declare (uses mt))
 (declare (uses api))
 (declare (uses tasks)) ;; only used for debugging.
 (declare (uses env))
 (declare (uses diff-report))
+(declare (uses db))
 (declare (uses dbmod))
 (declare (uses dbmod.import))
 (declare (uses commonmod))
 (declare (uses commonmod.import))
 (declare (uses dbfile))
@@ -78,10 +79,12 @@
 
 (require-library mutils)
 
 (define *usage-log-file* #f)    ;; put path to file for logging usage in this var in the ~/.megatestrc file
 (define *usage-use-seconds* #t) ;; for Epoc seconds in usage logging change this to #t in ~/.megatestrc file
+
+(dbfile:db-init-proc db:initialize-main-db)
 
 ;; load the ~/.megatestrc file, put (use trace)(trace-call-sites #t)(trace function-you-want-to-trace) in this file
 ;;
 (let ((debugcontrolf (conc (get-environment-variable "HOME") "/.megatestrc")))
   (if (common:file-exists? debugcontrolf)

Index: rmt.scm
==================================================================
--- rmt.scm
+++ rmt.scm
@@ -21,14 +21,15 @@
 (use format typed-records) ;; RADT => purpose of json format??
 
 (declare (unit rmt))
 (declare (uses api))
 (declare (uses http-transport))
+(declare (uses dbfile))
 (include "common_records.scm")
 ;; (declare (uses rmtmod))
 
-;; (import rmtmod)
+(import dbfile) ;; rmtmod)
 
 ;;
 ;; THESE ARE ALL CALLED ON THE CLIENT SIDE!!!
 ;;
 

Index: server.scm
==================================================================
--- server.scm
+++ server.scm
@@ -23,18 +23,22 @@
 
 (use spiffy uri-common intarweb http-client spiffy-request-vars)
 
 (declare (unit server))
 
+(declare (uses commonmod))
+
 (declare (uses common))
 (declare (uses db))
 (declare (uses tasks)) ;; tasks are where stuff is maintained about what is running.
 ;; (declare (uses synchash))
 (declare (uses http-transport))
 ;;(declare (uses rpc-transport))
 (declare (uses launch))
 ;; (declare (uses daemon))
+
+(import commonmod)
 
 (include "common_records.scm")
 (include "db_records.scm")
 
 (define (server:make-server-url hostport)

Index: tasks.scm
==================================================================
--- tasks.scm
+++ tasks.scm
@@ -20,15 +20,17 @@
 
 (use sqlite3 srfi-1 posix regex regex-case srfi-69 dot-locking format)
 (import (prefix sqlite3 sqlite3:))
 
 (declare (unit tasks))
+(declare (uses dbfile))
 (declare (uses db))
 (declare (uses rmt))
 (declare (uses common))
 (declare (uses pgdb))
 
+(import dbfile)
 ;; (import pgdb) ;; pgdb is a module
 
 (include "task_records.scm")
 (include "db_records.scm")