Index: api.scm
==================================================================
--- api.scm
+++ api.scm
@@ -34,19 +34,23 @@
     ((test-set-status-state)           (apply db:test-set-status-state db params))
     ((get-previous-test-run-record)    (apply db:get-previous-test-run-record db params))
     ((get-matching-previous-test-run-records)(map vector->list (apply db:get-matching-previous-test-run-records db params)))
     ((db:test-get-logfile-info)        (apply db:test-get-logfile-info db params))
     ((test-get-records-for-index-file  (apply db:test-get-records-for-index-file db params)))
-    ((get-testinfo-state-status)       (apply db:get-testinfo-state-status db params))
+    ((get-testinfo-state-status)       (let ((res (apply db:get-testinfo-state-status db params)))
+					 (if (vector? res)
+					     (vector->list res)
+					     res)))
     ((test-get-paths-matching-keynames-target-new) (apply db:test-get-paths-matching-keynames-target-new db params))
     ((get-prereqs-not-met)             (let ((res (apply db:get-prereqs-not-met db params)))
 					 (map (lambda (x)
 						(if (vector? x)
 						    (vector->list x)
 						    x))
 					      res)))
-					 
+    ((roll-up-pass-fail-counts)        (apply db:roll-up-pass-fail-counts db params))
+    
 
     ;; RUNS
     ((get-run-info)                 (let ((res (apply db:get-run-info db params)))
 				      (list (vector-ref res 0)
 					    (vector->list (vector-ref res 1)))))
@@ -71,10 +75,11 @@
     ;; MISC
     ((login)                        (apply db:login db params))
     ((general-call)                 (let ((stmtname   (car params))
 					  (realparams (cdr params)))
 				      (db:general-call db stmtname realparams)))
