Megatest

			"-repl"
			"-lock"
			"-unlock"
			"-list-servers"
			;; mist queries
			"-list-disks"
			"-list-targets"
			"-list-db-targets"
			;; queries
			"-test-paths" ;; get path(s) to a test, ordered by youngest first

			"-runall"    ;; run all tests
			"-remove-runs"
			"-usequeue"
			"-rebuild-db"

;;======================================================================

(if (args:get-arg "-env2file")
    (begin
      (save-environment-as-files (args:get-arg "-env2file"))
      (set! *didsomething* #t)))

(if (args:get-arg "-list-targets")
    (begin
      (print (string-intersperse
	      (common:get-runconfig-targets)
	      "\n"))
      (set! *didsomething* #t)))

;; (if (args:get-arg "-list-db-targets")
;;     (if (setup-for-run)
;; 	(let* ((db       (open-db)) ;; A=%,B=foo => ("A=%" "B=foo")
;; 	       (keypatts (let ((pattstr  (args:get-arg "-list-db-targets")))
;; 			   (if (equal? pattstr "-") 
;; 			       #f
;; 			       (let ((all (string-split pattstr ",")))
;; 				 (map (lambda (x) ;; A=% => (A "%")
;; 					(string-split x "="))
;; 				      all)))))
;; 	       (runsdat  (db:get-runs db "%" #f #f keypatts))
;; 	       (runs     (cadr runsdat))
;; 	       (header   (car  runsdat))
;; 	       (seen     (make-hash-table))
;; 	       (keysdat  (db:get-keys db))
;; 	       (keys     (map (lambda (x)(vector-ref x 0)) keysdat)))
;; 
;; 	  (for-each 
;; 	   (lambda (run)
;; 	     (print (string-intersperse 
;; 		     (let loop ((key (car keys))
;; 				(tal (cdr keys))
;; 				(res '()))
;; 		       (let ((val (db:get-value-by-header run header key)))
;; 			 (if (null? tal)
;; 			     (append res (list val))
;; 			     (loop (car tal)(cdr tal)(append res (list val))))))
;; 		     "/")))
;; 	   runs))))

(if (args:get-arg "-list-disks")
    (begin
      (print 
       (string-intersperse 
	(map (lambda (x)

	       (string-intersperse 
		x
		" => "))
	     (common:get-disks) )
	"\n"))
      (set! *didsomething* #t)))

;;======================================================================
;; Start the server - can be done in conjunction with -runall or -runtests (one day...)
;;   we start the server if not running else start the client thread
;;======================================================================

(if (args:get-arg "-server")

     (lambda (target runname keys keynames keyvallst)
       (operate-on 'set-state-status))))

;;======================================================================
;; Query runs
;;======================================================================

(if (or (args:get-arg "-list-runs")
	(args:get-arg "-list-db-targets"))
    (if (setup-for-run)
	(let* ((db       #f)
	       (runpatt  (args:get-arg "-list-runs"))
	       (testpatt (if (args:get-arg "-testpatt") 
			     (args:get-arg "-testpatt") 
			     "A long and rediculous test name that hopefully will never match"))
	       (runsdat  (open-run-close db:get-runs db runpatt #f #f '()))
	       (runs     (db:get-rows runsdat))
	       (header   (db:get-header runsdat))
	       (keys     (open-run-close db:get-keys db))
	       (keynames (map key:get-fieldname keys))
	       (db-targets (args:get-arg "-list-db-targets"))
	       (seen     (make-hash-table)))
	  ;; Each run
	  (for-each 
	   (lambda (run)

	     (let ((targetstr (string-intersperse (map (lambda (x)
							 (db:get-value-by-header run header x))
						       keynames) "/")))

	       (if db-targets
		   (if (not (hash-table-ref/default seen targetstr #f))
		       (begin
			 (hash-table-set! seen targetstr #t)
			 (print targetstr)))
		   (debug:print 1 
				(if db-targets "" "Run: ")
				targetstr 
				(if db-targets "" (conc " status: " (db:get-value-by-header run header "state"))))
		   ))
	     (let ((run-id (open-run-close db:get-value-by-header run header "id")))
	       (let ((tests (open-run-close db:get-tests-for-run db run-id testpatt '() '())))
		 ;; Each test
		 (for-each 
		  (lambda (test)
		    (format #t
			    "  Test: ~25a State: ~15a Status: ~15a Runtime: ~5@as Time: ~22a Host: ~10a\n"