Index: Makefile
==================================================================
--- Makefile
+++ Makefile
@@ -56,11 +56,11 @@
 tests.o tasks.o dashboard-tasks.o : task_records.scm
 runs.o : test_records.scm
 megatest.o : megatest-fossil-hash.scm
 
 # Temporary while transitioning to new routine
-runs.o : run-tests-queue-classic.scm  run-tests-queue-new.scm
+# runs.o : run-tests-queue-classic.scm  run-tests-queue-new.scm
 
 megatest-fossil-hash.scm : $(SRCFILES) megatest.scm *_records.scm
 	echo "(define megatest-fossil-hash \"$(MTESTHASH)\")" > megatest-fossil-hash.new
 	if ! diff -q megatest-fossil-hash.new megatest-fossil-hash.scm ; then echo copying .new to .scm;cp -f megatest-fossil-hash.new megatest-fossil-hash.scm;fi
 

Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -655,10 +655,47 @@
      db
      "SELECT COUNT(id) FROM runs WHERE runname LIKE ? AND state != 'deleted';" runpatt)
     (debug:print-info 11 "db:get-num-runs END " runpatt)
     numruns))
 
+;; db:get-runs-by-patt
+;; get runs by list of criteria
+;; register a test run with the db
+;;
+;; Use: (db-get-value-by-header (db:get-header runinfo)(db:get-row runinfo))
+;;  to extract info from the structure returned
+;;
+(define (db:get-runs-by-patt db keys runnamepatt targpatt) ;; 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 "")
+	 (runwildtype (if (substring-index "%" runnamepatt) "like" "glob"))
+	 (qry-str  #f)
+	 (keyvals  (keys:target->keyval keys targpatt)))
+    (for-each (lambda (keyval)
+		(let* ((key    (car keyval))
+		       (patt   (cadr keyval))
+		       (fulkey (conc ":" key))
+		       (wildtype (if (substring-index "%" patt) "like" "glob")))
+		  (if patt
+		      (set! key-patt (conc key-patt " AND " key " " wildtype " '" patt "'"))
+		      (begin
+			(debug:print 0 "ERROR: searching for runs with no pattern set for " fulkey)
+			(exit 6)))))
+	      keyvals)
+    (set! qry-str (conc "SELECT " keystr " FROM runs WHERE runname " runwildtype " ? " key-patt ";"))
+    (debug:print-info 4 "runs:get-runs-by-patt qry=" qry-str " " runnamepatt)
+    (sqlite3:for-each-row 
+     (lambda (a . r)
+       (set! res (cons (list->vector (cons a r)) res)))
+     db 
+     qry-str
+     runnamepatt)
+    (vector header res)))
+
 ;; use (get-value-by-header (db:get-header runinfo)(db:get-row runinfo))
 (define (db:get-run-info db run-id)
   ;;(if (hash-table-ref/default *run-info-cache* run-id #f)
   ;;    (hash-table-ref *run-info-cache* run-id)
       (let* ((res      #f)

Index: mt.scm
==================================================================
--- mt.scm
+++ mt.scm
@@ -27,10 +27,27 @@
 (include "test_records.scm")
 
 ;; This is the Megatest API. All generally "useful" routines will be wrapped or extended
 ;; here.
 
+;;======================================================================
+;;  R U N S
+;;======================================================================
+
+;; runs:get-runs-by-patt
+;; get runs by list of criteria
+;; register a test run with the db
+;;
+;; Use: (db-get-value-by-header (db:get-header runinfo)(db:get-row runinfo))
+;;  to extract info from the structure returned
+;;
+(define (mt:get-runs-by-patt keys runnamepatt targpatt)
+  (cdb:remote-run db:get-runs-by-patt #f keys runnamepatt targpatt))
+
+;;======================================================================
+;;  T E S T S
+;;======================================================================
 
 (define (mt:get-tests-for-run run-id testpatt states status #!key (not-in #t) (sort-by #f))
   (let loop ((testsdat (cdb:remote-run db:get-tests-for-run #f run-id testpatt states status 0 500 not-in sort-by))
 	     (res      '())
 	     (offset   0)

Index: runs.scm
==================================================================
--- runs.scm
+++ runs.scm
@@ -26,47 +26,10 @@
 (include "key_records.scm")
 (include "db_records.scm")
 (include "run_records.scm")
 (include "test_records.scm")
 
-;; runs:get-runs-by-patt
-;; get runs by list of criteria
-;; register a test run with the db
-;;
-;; Use: (db-get-value-by-header (db:get-header runinfo)(db:get-row runinfo))
-;;  to extract info from the structure returned
-;;
-(define (runs:get-runs-by-patt db keys runnamepatt targpatt) ;; 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 "")
-	 (runwildtype (if (substring-index "%" runnamepatt) "like" "glob"))
-	 (qry-str  #f)
-	 (keyvals  (keys:target->keyval keys targpatt)))
-    (for-each (lambda (keyval)
-		(let* ((key    (car keyval))
-		       (patt   (cadr keyval))
-		       (fulkey (conc ":" key))
-		       (wildtype (if (substring-index "%" patt) "like" "glob")))
-		  (if patt
-		      (set! key-patt (conc key-patt " AND " key " " wildtype " '" patt "'"))
-		      (begin
-			(debug:print 0 "ERROR: searching for runs with no pattern set for " fulkey)
-			(exit 6)))))
-	      keyvals)
-    (set! qry-str (conc "SELECT " keystr " FROM runs WHERE runname " runwildtype " ? " key-patt ";"))
-    (debug:print-info 4 "runs:get-runs-by-patt qry=" qry-str " " runnamepatt)
-    (sqlite3:for-each-row 
-     (lambda (a . r)
-       (set! res (cons (list->vector (cons a r)) res)))
-     db 
-     qry-str
-     runnamepatt)
-    (vector header res)))
-
 (define (runs:test-get-full-path test)
   (let* ((testname (db:test-get-testname   test))
 	 (itempath (db:test-get-item-path test)))
     (conc testname (if (equal? itempath "") "" (conc "(" itempath ")")))))
 
@@ -130,11 +93,10 @@
 			    (setenv (car varval)(cadr varval)))
 			  (configf:get-section runconfig section)))
 	      (list "default" target))
     (vector target runname testpatt keys keyvals envdat mconfig runconfig serverdat transport db toppath run-id)))
 
-	 
 (define (set-megatest-env-vars run-id #!key (inkeys #f)(inrunname #f)(inkeyvals #f))
   (let* ((target      (or (args:get-arg "-reqtarg")
 			  (args:get-arg "-target")
 			  (get-environment-variable "MT_TARGET")))
 	 (keys    (if inkeys    inkeys    (cdb:remote-run db:get-keys #f)))
@@ -170,11 +132,11 @@
 ;;
 ;; NOTE: We run this server-side!! Do not use this global except in the runs:can-run-more-tests routine
 ;;
 (define *last-num-running-tests* 0)
 (define *runs:can-run-more-tests-count* 0)
-(define (runs:shrink-can-run-more-tests-count db) ;; the db is just so we can use cdb:remote-run
+(define (runs:shrink-can-run-more-tests-count db) ;; the db is a dummy var so we can use cdb:remote-run
   (set! *runs:can-run-more-tests-count* 0)) ;; (/ *runs:can-run-more-tests-count* 2)))
 
 (define (runs:can-run-more-tests db jobgroup max-concurrent-jobs)
   (thread-sleep! (cond
 		  ((> *runs:can-run-more-tests-count* 20) 2);; obviously haven't had any work to do for a while
@@ -205,33 +167,20 @@
 					       " in " jobgroup " exceeded, will not run " (tests:testqueue-get-testname test-record))
 				  #t)
 				 (else #f))))
 	  (list (not can-not-run-more) num-running num-running-in-jobgroup max-concurrent-jobs job-group-limit)))))
 
-;;======================================================================
-;; New methodology. These routines will replace the above in time. For
-;; now the code is duplicated. This stuff is initially used in the monitor
-;; based code.
-;;======================================================================
-
-
-;; This is a duplicate of run-tests (which has been deprecated). Use this one instead of run tests.
-;; keyvals.
-;;
 ;;  test-names: Comma separated patterns same as test-patts but used in selection 
 ;;              of tests to run. The item portions are not respected.
 ;;              FIXME: error out if /patt specified
 ;;            
 (define (runs:run-tests target runname test-patts user flags) ;; test-names
   (common:clear-caches) ;; clear all caches
-  (let* ((db          #f)
-	 (keys        (keys:config-get-fields *configdat*))
+  (let* ((keys        (keys:config-get-fields *configdat*))
 	 (keyvals     (keys:target->keyval keys target))
 	 (run-id      (cdb:remote-run db:register-run #f keyvals runname "new" "n/a" user))  ;;  test-name)))
 	 (deferred    '()) ;; delay running these since they have a waiton clause
-	 ;; keepgoing is the defacto modality now, will add hit-n-run a bit later
-	 ;; (keepgoing   (hash-table-ref/default flags "-keepgoing" #f))
 	 (runconfigf   (conc  *toppath* "/runconfigs.config"))
 	 (required-tests '())
 	 (test-records (make-hash-table))
 	 (all-test-names (tests:get-valid-tests *toppath* "%"))) ;; we need a list of all valid tests to check waiton names
 
@@ -242,13 +191,11 @@
 	(debug:print 0 "WARNING: You do not have a run config file: " runconfigf))
     
     ;; look up all tests matching the comma separated list of globs in
     ;; test-patts (using % as wildcard)
 
-    (set! test-names (tests:get-valid-tests *toppath* test-patts))
-    (set! test-names (delete-duplicates test-names))
-
+    (set! test-names (delete-duplicates (tests:get-valid-tests *toppath* test-patts)))
     (debug:print-info 0 "test names " test-names)
 
     ;; on the first pass or call to run-tests set FAILS to NOT_STARTED if
     ;; -keepgoing is specified
     (if (eq? *passnum* 0)
@@ -258,22 +205,19 @@
 	  ;; on test A but test B reached the point on being registered as NOT_STARTED and test
 	  ;; A failed for some reason then on re-run using -keepgoing the run can never complete.
 	  (cdb:delete-tests-in-state *runremote* run-id "NOT_STARTED")
 	  (cdb:remote-run db:set-tests-state-status #f run-id test-names #f "FAIL" "NOT_STARTED" "FAIL")))
 
-    ;; from here on out the db will be opened and closed on every call runs:run-tests-queue
-    ;; (sqlite3:finalize! db) 
     ;; now add non-directly referenced dependencies (i.e. waiton)
     (if (not (null? test-names))
 	(let loop ((hed (car test-names))
 		   (tal (cdr test-names)))         ;; 'return-procs tells the config reader to prep running system but return a proc
 	  (let* ((config  (tests:get-testconfig hed 'return-procs))
 		 (waitons (let ((instr (if config 
 					   (config-lookup config "requirements" "waiton")
 					   (begin ;; No config means this is a non-existant test
 					     (debug:print 0 "ERROR: non-existent required test \"" hed "\"")
-					     (if db (sqlite3:finalize! db))
 					     (exit 1)))))
 			    (debug:print-info 8 "waitons string is " instr)
 			    (let ((newwaitons
 				   (string-split (cond
 						  ((procedure? instr)
@@ -751,13 +695,10 @@
       (cdr reg)
       (if (eq? (length tal) 1)
 	  '()
 	  reg)))
 
-(include "run-tests-queue-classic.scm")
-(include "run-tests-queue-new.scm")
-
 ;; parent-test is there as a placeholder for when parent-tests can be run as a setup step
 (define (run:test run-id run-info keyvals runname test-record flags parent-test)
   ;; All these vars might be referenced by the testconfig file reader
   (let* ((test-name    (tests:testqueue-get-testname   test-record))
 	 (test-waitons (tests:testqueue-get-waitons    test-record))
@@ -900,11 +841,11 @@
 ;;
 (define (runs:operate-on action target runnamepatt testpatt #!key (state #f)(status #f)(new-state-status #f))
   (common:clear-caches) ;; clear all caches
   (let* ((db           #f)
 	 (keys         (cdb:remote-run db:get-keys db))
-	 (rundat       (cdb:remote-run runs:get-runs-by-patt db keys runnamepatt target))
+	 (rundat       (mt:get-runs-by-patt keys runnamepatt target))
 	 (header       (vector-ref rundat 0))
 	 (runs         (vector-ref rundat 1))
 	 (states       (if state  (string-split state  ",") '()))
 	 (statuses     (if status (string-split status ",") '()))
 	 (state-status (if (string? new-state-status) (string-split new-state-status ",") '(#f #f))))
@@ -1118,11 +1059,11 @@
 ;; Lock/unlock runs
 ;;======================================================================
 
 (define (runs:handle-locking target keys runname lock unlock user)
   (let* ((db       #f)
-	 (rundat   (cdb:remote-run runs:get-runs-by-patt db keys runname target))
+	 (rundat   (mt:get-runs-by-patt keys runname target))
 	 (header   (vector-ref rundat 0))
 	 (runs     (vector-ref rundat 1)))
     (for-each (lambda (run)
 		(let ((run-id (db:get-value-by-header run header "id")))
 		  (if (or lock