+    ((sync-inmem->db)               (db:sync-back))
     ((kill-server)
      (db:sync-to *inmemdb* *db*)
      (let ((hostname (car  *runremote*))
 	   (port     (cadr *runremote*))
 	   (pid      (if (null? params) #f (car params)))

Index: dashboard-tests.scm
==================================================================
--- dashboard-tests.scm
+++ dashboard-tests.scm
@@ -314,56 +314,56 @@
       (for-each 
        (lambda (step)
 	 (debug:print 6 "step=" step)
 	 (let ((record (hash-table-ref/default 
 			res 
-			(db:step-get-stepname step) 
+			(tdb:step-get-stepname step) 
 			;;        stepname                start end status Duration  Logfile 
-			(vector (db:step-get-stepname step) ""   "" ""     ""        ""))))
+			(vector (tdb:step-get-stepname step) ""   "" ""     ""        ""))))
 	   (debug:print 6 "record(before) = " record 
-			"\nid:       " (db:step-get-id step)
-			"\nstepname: " (db:step-get-stepname step)
-			"\nstate:    " (db:step-get-state step)
-			"\nstatus:   " (db:step-get-status step)
-			"\ntime:     " (db:step-get-event_time step))
-	   (case (string->symbol (db:step-get-state step))
-	     ((start)(vector-set! record 1 (db:step-get-event_time step))
+			"\nid:       " (tdb:step-get-id step)
+			"\nstepname: " (tdb:step-get-stepname step)
+			"\nstate:    " (tdb:step-get-state step)
+			"\nstatus:   " (tdb:step-get-status step)
+			"\ntime:     " (tdb:step-get-event_time step))
+	   (case (string->symbol (tdb:step-get-state step))
+	     ((start)(vector-set! record 1 (tdb:step-get-event_time step))
 	      (vector-set! record 3 (if (equal? (vector-ref record 3) "")
-					(db:step-get-status step)))
-	      (if (> (string-length (db:step-get-logfile step))
+					(tdb:step-get-status step)))
+	      (if (> (string-length (tdb:step-get-logfile step))
 		     0)
-		  (vector-set! record 5 (db:step-get-logfile step))))
+		  (vector-set! record 5 (tdb:step-get-logfile step))))
 	     ((end)  
-	      (vector-set! record 2 (any->number (db:step-get-event_time step)))
-	      (vector-set! record 3 (db:step-get-status step))
+	      (vector-set! record 2 (any->number (tdb:step-get-event_time step)))
+	      (vector-set! record 3 (tdb:step-get-status step))
 	      (vector-set! record 4 (let ((startt (any->number (vector-ref record 1)))
 					  (endt   (any->number (vector-ref record 2))))
 				      (debug:print 4 "record[1]=" (vector-ref record 1) 
 						   ", startt=" startt ", endt=" endt
-						   ", get-status: " (db:step-get-status step))
+						   ", get-status: " (tdb:step-get-status step))
 				      (if (and (number? startt)(number? endt))
 					  (seconds->hr-min-sec (- endt startt)) "-1")))
-	      (if (> (string-length (db:step-get-logfile step))
+	      (if (> (string-length (tdb:step-get-logfile step))
 		     0)
-		  (vector-set! record 5 (db:step-get-logfile step))))
+		  (vector-set! record 5 (tdb:step-get-logfile step))))
 	     (else
-	      (vector-set! record 2 (db:step-get-state step))
-	      (vector-set! record 3 (db:step-get-status step))
-	      (vector-set! record 4 (db:step-get-event_time step))))
-	   (hash-table-set! res (db:step-get-stepname step) record)
+	      (vector-set! record 2 (tdb:step-get-state step))
+	      (vector-set! record 3 (tdb:step-get-status step))
+	      (vector-set! record 4 (tdb:step-get-event_time step))))
+	   (hash-table-set! res (tdb:step-get-stepname step) record)
 	   (debug:print 6 "record(after)  = " record 
-			"\nid:       " (db:step-get-id step)
-			"\nstepname: " (db:step-get-stepname step)
-			"\nstate:    " (db:step-get-state step)
-			"\nstatus:   " (db:step-get-status step)
-			"\ntime:     " (db:step-get-event_time step))))
-       ;; (else   (vector-set! record 1 (db:step-get-event_time step)))
+			"\nid:       " (tdb:step-get-id step)
+			"\nstepname: " (tdb:step-get-stepname step)
+			"\nstate:    " (tdb:step-get-state step)
+			"\nstatus:   " (tdb:step-get-status step)
+			"\ntime:     " (tdb:step-get-event_time step))))
+       ;; (else   (vector-set! record 1 (tdb:step-get-event_time step)))
        (sort steps (lambda (a b)
 		     (cond
-		      ((<   (db:step-get-event_time a)(db:step-get-event_time b)) #t)
-		      ((eq? (db:step-get-event_time a)(db:step-get-event_time b)) 
-		       (<   (db:step-get-id a)        (db:step-get-id b)))
+		      ((<   (tdb:step-get-event_time a)(tdb:step-get-event_time b)) #t)
+		      ((eq? (tdb:step-get-event_time a)(tdb:step-get-event_time b)) 
+		       (<   (tdb:step-get-id a)        (tdb:step-get-id b)))
 		      (else #f)))))
       res))
 
 (define (dashboard-tests:get-compressed-steps test-id #!key (work-area #f))
   (if (or (not work-area)

Index: dashboard.scm
==================================================================
--- dashboard.scm
+++ dashboard.scm
@@ -1428,11 +1428,11 @@
   (or please-update-buttons
       (and (> (current-milliseconds)(+ *last-recalc-ended-time* 150))
 	   (> modtime last-db-update-time)
 	   (> (current-seconds)(+ last-db-update-time 1)))))
 
-(define *monitor-db-path* (conc *toppath* "/monitor.db"))
+(define *monitor-db-path* (conc *toppath* "/db/monitor.db"))
 (define *last-monitor-update-time* 0)
 
 ;; Force creation of the db in case it isn't already there.
 (let ((db (tasks:open-db)))
   (sqlite3:finalize! db))

Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -72,12 +72,12 @@
 	  (begin
 	    (debug:print 0 "ERROR: Attempted to open db when not in megatest area. Exiting.")
 	    (exit))))
   (let* ((dbpath    (conc *toppath* "/megatest.db")) ;; fname)
 	 (dbexists  (file-exists? dbpath))
-	 (write-access (file-write-access? dbpath))
 	 (db        (sqlite3:open-database dbpath)) ;; (never-give-up-open-db dbpath))
+	 (write-access (file-write-access? dbpath))
 	 (handler   (make-busy-timeout (if (args:get-arg "-override-timeout")
 					   (string->number (args:get-arg "-override-timeout"))
 					   136000)))) ;; 136000))) ;; 136000 = 2.2 minutes
     (if (and dbexists
 	     (not write-access))
@@ -96,12 +96,16 @@
 	 (exists (and path (file-exists? fname)))
 	 (db     (if path
 		     (begin
 		       (create-directory path #t)
 		       (sqlite3:open-database fname))
-		     (sqlite3:open-database ":memory:"))))
-    (if (not exists) (db:initialize db))
+		     (sqlite3:open-database ":memory:")))
+	 (handler   (make-busy-timeout 3600)))
+    (if (or (not path)
+	    (not exists))
+	(db:initialize db))
+    (sqlite3:set-busy-handler! db handler)
     db))
 
 (define (db:sync-to fromdb todb)
   ;; strategy
   ;;  1. Get all run-ids
@@ -1169,23 +1173,13 @@
      db 
      qry
      )
     res))
 
-(define (db:delete-test-records db tdb test-id #!key (force #f))
-  (if tdb 
-      (begin
-	(sqlite3:execute tdb "DELETE FROM test_steps;")
-	(sqlite3:execute tdb "DELETE FROM test_data;"))
-      (tdb:delete-test-step-records db test-id))
-  (if db 
-      (begin
-	(sqlite3:execute db "DELETE FROM test_steps WHERE test_id=?;" test-id)
-	(sqlite3:execute db "DELETE FROM test_data  WHERE test_id=?;" test-id)
-	(if force
-	    (sqlite3:execute db "DELETE FROM tests WHERE id=?;" test-id)
-	    (sqlite3:execute db "UPDATE tests SET state='DELETED',status='n/a',comment='' WHERE id=?;" test-id)))))
+(define (db:delete-test-records db test-id)
+  (tdb:delete-test-step-records db test-id)
+  (sqlite3:execute db "UPDATE tests SET state='DELETED',status='n/a',comment='' WHERE id=?;" test-id))
 
 (define (db:delete-tests-for-run db run-id)
   (sqlite3:execute db "DELETE FROM tests WHERE run_id=?;" run-id))
 
 (define (db:delete-old-deleted-test-records db)
@@ -1638,10 +1632,21 @@
 ;; 	  (not (member proc *db:all-write-procs*)))
 ;;       (apply cdb:client-call *runremote* 'immediate #f *default-numtries* open-run-close proc #f params)
 ;;       (begin
 ;; 	(debug:print 0 "ERROR: Attempt to access read-only database")
 ;; 	#f)))
+
+(define (rmt:roll-up-pass-fail-counts run-id test-name item-path status)
+  (if (and (not (equal? item-path ""))
+	   (member status '("PASS" "WARN" "FAIL" "WAIVED" "RUNNING" "CHECK" "SKIP")))
+      (begin
+	(db:general-call 'update-pass-fail-counts db (list run-id test-name run-id test-name))
+	(if (equal? status "RUNNING")
+	    (db:general-call 'top-test-set-running db (list run-id test-name))
+	    (db:general-call 'top-test-set-per-pf-counts db (list run-id test-name run-id test-name)))
+	#f)
+      #f))
 
 (define (db:test-get-logfile-info db run-id test-name)
   (let ((res #f))
     (sqlite3:for-each-row 
      (lambda (path final_logf)
@@ -1887,11 +1892,11 @@
 	  ;; if found then return that matching test record
 	  (debug:print 4 "selstr: " selstr ", qrystr: " qrystr ", keyvals: " keyvals ", previous run ids found: " prev-run-ids)
 	  (if (null? prev-run-ids) #f
 	      (let loop ((hed (car prev-run-ids))
 			 (tal (cdr prev-run-ids)))
-		(let ((results (db:get-tests-for-run db hed (conc test-name "/" item-path)'() '() #f #f #f #f #f)))
+		(let ((results (db:get-tests-for-run db 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)
 		  (if (and (null? results)
 			   (not (null? tal)))
 		      (loop (car tal)(cdr tal))
 		      (if (null? results) #f
@@ -1928,11 +1933,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 db hed (conc test-name "/" item-path) '() '() #f #f #f #f #f)))
+		(let ((results (db:get-tests-for-run db 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)

Index: ezsteps.scm
==================================================================
--- ezsteps.scm
+++ ezsteps.scm
@@ -98,11 +98,11 @@
 		    (let ((exinfo (vector-ref exit-info 2))
 			  (logfna (if logpro-used (conc stepname ".html") "")))
 		      ;; testing if procedures called in a remote call cause problems (ans: no or so I suspect)
 		      (db:teststep-set-status! #f test-id stepname "end" exinfo #f logfna work-area: test-run-dir))
 		    (if logpro-used
-			(cdb:test-set-log! *runremote*  test-id (conc stepname ".html")))
+			(rmt:test-set-log! test-id (conc stepname ".html")))
 		    ;; set the test final status
 		    (let* ((this-step-status (cond
 					      ((and (eq? (vector-ref exit-info 2) 2) logpro-used) 'warn)
 					      ((eq? (vector-ref exit-info 2) 0)                   'pass)
 					      (else 'fail)))

Index: http-transport.scm
==================================================================
--- http-transport.scm
+++ http-transport.scm
@@ -74,11 +74,11 @@
 	 (hostname        (get-host-name))
 	 (ipaddrstr       (let ((ipstr (if (string=? "-" hostn)
 					   ;; (string-intersperse (map number->string (u8vector->list (hostname->ip hostname))) ".")
 					   (server:get-best-guess-address hostname)
 					   #f)))
-			    (if ipstr ipstr hostn))) ;; hostname)))
+			    (if ipstr ipstr hostn))) ;; hostname))) 
 	 (start-port    (if (and (args:get-arg "-port")
 				 (string->number (args:get-arg "-port")))
 			    (string->number (args:get-arg "-port"))
 			    (if (and (config-lookup  *configdat* "server" "port")
 				     (string->number (config-lookup  *configdat* "server" "port")))

Index: launch.scm
==================================================================
--- launch.scm
+++ launch.scm
@@ -146,11 +146,11 @@
 	  (alist->env-vars env-ovrd)
 	  (set-megatest-env-vars run-id inkeys: keys inkeyvals: keyvals)
 	  (set-item-env-vars itemdat)
 	  (save-environment-as-files "megatest")
 	  ;; open-run-close not needed for test-set-meta-info
-	  (tests:set-full-meta-info #f test-id run-id 0 work-area)
+	  (tests:set-full-meta-info test-id run-id 0 work-area)
 
 	  ;; (tests:test-set-status! test-id "REMOTEHOSTSTART" "n/a" (args:get-arg "-m") #f)
 	  (tests:test-force-state-status! test-id "REMOTEHOSTSTART" "n/a")
 	  (thread-sleep! 0.3) ;; NFS slowness has caused grief here
 

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -622,11 +622,11 @@
 				(db:test-get-status test)
 				(db:test-get-run_duration test)
 				(db:test-get-event_time test)
 				(db:test-get-host test))
 			(if (not (or (equal? (db:test-get-status test) "PASS")
-				     (equal? (db:test-get-status test) "WARN")
+			   	     (equal? (db:test-get-status test) "WARN")
 				     (equal? (db:test-get-state test)  "NOT_STARTED")))
 			    (begin
 			      (print   "         cpuload:  " (db:test-get-cpuload test)
 				     "\n         diskfree: " (db:test-get-diskfree test)
 				     "\n         uname:    " (db:test-get-uname test)
@@ -903,11 +903,11 @@
 	    (begin
 	      (debug:print 0 "Failed to setup, exiting")
 	      (exit 1)))
 	(if (and state status)
 	    ;; DO NOT remote run, makes calls to the testdat.db test db.
-	    (db:teststep-set-status! db test-id step state status msg logfile work-area: work-area)
+	    (tdb:teststep-set-status! test-id step state status msg logfile work-area: work-area)
 	    (begin
 	      (debug:print 0 "ERROR: You must specify :state and :status with every call to -step")
 	      (exit 6))))))
 
 (if (args:get-arg "-step")
@@ -962,14 +962,14 @@
 	  ;; (client:setup)
 
 	  (if (args:get-arg "-load-test-data")
 	      ;; has sub commands that are rdb:
 	      ;; DO NOT put this one into either cdb:remote-run or open-run-close
-	      (db:load-test-data db test-id work-area: work-area))
+	      (tdb:load-test-data test-id work-area: work-area))
 	  (if (args:get-arg "-setlog")
 	      (let ((logfname (args:get-arg "-setlog")))
-		(cdb:test-set-log! *runremote* test-id logfname)))
+		(rmt:test-set-log! test-id logfname)))
 	  (if (args:get-arg "-set-toplog")
 	      ;; DO NOT run remote
 	      (tests:test-set-toplog! db run-id test-name (args:get-arg "-set-toplog")))
 	  (if (args:get-arg "-summarize-items")
 	      ;; DO NOT run remote
@@ -994,11 +994,11 @@
 			 (fullcmd    (conc "(" (string-intersperse 
 						(cons cmd params) " ")
 					   ") " redir " " logfile)))
 		    ;; mark the start of the test
 		    ;; DO NOT run remote
-		    (db:teststep-set-status! db test-id stepname "start" "n/a" (args:get-arg "-m") logfile work-area: work-area)
+		    (tdb:teststep-set-status! test-id stepname "start" "n/a" (args:get-arg "-m") logfile work-area: work-area)
 		    ;; run the test step
 		    (debug:print-info 2 "Running \"" fullcmd "\" in directory \"" startingdir)
 		    (change-directory startingdir)
 		    (set! exitstat (system fullcmd)) ;; cmd params))
 		    (set! *globalexitstatus* exitstat)
@@ -1011,14 +1011,14 @@
 			  (debug:print-info 2 "running \"" cmd "\"")
 			  (change-directory startingdir)
 			  (set! exitstat (system cmd))
 			  (set! *globalexitstatus* exitstat) ;; no necessary
 			  (change-directory testpath)
-			  (cdb:test-set-log! *runremote* test-id htmllogfile)))
+			  (rmt:test-set-log! test-id htmllogfile)))
 		    (let ((msg (args:get-arg "-m")))
 		      ;; DO NOT run remote
-		      (db:teststep-set-status! db test-id stepname "end" exitstat msg logfile work-area: work-area))
+		      (tdb:teststep-set-status! test-id stepname "end" exitstat msg logfile work-area: work-area))
 		    )))
 	  (if (or (args:get-arg "-test-status")
 		  (args:get-arg "-set-values"))
 	      (let ((newstatus (cond
 				((number? status)       (if (equal? status 0) "PASS" "FAIL"))

Index: rmt.scm
==================================================================
--- rmt.scm
+++ rmt.scm
@@ -74,10 +74,13 @@
 
 ;; hand off a call to one of the db:queries statements
 (define (rmt:general-call stmtname . params)
   (rmt:send-receive 'general-call (append (list stmtname) params)))
 
+(define (rmt:sync-inmem->db)
+  (rmt:send-receive 'sync-inmem->db '()))
+
 ;;======================================================================
 ;;  K E Y S 
 ;;======================================================================
 
 (define (rmt:get-key-val-pairs run-id)
@@ -134,18 +137,21 @@
 
 (define (rmt:get-matching-previous-test-run-records run-id test-name item-path)
   (map list->vector 
        (rmt:send-receive 'get-matching-previous-test-run-records (list run-id test-name item-path))))
 
-(define (rmt:db:test-get-logfile-info run-id test-name)
+(define (rmt:test-get-logfile-info run-id test-name)
   (rmt:send-receive 'test-get-logfile-info (list run-id test-name)))
 
 (define (rmt:test-get-records-for-index-file run-id test-name)
   (rmt:send-receive 'test-get-records-for-index-file (list  run-id test-name)))
 
 (define (rmt:get-testinfo-state-status test-id)
-  (rmt:send-receive 'get-testinfo-state-status (list test-id)))
+  (let ((res (rmt:send-receive 'get-testinfo-state-status (list test-id))))
+    (if (list? res)
+	(list->vector res)
+	res)))
 
 (define (rmt:test-set-log! test-id logf)
   (if (string? logf)(rmt:general-call 'test-set-log logf test-id)))
 
 (define (rmt:test-get-paths-matching-keynames-target-new keynames target res testpatt statepatt statuspatt runname)

Index: tasks.scm
==================================================================
--- tasks.scm
+++ tasks.scm
@@ -426,11 +426,11 @@
 ;; 
 (define (tasks:start-monitor db mdb)
   (if (> (tasks:get-num-alive-monitors mdb) 2) ;; have two running, no need for more
       (debug:print-info 1 "Not starting monitor, already have more than two running")
       (let* ((megatestdb     (conc *toppath* "/megatest.db"))
-	     (monitordbf     (conc *toppath* "/monitor.db"))
+	     (monitordbf     (conc *toppath* "/db/monitor.db"))
 	     (last-db-update 0)) ;; (file-modification-time megatestdb)))
 	(task:register-monitor mdb)
 	(let loop ((count      0)
 		   (next-touch 0)) ;; next-touch is the time where we need to update last_update
 	  ;; if the db has been modified we'd best look at the task queue

Index: tests/Makefile
==================================================================
--- tests/Makefile
+++ tests/Makefile
@@ -1,10 +1,11 @@
 #
 # run some tests
 
 BINPATH=$(shell readlink -m $(PWD)/../bin)
 MEGATEST=$(BINPATH)/megatest
+DASHBOARD=$(BINPATH)/dashboard
 PATH := $(BINPATH):$(PATH)
 RUNNAME := $(shell date +w%V.%u.%H.%M)
 IPADDR := "-"
 # Set SERVER to "-server -"
 SERVER  = 
@@ -106,27 +107,27 @@
 
 test9 : minsetup test9a test9b test9c test9d test9e
 
 test9a :
 	@echo Run super-simple mintest e, no waitons.
-	cd mintest;megatest -runtests e -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
+	cd mintest;$(MEGATEST) -runtests e -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
 
 test9b :
 	@echo Run simple mintest d with one waiton c
-	cd mintest;megatest -runtests d -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
+	cd mintest;$(MEGATEST) -runtests d -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
 
 test9c :
 	@echo Run mintest a with full waiton chain a -> b -> c -> d -> e
-	cd mintest;megatest -runtests a -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
+	cd mintest;$(MEGATEST) -runtests a -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
 
 test9d :
 	@echo Run an itemized test with no items
-	cd mintest;megatest -runtests g -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
+	cd mintest;$(MEGATEST) -runtests g -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
 
 test9e :
 	@echo Run mintest a1 with full waiton chain with d1fail: a1 -> b1 -> c1 -> d1fail -> e1
-	cd mintest;megatest -runtests a1 -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
+	cd mintest;$(MEGATEST) -runtests a1 -target $(VER) :runname `date +%H.%M.%S` -debug $(DEBUG)
 
 test10 :
 	@echo Run a bunch of different targets simultaneously
 	(cd fullrun;$(MEGATEST) -server - ;sleep 2)&
 	for targ in mint/btrfs/mintdir sunos/sshfs/loc; do \
@@ -141,14 +142,14 @@
 	 cd fullrun;time (for a in 1 2 3 4 5 6 7 8 9 10  1 2 3 4 5 6 7 8 9 10  1 2 3 4 5 6 7 8 9 10  1 2 3 4 5 6 7 8 9 10 ;do   (megatest -test-paths -target %/%/% > /dev/null ) & done; wait; )
 
 minsetup : 
 	cd ..;make && make install
 	mkdir -p mintest/runs mintest/links
-	cd mintest;megatest -stop-server 0
-	cd mintest;megatest -server - -debug $(DEBUG) > server.log 2> server.log & 
+	cd mintest;$(MEGATEST) -stop-server 0
+	cd mintest;$(MEGATEST) -server - -debug $(DEBUG) > server.log 2> server.log & 
 	sleep 3
-	cd mintest;dashboard -rows 18 &
+	cd mintest;$(DASHBOARD) -rows 18 &
 
 cleanprep : ../*.scm Makefile */*.config
 	mkdir -p fullrun/tmp/mt_runs fullrun/tmp/mt_links
 	cd ..;make;make install
 	rm -f */logging.db
@@ -170,16 +171,16 @@
 clean  : 
 	rm cleanprep
 
 kill :
 	killall -v mtest main.sh dboard || true
-	rm -f */megatest.db */logging.db */monitor.db || true
+	rm -rf */megatest.db */logging.db */monitor.db fullrun/tmp/mt_*/* || true
 	killall -v mtest dboard || true
 
 hardkill : kill
-	sleep 5;killall -v mtest main.sh dboard -9
+	sleep 2;killall -v mtest main.sh dboard -9
 
 listservers :
 	cd fullrun;$(MEGATEST) -list-servers
 
 runforever :
 	while(ls); do runname=`date +%F-%R:%S`;(cd fullrun;$(MEGATEST) -runall -target ubuntu/nfs/none :runname $$runname;/home/matt/data/megatest/megatest -runall -target ubuntu/nfs/none :runname $$runname;/home/matt/data/megatest/megatest -runall -target ubuntu/nfs/none :runname $$runname);done

Index: tests/mintest/megatest.config
==================================================================
--- tests/mintest/megatest.config
+++ tests/mintest/megatest.config
@@ -2,10 +2,11 @@
 X TEXT
 
 [setup]
 max_concurrent_jobs 50
 linktree #{getenv PWD}/linktree
+transport http
 
 [server]
 port 8090
 
 [jobtools]

Index: tests/rununittest.sh
==================================================================
--- tests/rununittest.sh
+++ tests/rununittest.sh
@@ -3,12 +3,12 @@
 # Usage: rununittest.sh testname debuglevel
 #
 
 # Clean setup
 #
-rm -f simplerun/megatest.db
+rm -f simplerun/megatest.db simplerun/monitor.db simplerun/db/monitor.db
 rm -rf simplelinks/ simpleruns/
 mkdir -p simplelinks simpleruns
 (cd simplerun;cp ../../*_records.scm .;perl -pi.bak -e 's/define-inline/define/' *_records.scm)
 
 # Run the test $1 is the unit test to run
-cd simplerun;echo '(load "../tests.scm")' | megatest -repl -debug $2 $1
+cd simplerun;echo '(load "../tests.scm")' | ../../bin/megatest -repl -debug $2 $1

ADDED   tests/unittests/inmemdb.scm
Index: tests/unittests/inmemdb.scm
==================================================================
--- /dev/null
+++ tests/unittests/inmemdb.scm
@@ -0,0 +1,44 @@
+;;======================================================================
+;; S E R V E R
+;;======================================================================
+
+;; Run like this:
+;;
+;;  (cd ..;make && make install) && ./rununittest.sh server 1;(cd simplerun;megatest -stop-server 0)
+
+(set! *transport-type* 'http)
+
+(system "cp ../fullrun/megatest.db megatest.db")
+
+(test "open inmem db"          1  (begin (open-in-mem-db) 1))
+
+(test "setup for run" #t (begin (setup-for-run)
+				(string? (getenv "MT_RUN_AREA_HOME"))))
+
+(system "megatest -server - -debug 0 &")
+
+(thread-sleep! 3) ;; need to wait for server to start. Yes, a better way is needed.
+
+(define *keys*               (keys:config-get-fields *configdat*))
+(define *keyvals*            (keys:target->keyval *keys* "a/b/c"))
+
+(test #f #t                       (string? (car *runremote*)))
+(test #f '(#t "successful login") (rmt:login)) ;;  *runremote* *toppath* *my-client-signature*)))
+
+(define inmem (open-in-mem-db))
+
+(define (inmem-test t b)
+  (test "inmem sync to"   t (db:sync-to *db* inmem))
+  (test "inmem sync back" b (db:sync-to inmem *db*)))
+
+(inmem-test 0 0)
+
+(inmem-test 1 1)
+
+;;======================================================================
+;; D B
+;;======================================================================
+
+(test #f '(#t "exit process started") (rmt:kill-server)) ;; *toppath* *my-client-signature* #f)))
+
+ 

Index: tests/unittests/server.scm
==================================================================
--- tests/unittests/server.scm
+++ tests/unittests/server.scm
@@ -6,12 +6,10 @@
 ;;
 ;;  (cd ..;make && make install) && ./rununittest.sh server 1;(cd simplerun;megatest -stop-server 0)
 
 (set! *transport-type* 'http)
 
-(test "open inmem db"          1  (begin (open-in-mem-db) 1))
-
 (test "setup for run" #t (begin (setup-for-run)
 				(string? (getenv "MT_RUN_AREA_HOME"))))
 
 (test "server-register, get-best-server" #t (let ((res #f))
 					      (open-run-close tasks:server-register tasks:open-db 1 "bob" 1234 100 'live 'http)
@@ -28,13 +26,20 @@
 ;; (test "launch server" #t (let ((pid (process-fork (lambda ()
 ;; 						    ;; (daemon:ize)
 ;; 						    (server:launch 'http)))))
 ;; 			   (set! server-pid pid)
 ;; 			   (number? pid)))
-(system "megatest -server - -debug 0 &")
+(system "../../bin/megatest -server - -debug 22 > server.log 2> server.log &")
 
-(thread-sleep! 3) ;; need to wait for server to start. Yes, a better way is needed.
+(let loop ((n 10))
+  (thread-sleep! 1) ;; need to wait for server to start.
+  (let ((res (open-run-close tasks:get-best-server tasks:open-db)))
+    (print "tasks:get-best-server returned " res)
+    (if (and (not res)
+	     (> n 0))
+	(loop (- n 1)))))
+
 (test "get-best-server" #t (begin 
 			     (client:launch)
 			     (let ((dat (open-run-close tasks:get-best-server tasks:open-db)))
 			       (vector? dat))))
 
@@ -42,17 +47,10 @@
 (define *keyvals*            (keys:target->keyval *keys* "a/b/c"))
 
 (test #f #t                       (string? (car *runremote*)))
 (test #f '(#t "successful login") (rmt:login)) ;;  *runremote* *toppath* *my-client-signature*)))
 
-(define inmem (open-in-mem-db))
-(define (inmem-test t b)
-  (test "inmem sync to"   t (db:sync-to *db* inmem))
-  (test "inmem sync back" b (db:sync-to inmem *db*)))
-
-(inmem-test 0 0)
-
 (test #f #f                       (rmt:get-test-info-by-id 99)) ;; get non-existant test
 
 ;; RUNS
 (test #f 1                        (rmt:register-run  *keyvals* "firstrun" "new" "n/a" (current-user-name)))
 (test "get run info"  "firstrun"  (let ((rinfo (rmt:get-run-info 1)))
@@ -62,13 +60,11 @@
 ;; TESTS
 (test "get tests (no data)" '()   (rmt:get-tests-for-run 1 "%" '() '() #f #f #f #f #f #f))
 (test "register test"       #t    (rmt:general-call 'register-test 1 "test1" ""))
 (test "get tests (some data)"  1  (length (rmt:get-tests-for-run 1 "%" '() '() #f #f #f #f #f #f)))
 (test "get test id"            1  (rmt:get-test-id 1 "test1" ""))
-
-(inmem-test 1 1)
-
+(test "sync back"              #t (> (rmt:sync-inmem->db) 0))
 (test "get test id from main"  1  (db:get-test-id *db* 1 "test1" ""))
 (test "get keys"               #t (list? (rmt:get-keys)))
 (test "set comment"            #t (begin (rmt:general-call 'set-test-comment "this is a comment" 1) #t))
 (test "get comment" "this is a comment" (let ((trec (rmt:get-test-info-by-id 1)))
 					  (db:test-get-comment trec)))
@@ -79,14 +75,14 @@
 			    (data   (vector-ref runs 1)))
 		       (and (list?   header)
 			    (list?   data)
 			    (vector? (car data)))))
 
-
-(inmem-test 1 1)
+(test "get local testinfo" "test1" (vector-ref (db:get-testinfo-state-status *db* 1) 2))
+(test "get testinfo"       "test1" (vector-ref (rmt:get-testinfo-state-status 1) 2))
 
 ;;======================================================================
 ;; D B
 ;;======================================================================
 
 (test #f '(#t "exit process started") (rmt:kill-server)) ;; *toppath* *my-client-signature* #f)))