Megatest

Artifact [2a4403e0b1]
Login

Artifact 2a4403e0b1913cf0289f2bed254f033d2387bae7:


;; Copyright 2006-2017, Matthew Welland.
;; 
;; This file is part of Megatest.
;; 
;;     Megatest is free software: you can redistribute it and/or modify
;;     it under the terms of the GNU General Public License as published by
;;     the Free Software Foundation, either version 3 of the License, or
;;     (at your option) any later version.
;; 
;;     Megatest is distributed in the hope that it will be useful,
;;     but WITHOUT ANY WARRANTY; without even the implied warranty of
;;     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;     GNU General Public License for more details.
;; 
;;     You should have received a copy of the GNU General Public License
;;     along with Megatest.  If not, see <http://www.gnu.org/licenses/>.
;;

(declare (uses dbi))
(declare (uses pkts))
(declare (uses stml2))
(declare (uses cookie))
(declare (uses csv-xml))
;; (declare (uses hostinfo))

(declare (uses adjutant))
(declare (uses archivemod))
(declare (uses apimod))
(declare (uses autoload))
(declare (uses bigmod))
(declare (uses commonmod))
(declare (uses configfmod))
(declare (uses dbmod))
(declare (uses dbi))
(declare (uses debugprint))
(declare (uses ducttape-lib))
(declare (uses ezstepsmod))
(declare (uses launchmod))
(declare (uses mtargs))
(declare (uses mtver))
(declare (uses mutils))
(declare (uses processmod))
(declare (uses rmtmod))
(declare (uses runsmod))
(declare (uses servermod))
(declare (uses testsmod))
(declare (uses dbmgrmod))

;; needed for configf scripts, scheme etc.
;; (declare (uses apimod.import))
;; (declare (uses debugprint.import))
;; (declare (uses mtargs.import))
;; (declare (uses commonmod.import))
;; (declare (uses configfmod.import))
;; (declare (uses bigmod.import))
;; (declare (uses dbmod.import))
;; (declare (uses rmtmod.import))
;; (declare (uses servermod.import))
;; (declare (uses launchmod.import))

;; (include "call-with-environment-variables/call-with-environment-variables.scm")

(module megatest
	*

  (import scheme
	  chicken.base
	  chicken.bitwise
	  chicken.condition
	  ;; chicken.csi
	  chicken.eval
	  chicken.file
	  chicken.file.posix
	  chicken.format
	  chicken.io
	  chicken.irregex
	  chicken.pathname
	  chicken.port
	  chicken.pretty-print
	  chicken.process
	  chicken.process-context
	  chicken.process-context.posix
	  chicken.process.signal
	  chicken.random
	  chicken.repl
	  chicken.sort
	  chicken.string
	  chicken.tcp
	  chicken.time
	  chicken.time.posix
	  
	  (prefix base64 base64:)
	  (prefix sqlite3 sqlite3:)
	  (prefix sxml-modifications sxml-)
	  address-info
	  csv-abnf
	  directory-utils
	  fmt
	  format
	  http-client
	  intarweb
	  json
	  linenoise
	  matchable
	  md5
	  message-digest
	  queues
	  regex
	  regex-case
	  s11n
	  sparse-vectors
	  spiffy
	  spiffy-directory-listing
	  spiffy-request-vars
	  sql-de-lite
	  stack
	  sxml-modifications
	  sxml-serializer
	  sxml-transforms
	  system-information
	  typed-records
	  uri-common
	  z3
	  
	  srfi-1
	  srfi-4
	  srfi-18
	  srfi-13
	  srfi-98
	  srfi-69

	  ;; local modules
	  autoload
	  adjutant
	  csv-xml
	  ;; hostinfo
	  mtver
	  mutils
	  cookie
	  csv-xml
	  ducttape-lib
	  (prefix mtargs args:)
	  pkts
	  stml2
	  (prefix dbi dbi:)

	  apimod
	  archivemod
	  bigmod
	  commonmod
	  configfmod
	  dbmod
	  debugprint
	  ezstepsmod
	  launchmod
	  processmod
	  rmtmod
	  runsmod
	  servermod
	  tasksmod
	  testsmod
	  dbmgrmod
	  
	  ulex
	  )

;;   ;; ulex parameters
;;   (work-method 'direct)
;;   (return-method 'direct)
  
  ;; ulex parameters
  ;; (work-method   'mailbox)
  ;; (return-method 'mailbox)
  
;; fake out readline usage of toplevel-command
(define (toplevel-command . a) #f)
(define *didsomething* #f)  
(define *db* #f) ;; this is only for the repl, do not use in general!!!!

;; (include "common_records.scm")
;; (include "key_records.scm")
;; (include "db_records.scm")
(include "run_records.scm")
;; (include "test_records.scm")

;; (include "common.scm")
(include "db.scm")
;; (include "server.scm")
(include "tests.scm")
(include "genexample.scm")
(include "tdb.scm")
(include "env.scm")
(include "diff-report.scm")
(include "ods.scm")

(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

;;======================================================================
;; Test commands (i.e. for use inside tests)
;;======================================================================

(define (megatest:step step state status logfile msg)
  (if (not (get-environment-variable "MT_CMDINFO"))
      (begin
     	(debug:print-error 0 *default-log-port* "MT_CMDINFO env var not set, -step must be called *inside* a megatest invoked environment!")
     	(exit 5))
      (let* ((cmdinfo   (common:read-encoded-string (get-environment-variable "MT_CMDINFO")))
     	     (transport (assoc/default 'transport cmdinfo))
     	     (testpath  (assoc/default 'testpath  cmdinfo))
     	     (test-name (assoc/default 'test-name cmdinfo))
     	     (runscript (assoc/default 'runscript cmdinfo))
     	     (db-host   (assoc/default 'db-host   cmdinfo))
     	     (run-id    (assoc/default 'run-id    cmdinfo))
     	     (test-id   (assoc/default 'test-id   cmdinfo))
     	     (itemdat   (assoc/default 'itemdat   cmdinfo))
     	     (work-area (assoc/default 'work-area cmdinfo))
     	     (db        #f))
     	(change-directory testpath)
     	(if (not (launch:setup))
     	    (begin
     	      (debug:print 0 *default-log-port* "Failed to setup, exiting")
     	      (exit 1)))
     	(if (and state status)
     	    (let ((comment (launch:load-logpro-dat run-id test-id step)))
     	      ;; (rmt:test-set-log! run-id test-id (conc stepname ".html"))))
     	      (rmt:teststep-set-status! run-id test-id step state status (or comment msg) logfile))
     	    (begin
     	      (debug:print-error 0 *default-log-port* "You must specify :state and :status with every call to -step")
     	      (exit 6))))))

;;======================================================================
;; full run
;;======================================================================

(define (handle-run-requests target runname keys keyvals need-clean)	 
  (if (or (args:get-arg "-kill-rerun") (args:get-arg "-rerun-clean")) ;; first set states/statuses correct
      ;; For rerun-clean do we or do we not support the testpatt?
      (let ((states   (or (configf:lookup *configdat* "validvalues" "cleanrerun-states")
     			  "KILLREQ,KILLED,UNKNOWN,INCOMPLETE,STUCK,NOT_STARTED"))
     	    (statuses (or (configf:lookup *configdat* "validvalues" "cleanrerun-statuses")
     			  "FAIL,INCOMPLETE,ABORT,CHECK,DEAD,PREQ_FAIL,PREQ_DISCARDED")))
     	(hash-table-set! args:arg-hash "-preclean" #t)
     	(runs:operate-on 'set-state-status
     			 target
     			 (common:args-get-runname)  ;; (or (args:get-arg "-runname")(args:get-arg ":runname"))
     			 ;; "%" ;; (common:args-get-testpatt #f) ;; (args:get-arg "-testpatt")
     			 (common:args-get-testpatt #f) ;; (args:get-arg "-testpatt")
     			 state:  states
     			 ;; status: statuses
     			 new-state-status: "NOT_STARTED,n/a")
     	(runs:clean-cache target runname *toppath*)
     	(runs:operate-on 'set-state-status
     			 target
     			 (common:args-get-runname)  ;; (or (args:get-arg "-runname")(args:get-arg ":runname"))
     			 ;; "%" ;; (common:args-get-testpatt #f) ;; (args:get-arg "-testpatt")
     			 (common:args-get-testpatt #f) ;; (args:get-arg "-testpatt")
     			 ;; state:  states
     			 status: statuses
     			 new-state-status: "NOT_STARTED,n/a")))
  ;; RERUN ALL
  (if (args:get-arg "-rerun-all") ;; first set states/statuses correct
      (let* ((rconfig (full-runconfigs-read)))
     	(hash-table-set! args:arg-hash "-preclean" #t)
     	(runs:operate-on 'set-state-status
     			 target
     			 (common:args-get-runname)  ;; (or (args:get-arg "-runname")(args:get-arg ":runname"))
     			 (common:args-get-testpatt rconfig) ;; (args:get-arg "-testpatt")
     			 state:  #f
     			 ;; status: statuses
     			 new-state-status: "NOT_STARTED,n/a")
     	(runs:clean-cache target runname *toppath*)
     	(runs:operate-on 'set-state-status
     			 target
     			 (common:args-get-runname)  ;; (or (args:get-arg "-runname")(args:get-arg ":runname"))
     			 (common:args-get-testpatt rconfig) ;; (args:get-arg "-testpatt")
     			 ;; state:  states
     			 status: #f
     			 new-state-status: "NOT_STARTED,n/a")))
  (let* ((config-reruns      (let ((x (configf:lookup *configdat* "setup" "reruns")))
     			       (if x (string->number x) #f)))
     	 (rerun-cnt (if config-reruns
     			config-reruns
     			1)))
    
    (runs:run-tests target
     		    runname
     		    #f ;; (common:args-get-testpatt #f)
     		    ;; (or (args:get-arg "-testpatt")
     		    ;;     "%")
     		    (bdat-user *bdat*)
     		    args:arg-hash
     		    run-count: rerun-cnt)))

;; csv processing record
(define (make-refdb:csv)
  (vector 
   (make-sparse-array)
   (make-hash-table)
   (make-hash-table)
   0
   0))
(define-inline (refdb:csv-get-svec     vec)    (vector-ref  vec 0))
(define-inline (refdb:csv-get-rows     vec)    (vector-ref  vec 1))
(define-inline (refdb:csv-get-cols     vec)    (vector-ref  vec 2))
(define-inline (refdb:csv-get-maxrow   vec)    (vector-ref  vec 3))
(define-inline (refdb:csv-get-maxcol   vec)    (vector-ref  vec 4))
(define-inline (refdb:csv-set-svec!    vec val)(vector-set! vec 0 val))
(define-inline (refdb:csv-set-rows!    vec val)(vector-set! vec 1 val))
(define-inline (refdb:csv-set-cols!    vec val)(vector-set! vec 2 val))
(define-inline (refdb:csv-set-maxrow!  vec val)(vector-set! vec 3 val))
(define-inline (refdb:csv-set-maxcol!  vec val)(vector-set! vec 4 val))

(define (get-dat results sheetname)
  (or (hash-table-ref/default results sheetname #f)
      (let ((tmp-vec  (make-refdb:csv)))
     	(hash-table-set! results sheetname tmp-vec)
     	tmp-vec)))

;; bracket open-output-file with code to make leading directory if it does not exist and handle exceptions
(define (open-logfile logpath-in)
  (condition-case
   (let* ((log-dir (or (pathname-directory logpath-in) "."))
     	  (fname   (pathname-strip-directory logpath-in))
     	  (logpath (if (> (string-length fname) 250)
     		       (let ((newlogf (conc log-dir "/" (common:get-signature fname) ".log")))
     			 (debug:print 0 *default-log-port* "WARNING: log file " logpath-in " path too long, converted to " newlogf)
     			 newlogf)
     		       logpath-in)))
     (if (not (directory-exists? log-dir))
	 (system (conc "mkdir -p " log-dir)))
     (open-output-file logpath))
   (exn ()
	(debug:print-error 0 *default-log-port* "Could not open log file for write: "logpath-in)
	(set! *didsomething* #t)
	(exit 1))))

;; Disabled help items
;;  -rollup                 : (currently disabled) fill run (set by :runname)  with latest test(s)
;;                            from prior runs with same keys
;;  -daemonize              : fork into background and disconnect from stdin/out

(define help (conc "
Megatest, documentation at http://www.kiatoa.com/fossils/megatest
  version " megatest-version "
  license GPL, Copyright Matt Welland 2006-2017
 
Usage: megatest [options]
  -h                      : this help
  -manual                 : show the Megatest user manual
  -version                : print megatest version (currently " megatest-version ")

Launching and managing runs
  -run                    : run all tests or as specified by -testpatt
  -remove-runs            : remove the data for a run, requires -runname and -testpatt
                            Optionally use :state and :status, use -keep-records to remove only
                            the run data. Use -kill-wait to override the 10 second
                            per test wait after kill delay (e.g. -kill-wait 0). 
  -kill-runs              : kill existing run(s) (all incomplete tests killed)
  -kill-rerun             : kill an existing run (all incomplete tests killed and run is rerun)
  -set-state-status X,Y   : set state to X and status to Y, requires controls per -remove-runs
  -rerun FAIL,WARN...     : force re-run for tests with specificed status(s)
  -rerun-clean            : set all tests not COMPLETED+PASS,WARN,WAIVED to NOT_STARTED,n/a
                            and then run the specified testpatt with -preclean
  -rerun-all              : set all tests to NOT_STARTED,n/a and run with -preclean
  -lock                   : lock run specified by target and runname
  -unlock                 : unlock run specified by target and runname
  -set-run-status status  : sets status for run to status, requires -target and -runname
  -get-run-status         : gets status for run specified by target and runname
  -run-wait               : wait on run specified by target and runname
  -preclean               : remove the existing test directory before running the test
  -clean-cache            : remove the cached megatest.config and runconfigs.config files
  -no-cache               : do not use the cached config files. 
  -one-pass               : launch as many tests as you can but do not wait for more to be ready
  -remove-keep N          : remove all but N most recent runs per target; use '-actions, -age, -precmd'
  -age <age>              : 120d,3h,20m to apply only to runs older than the 
                                 specified age. NB// M=month, m=minute
  -actions <action>[,...] : actions to take; print,remove-runs,archive,kill-runs
  -precmd                 : insert a wrapper command in front of the commands run

Selectors (e.g. use for -runtests, -remove-runs, -set-state-status, -list-runs etc.)
  -target key1/key2/...   : run for key1, key2, etc.
  -reqtarg key1/key2/...  : run for key1, key2, etc. but key1/key2 must be in runconfigs
  -testpatt patt1/patt2,patt3/...  : % is wildcard
  -runname                : required, name for this particular test run
  -state                  : Applies to runs, tests or steps depending on context
  -status                 : Applies to runs, tests or steps depending on context
  -modepatt key           : load testpatt from <key> in runconfigs instead of default TESTPATT if -testpatt and -tagexpr are not specified
  -tagexpr tag1,tag2%,..  : select tests with tags matching expression
  

Test helpers (for use inside tests)
  -step stepname
  -test-status            : set the state and status of a test (use :state and :status)
  -setlog logfname        : set the path/filename to the final log relative to the test
                            directory. may be used with -test-status
  -set-toplog logfname    : set the overall log for a suite of sub-tests
  -summarize-items        : for an itemized test create a summary html 
  -m comment              : insert a comment for this test

Test data capture
  -set-values             : update or set values in the testdata table
  :category               : set the category field (optional)
  :variable               : set the variable name (optional)
  :value                  : value measured (required)
  :expected               : value expected (required)
  :tol                    : |value-expect| <= tol (required, can be <, >, >=, <= or number)
  :units                  : name of the units for value, expected_value etc. (optional)
  -load-test-data         : read test specific data for storage in the test_data table
                            from standard in. Each line is comma delimited with four
                            fields category,variable,value,comment

Queries
  -list-runs patt         : list runs matching pattern \"patt\", % is the wildcard
  -show-keys              : show the keys used in this megatest setup
  -test-files targpatt    : get the most recent test path/file matching targpatt e.g. %/% or '*.log'
                            returns list sorted by age ascending, see examples below
  -test-paths             : get the test paths matching target, runname, item and test
                            patterns.
  -list-disks             : list the disks available for storing runs
  -list-targets           : list the targets in runconfigs.config
  -list-db-targets        : list the target combinations used in the db
  -show-config            : dump the internal representation of the megatest.config file
  -show-runconfig         : dump the internal representation of the runconfigs.config file
  -dumpmode MODE          : dump in MODE format instead of sexpr, MODE=json,ini,sexp etc. (add -debug 0,9 to see which file contributes each line)
  -show-cmdinfo           : dump the command info for a test (run in test environment)
  -section sectionName
  -var varName            : for config and runconfig lookup value for sectionName varName
  -since N                : get list of runs changed since time N (Unix seconds)
  -fields fieldspec       : fields to include in json dump; runs:id,runame+tests:testname+steps
  -sort fieldname         : in -list-runs sort tests by this field
  -testdata-csv [categorypatt/]varpatt  : dump testdata for given category

Misc 
  -start-dir path         : switch to this directory before running megatest
  -contour cname          : add a level of hierarcy to the linktree and run paths
  -area-tag tagname       : add a tag to an area while syncing to pgdb
  -run-tag tagname        : add a tag to a run while syncing to pgdb
  -rebuild-db             : bring the database schema up to date
  -cleanup-db             : remove any orphan records, vacuum the db
  -import-megatest.db     : push data from megatest.db to cache db files in /tmp/$USER
  -sync-to-megatest.db    : pull data from cache files in /tmp/$USER to megatest.db
  -sync-to dest           : sync to new postgresql central style database
  -update-meta            : update the tests metadata for all tests
  -setvars VAR1=val1,VAR2=val2 : Add environment variables to a run NB// these are
                                 overwritten by values set in config files.
  -server -|hostname      : start the server (reduces contention on megatest.db), use
                            - to automatically figure out hostname
  -adjutant C,M           : start the server/adjutant with allocated cores C and Mem M (Gig), 
                            use 0,0 to auto use full machine
  -transport http|rpc     : use http or rpc for transport (default is http) 
  -log logfile            : send stdout and stderr to logfile
  -autolog logfilebase    : appends pid and host to logfilebase for logfile
  -list-servers           : list the servers 
  -kill-servers           : kill all servers
  -repl                   : start a repl (useful for extending megatest)
  -load file.scm          : load and run file.scm
  -mark-incompletes       : find and mark incomplete tests
  -ping run-id|host:port  : ping server, exit with 0 if found
  -debug N|N,M,O...       : enable debug 0-N or N and M and O ...
  -debug-noprop N|M,M,O...: enable debug but do not propagate to subprocesses via MT_DEBUG
  -config fname           : override the megatest.config file with fname
  -append-config fname    : append fname to the megatest.config file

Utilities
  -env2file fname         : write the environment to fname.csh and fname.sh
  -envcap a               : save current variables labeled as context 'a' in file envdat.db
  -envdelta a-b           : output enviroment delta from context a to context b to -o fname
                            set the output mode with -dumpmode csh, bash or ini
                            note: ini format will use calls to use curr and minimize path
  -refdb2dat refdb        : convert refdb to sexp or to format specified by s-dumpmode
                            formats: perl, ruby, sqlite3, csv (for csv the -o param
                            will substitute %s for the sheet name in generating 
                            multiple sheets)
  -o                      : output file for refdb2dat (defaults to stdout)
  -archive cmd            : archive runs specified by selectors to one of disks specified
                            in the [archive-disks] section.
                            cmd: keep-html, restore, save, save-remove, get, replicate-db (use 
                            -dest to set destination), -include path1,path2... to get or save specific files
  -generate-html          : create a simple html dashboard for browsing your runs
  -generate-html-structure  : create a top level html veiw to list targets/runs and a Run view within each run directory.  
  -list-run-time          : list time requered to complete runs. It supports following switches
                            -run-patt <patt> -target-patt <patt> -dumpmode <csv,json,plain-text>
  -list-test-time	  : list time requered to complete each test in a run. It following following arguments
                            -runname <patt> -target <patt> -dumpmode <csv,json,plain-text>
  -syscheck               : do some very basic checks; write access and space in tmp, home, runs, links and 
                            is $DISPLAY valid 
  -list-waivers           : dump waivers for specified target, runname, testpatt to stdout

Diff report
  -diff-rep               : generate diff report (must include -src-target, -src-runname, -target, -runname
                                                  and either -diff-email or -diff-html)
  -src-target <target>
  -src-runname <target>
  -diff-email <emails>    : comma separated list of email addresses to send diff report
  -diff-html  <rep.html>  : path to html file to generate

Spreadsheet generation
  -extract-ods fname.ods  : extract an open document spreadsheet from the database
  -pathmod path           : insert path, i.e. path/runame/itempath/logfile.html
                            will clear the field if no rundir/testname/itempath/logfile
                            if it contains forward slashes the path will be converted
                            to windows style
Getting started
  -create-megatest-area   : create a skeleton megatest area. You will be prompted for paths
  -create-test testname   : create a skeleton megatest test. You will be prompted for info

Examples

# Get test path, use '.' to get a single path or a specific path/file pattern
megatest -test-files 'logs/*.log' -target ubuntu/n%/no% -runname w49% -testpatt test_mt%

Called as " (string-intersperse (argv) " ") "
Version " megatest-version ", built from " megatest-fossil-hash ))
     
(define (main)
  (make-and-init-bigdata)

;; 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)
      (load debugcontrolf)))

;; usage logging, careful with this, it is not designed to deal with all real world challenges!
;;
(if (and *usage-log-file*
	 (file-writable? *usage-log-file*))
    (with-output-to-file
	*usage-log-file*
      (lambda ()
	(print
	 (if *usage-use-seconds*
	     (current-seconds)
	     (time->string
	      (seconds->local-time (current-seconds))
	      "%Yww%V.%w %H:%M:%S"))
	 " "
	 (current-user-name) " "
	 (current-directory) " "
	 "\"" (string-intersperse (argv) " ") "\""))
      #:append))

     ;;  -gui                    : start a gui interface
     ;;  -config fname           : override the runconfigs file with fname
     
     ;; process args
     (define remargs (args:get-args 
     		 (argv)
     		 (list  "-runtests"  ;; run a specific test
     			"-config"    ;; override the config file name
     			"-append-config"
     			"-execute"   ;; run the command encoded in the base64 parameter
     			"-step"
     			"-target"
     			"-reqtarg"
     			":runname"
     			"-runname"
     			":state"  
     			"-state"
     			":status"
     			"-status"
     			"-list-runs"
			"-testdata-csv"
     			"-testpatt"
			"--modepatt"
			"-modepatt"
			"-tagexpr"
     			"-itempatt"
     			"-setlog"
     			"-set-toplog"
     			"-runstep"
     			"-logpro"
     			"-m"
     			"-rerun"
     
     			"-days"
     			"-rename-run"
     			"-to"
     			"-dest"
			"-source" 
			"-time-stamp" 
     			;; values and messages
     			":category"
     			":variable"
     			":value"
     			":expected"
     			":tol"
     			":units"
     
     			;; misc
     			"-start-dir"
			"-run-patt"
			"-target-patt"   
     			"-contour"
			"-area-tag"  
			"-area"  
     			"-run-tag"
     			"-server"
			"-db"            ;; file name for setting up a server
     			"-adjutant"
     			"-transport"
     			"-port"
     			"-extract-ods"
     			"-pathmod"
     			"-env2file"
     			"-envcap"
     			"-envdelta"
     			"-setvars"
     			"-set-state-status"
			
			;; move runs stuff here
			"-remove-keep"           
     			"-set-run-status"
     			"-age"
     
     			;; archive 
     			"-archive"
     			"-actions"
     			"-precmd"
     			"-include"
     			"-exclude-rx"
     			"-exclude-rx-from"
     			
     			"-debug" ;; for *verbosity* > 2
     			"-debug-noprop"
     			"-create-test"
     			"-override-timeout"
     			"-test-files"  ;; -test-paths is for listing all
     			"-load"        ;; load and exectute a scheme file
     			"-section"
     			"-var"
     			"-dumpmode"
     			"-run-id"
     			"-ping"
     			"-refdb2dat"
     			"-o"
     			"-log"
			"-autolog"
			"-sync-log"
     			"-since"
     			"-fields"
     			"-recover-test" ;; run-id,test-id - used internally to recover a test stuck in RUNNING state
     			"-sort"
     			"-target-db"
     			"-source-db"
     			"-prefix-target"
     
			"-src-target"
			"-src-runname"
			"-diff-email"
     			"-sync-to"			
     			"-pgsync"
     			"-kill-wait"    ;; wait this long before removing test (default is 10 sec)
			"-diff-html"
     
     			;; wizards, area capture, setup new ...
     			"-extract-skeleton"
     			)
      		 (list  "-h" "-help" "--help"
     			"-manual"
     			"-version"
     		        "-force"
     		        "-xterm"
     		        "-showkeys"
     		        "-show-keys"
     		        "-test-status"
     			"-set-values"
     			"-load-test-data"
     			"-summarize-items"
     		        "-gui"
     			"-daemonize"
     			"-preclean"
     			"-rerun-clean"
     			"-rerun-all"
     			"-clean-cache"
     			"-no-cache"
     			"-cache-db"
     			"-cp-eventtime-to-publishtime"
                             "-use-db-cache"
                             "-prepend-contour"
     
     
     			;; misc
     			"-repl"
     			"-lock"
     			"-unlock"
     			"-list-servers"
     			"-kill-servers"
			"-run-wait"      ;; wait on a run to complete (i.e. no RUNNING)
     			"-one-pass"      ;;
     			"-local"         ;; run some commands using local db access
     			"-generate-html"
     			"-generate-html-structure" 
     			"-list-run-time"
                             "-list-test-time"
     			
     			;; misc queries
     			"-list-disks"
     			"-list-targets"
     			"-list-db-targets"
     			"-show-runconfig"
     			"-show-config"
     			"-show-cmdinfo"
     			"-get-run-status"
     			"-list-waivers"
     
     			;; queries
     			"-test-paths" ;; get path(s) to a test, ordered by youngest first
     
     			"-runall"    ;; run all tests, respects -testpatt, defaults to %
     			"-run"       ;; alias for -runall
     			"-remove-runs"
                             "-kill-runs"
                             "-kill-rerun"
                             "-keep-records" ;; use with -remove-runs to remove only the run data
     			"-rebuild-db"
     			"-cleanup-db"
     			"-rollup"
     			"-update-meta"
     			"-create-megatest-area"
     			"-mark-incompletes"
     
     			"-convert-to-norm"
     			"-convert-to-old"
     			"-import-megatest.db"
     			"-sync-to-megatest.db"
			"-sync-brute-force"
     			"-logging"
     			"-v" ;; verbose 2, more than normal (normal is 1)
     			"-q" ;; quiet 0, errors/warnings only
     
                             "-diff-rep"
     
     			"-syscheck"
     			"-obfuscate"
     			;; junk placeholder
     			;; "-:p"
     			
                             )
     		 args:arg-hash
     		 0))
     
     ;; Add args that use remargs here
     ;;
     (if (and (not (null? remargs))
     	 (not (or
     	       (args:get-arg "-runstep")
     	       (args:get-arg "-envcap")
     	       (args:get-arg "-envdelta")
     	       )
     	      ))
         (debug:print-error 0 *default-log-port* "Unrecognised arguments: " (string-intersperse (if (list? remargs) remargs (argv))  " ")))
     
     ;; before doing anything else change to the start-dir if provided
     ;;
     (if (args:get-arg "-start-dir")
         (if (common:file-exists? (args:get-arg "-start-dir"))
             (let ((fullpath (common:real-path (args:get-arg "-start-dir"))))
               (set-environment-variable! "PWD" fullpath)
               (change-directory fullpath))
     	(begin
     	  (debug:print-error 0 *default-log-port* "non-existant start dir " (args:get-arg "-start-dir") " specified, exiting.")
     	  (exit 1))))
     
     ;; immediately set MT_TARGET if -reqtarg or -target are available
     ;;
     (let ((targ (or (args:get-arg "-reqtarg")(args:get-arg "-target"))))
       (if targ (set-environment-variable! "MT_TARGET" targ)))
     
     ;; The watchdog is to keep an eye on things like db sync etc.
     ;;
;; (init-watchdog)
  
;;      (define (debug:debug-mode n)
;;        (cond
;;         ((and (number? *verbosity*)   ;; number number
;;      	 (number? n))
;;          (<= n *verbosity*))
;;         ((and (list? *verbosity*)     ;; list   number
;;      	 (number? n))
;;          (member n *verbosity*))
;;         ((and (list? *verbosity*)     ;; list   list
;;      	 (list? n))
;;          (not (null? (lset-intersection! eq? *verbosity* n))))
;;         ((and (number? *verbosity*)
;;      	 (list? n))
;;          (member *verbosity* n))))

     ;; this segment will run launch:setup only if -log is not set. This is fairly safe as servers are not
     ;; manually started and thus should never be started in a non-megatest area. Thus no need to handle situation
     ;; where (launch:setup) returns #f?
     ;;
     (if (or (args:get-arg "-log") ;;(args:get-arg "-server") ;; redirect the log always when a server
	     (args:get-arg "-autolog"))
         (handle-exceptions
     	exn
     	(begin
     	  (print "ERROR: Failed to switch to log output. " ((condition-property-accessor 'exn 'message) exn) ", exn=" exn)
     	  )
        (let* ((tl   (or (args:get-arg "-log")
			 (args:get-arg "-autolog") ;; autolog provides the basename .../logs/something- for the logfile
			 (launch:setup)))   ;; run launch:setup if -server, ensure we do NOT run launch:setup if -log specified
     	       (logf (or (args:get-arg "-log") ;; use -log unless we are a server, then craft a logfile name
			 (conc tl (current-process-id)"-"(get-host-name)".log")
     			 (conc tl "/logs/server-" (current-process-id) "-" (get-host-name) ".log")))
     	       (oup  (open-logfile logf)))
     	(if (not (args:get-arg "-log"))
     	    (hash-table-set! args:arg-hash "-log" logf)) ;; fake out future queries of -log
     	(debug:print-info 0 *default-log-port* "Sending log output to " logf)
     	(set! *default-log-port* oup))))
     
     (if (or (args:get-arg "-h")
     	(args:get-arg "-help")
     	(args:get-arg "--help"))
         (begin
           (print help)
           (exit)))
     
     (if (args:get-arg "-manual")
         (let* ((htmlviewercmd (or (configf:lookup *configdat* "setup" "htmlviewercmd")
     			      (common:which '("firefox" "arora"))))
     	   (install-home  (common:get-install-area))
     	   (manual-html   (conc install-home "/share/docs/megatest_manual.html")))
           (if (and install-home
     	       (common:file-exists? manual-html))
     	  (system (conc "(" htmlviewercmd " " manual-html " ) &"))
     	  (system (conc "(" htmlviewercmd " http://www.kiatoa.com/cgi-bin/fossils/megatest/doc/tip/docs/manual/megatest_manual.html ) &")))
           (exit)))
     
     (if (args:get-arg "-version")
         (begin
           (print (common:version-signature)) ;; (print megatest-version)
           (exit)))
     
     ;; Overall exit handling setup immediately
     ;;
     (if (or (args:get-arg "-process-reap"))
             ;; (args:get-arg "-runtests")
     	;; (args:get-arg "-execute")
     	;; (args:get-arg "-remove-runs")
     	;; (args:get-arg "-runstep"))
         (let ((original-exit (exit-handler)))
           (exit-handler (lambda (#!optional (exit-code 0))
     		      (printf "Preparing to exit with exit code ~A ...\n" exit-code)
     		      (for-each
     		       
     		       (lambda (pid)
     			 (handle-exceptions
     			     exn
     			   (begin
     			     (printf "process reap failed. exn=~A\n" exn)
     			     #t)
     			  (let-values (((pid-val exit-status exit-code) (process-wait pid #t)))
     				      (if (or (eq? pid-val pid)
     					      (eq? pid-val 0))
     					  (begin
     					    (printf "Sending signal/term to ~A\n" pid)
     					    (process-signal pid signal/term))))))
     		       (process:children #f))
     		      (original-exit exit-code)))))
     
     ;; for some switches always print the command to stderr
     ;;
     (if (args:any-defined? "-run" "-runall" "-remove-runs" "-set-state-status" "-kill-runs" "-kill-rerun")
         (debug:print 0 *default-log-port* (string-intersperse (argv) " ")))
     
     ;; some switches imply homehost. Exit here if not on homehost
     ;;
     #;(let ((homehost-required  (list "-cleanup-db" "-server")))
       (if (apply args:any-defined? homehost-required)
           (if (not (common:on-homehost?))
     	  (for-each
     	   (lambda (switch)
     	     (if (args:get-arg switch)
     		 (begin
     		   (debug:print 0 *default-log-port* "ERROR: you must be on the homehost to run with " switch
     				", you can move homehost by removing the .homehost file but this will disrupt any runs in progress.")
     		   (exit 1))))
     	   homehost-required))))
     
     ;;======================================================================
     ;; Misc setup stuff
     ;;======================================================================
     
     (debug:setup)
     
     (if (args:get-arg "-logging")(set! *logging* #t))
     
     ;;(if (debug:debug-mode 3) ;; we are obviously debugging
     ;;    (set! open-run-close open-run-close-no-exception-handling))
     
     (if (args:get-arg "-itempatt")
         (let ((newval (conc (args:get-arg "-testpatt") "/" (args:get-arg "-itempatt"))))
           (debug:print 0 *default-log-port* "WARNING: -itempatt has been deprecated, please use -testpatt testpatt/itempatt method, new testpatt is "newval)
           (hash-table-set! args:arg-hash "-testpatt" newval)
           (hash-table-delete! args:arg-hash "-itempatt")))
     
     (if (args:get-arg "-runtests")
         (debug:print 0 *default-log-port* "WARNING: \"-runtests\" is deprecated. Use \"-run\" with \"-testpatt\" instead"))

     ;; (debug:print 0 *default-log-port* "on-exit disabled. Please re-enable")
     (on-exit std-exit-procedure)
     
     ;;======================================================================
     ;; Misc general calls
     ;;======================================================================

;; TODO: Restore this functionality

     #; (if (and (args:get-arg "-cache-db")
              (args:get-arg "-source-db"))
         (let* ((temp-dir (or (args:get-arg "-target-db") (create-directory (conc "/tmp/" (get-environment-variable "USER") "/" (string-translate (current-directory) "/" "_")))))
                (target-db (conc temp-dir "/cached.db"))
                (source-db (args:get-arg "-source-db")))        
           (db:cache-for-read-only source-db target-db)
           (set! *didsomething* #t)))
     
     ;; handle a clean-cache request as early as possible
     ;;
     (if (args:get-arg "-clean-cache")
         (let ((toppath  (launch:setup)))
           (set! *didsomething* #t) ;; suppress the help output.
           (runs:clean-cache (common:args-get-target)
     			(args:get-arg "-runname")
     			toppath)))
     	  
     (if (args:get-arg "-env2file")
         (begin
           (save-environment-as-files (args:get-arg "-env2file"))
           (set! *didsomething* #t)))
     
     (if (args:get-arg "-list-disks")
         (let ((toppath (launch:setup)))
           (print 
            (string-intersperse 
     	(map (lambda (x)
     	       (string-intersperse 
     		x
     		" => "))
     	     (common:get-disks *configdat*))
     	"\n"))
           (set! *didsomething* #t)))
     
     
  (if (args:get-arg "-refdb2dat")
         (let* ((input-db (args:get-arg "-refdb2dat"))
     	   (out-file (args:get-arg "-o"))
     	   (out-fmt  (or (args:get-arg "-dumpmode") "scheme"))
     	   (out-port (if (and out-file 
     			      (not (member out-fmt '("sqlite3" "csv"))))
     			 (open-output-file out-file)
     			 (current-output-port)))
     	   (res-data (configf:read-refdb input-db))
     	   (data     (car res-data))
     	   (msg      (cadr res-data)))
           (if (not data)
     	  (debug:print 0 *default-log-port* "Bad input? data=" data) ;; some error occurred
     	  (with-output-to-port out-port
     	    (lambda ()
     	      (case (string->symbol out-fmt)
     		((scheme)(pp data))
     		((perl)
     		 ;; (print "%hash = (")
     		 ;;        key1 => 'value1',
     		 ;;        key2 => 'value2',
     		 ;;        key3 => 'value3',
     		 ;; );
     		 (configf:map-all-hier-alist 
     		  data 
     		  (lambda (sheetname sectionname varname val)
     		    (print "$data{\"" sheetname "\"}{\"" sectionname "\"}{\"" varname "\"} = \"" val "\";"))))
     		((python ruby)
     		 (print "data={}")
     		 (configf:map-all-hier-alist
     		  data
     		  (lambda (sheetname sectionname varname val)
     		    (print "data[\"" sheetname "\"][\"" sectionname "\"][\"" varname "\"] = \"" val "\""))
     		  initproc1:
     		  (lambda (sheetname)
     		    (print "data[\"" sheetname "\"] = {}"))
     		  initproc2:
     		  (lambda (sheetname sectionname)
     		    (print "data[\"" sheetname "\"][\"" sectionname "\"] = {}"))))
     		((csv)
     		 (let* ((results  (make-hash-table)) ;; (make-sparse-array)))
     			(row-cols (make-hash-table))) ;; hash of hashes where section => ht { row-<name> => num or col-<name> => num
     		   ;; (print "data=")
     		   ;; (pp data)
     		   (configf:map-all-hier-alist
     		    data
     		    (lambda (sheetname sectionname varname val)
     		      ;; (print "sheetname: " sheetname ", sectionname: " sectionname ", varname: " varname ", val: " val)
     		      (let* ((dat      (get-dat results sheetname))
     			     (vec      (refdb:csv-get-svec dat))
     			     (rownames (refdb:csv-get-rows dat))
     			     (colnames (refdb:csv-get-cols dat))
     			     (currrown (hash-table-ref/default rownames varname #f))
     			     (currcoln (hash-table-ref/default colnames sectionname #f))
     			     (rown     (or currrown 
     					   (let* ((lastn   (refdb:csv-get-maxrow dat))
     						  (newrown (+ lastn 1)))
     					     (refdb:csv-set-maxrow! dat newrown)
     					     newrown)))
     			     (coln     (or currcoln 
     					   (let* ((lastn   (refdb:csv-get-maxcol dat))
     						  (newcoln (+ lastn 1)))
     					     (refdb:csv-set-maxcol! dat newcoln)
     					     newcoln))))
     			(if (not (sparse-array-ref vec 0 coln)) ;; (eq? rown 0)
     			    (begin
     			      (sparse-array-set! vec 0 coln sectionname)
     			      ;; (print "sparse-array-ref " 0 "," coln "=" (sparse-array-ref vec 0 coln))
     			      ))
     			(if (not (sparse-array-ref vec rown 0)) ;; (eq? coln 0)
     			    (begin
     			      (sparse-array-set! vec rown 0 varname)
     			      ;; (print "sparse-array-ref " rown "," 0 "=" (sparse-array-ref vec rown 0))
     			      ))
     			(if (not currrown)(hash-table-set! rownames varname rown))
     			(if (not currcoln)(hash-table-set! colnames sectionname coln))
     			;; (print "dat=" dat ", rown=" rown ", coln=" coln)
     			(sparse-array-set! vec rown coln val)
     			;; (print "sparse-array-ref " rown "," coln "=" (sparse-array-ref vec rown coln))
     			)))
     		   (for-each
     		    (lambda (sheetname)
     		      (let* ((sheetdat (get-dat results sheetname))
     			     (svec     (refdb:csv-get-svec sheetdat))
     			     (maxrow   (refdb:csv-get-maxrow sheetdat))
     			     (maxcol   (refdb:csv-get-maxcol sheetdat))
     			     (fname    (if out-file 
     					   (string-substitute "%s" sheetname out-file) ;; "/foo/bar/%s.csv")
     					   (conc sheetname ".csv"))))
     			(with-output-to-file fname
     			  (lambda ()
     			    ;; (print "Sheetname: " sheetname)
     			    (let loop ((row       0)
     				       (col       0)
     				       (curr-row '())
     				       (result   '()))
     			      (let* ((val (sparse-array-ref svec row col))
     				     (disp-val (if val
     						   (conc "\"" val "\"")
     						   "")))
     				(if (> col 0)(display ","))
     				(display disp-val)
     				(cond
     				 ((> row maxrow)(display "\n") result)
     				 ((>= col maxcol)
     				  (display "\n")
     				  (loop (+ row 1) 0 '() (append result (list curr-row))))
     				 (else
     				  (loop row (+ col 1) (append curr-row (list val)) result)))))))))
     		    (hash-table-keys results))))
     		((sqlite3)
     		 (let* ((db-file   (or out-file (pathname-file input-db)))
     			(db-exists (common:file-exists? db-file))
     			(db        (sqlite3:open-database db-file)))
     		   (if (not db-exists)(sqlite3:execute db "CREATE TABLE data (sheet,section,var,val);"))
     		   (configf:map-all-hier-alist
     		    data
     		    (lambda (sheetname sectionname varname val)
     		      (sqlite3:execute db
     				       "INSERT OR REPLACE INTO data (sheet,section,var,val) VALUES (?,?,?,?);"
     				       sheetname sectionname varname val)))
     		   (sqlite3:finalize! db)))
     		(else
     		 (pp data))))))
           (if out-file (close-output-port out-port))
           (exit) ;; yes, bending the rules here - need to exit since this is a utility
           ))

  ;; disabled for now
  
     #;(if (args:get-arg "-ping")
         (let* ((server-id     (string->number (args:get-arg "-ping"))) ;; extract run-id (i.e. no ":"
     	   (host:port     (args:get-arg "-ping")))
           (server-ready? (or server-id host:port) #f do-exit: #t)))
     
     ;;======================================================================
     ;; Capture, save and manipulate environments
     ;;======================================================================
     
     ;; NOTE: Keep these above the section where the server or client code is setup
     
     (let ((envcap (args:get-arg "-envcap")))
       (if envcap
           (let* ((db      (env:open-db (if (null? remargs) "envdat.db" (car remargs)))))
     	(env:save-env-vars db envcap)
     	(env:close-database db)
     	(set! *didsomething* #t))))
     
     ;; delta "language" will eventually be res=a+b-c but for now it is just res=a-b 
     ;;
     (let ((envdelta (args:get-arg "-envdelta")))
       (if envdelta
           (let ((match (string-split envdelta "-")));; (string-match "([a-z0-9_]+)=([a-z0-9_\\-,]+)" envdelta)))
     	(if (not (null? match))
     	    (let* ((db        (env:open-db (if (null? remargs) "envdat.db" (car remargs))))
     		   ;; (resctx    (cadr match))
     		   ;; (equn      (caddr match))
     		   (parts     match) ;; (string-split equn "-"))
     		   (minuend   (car parts))
     		   (subtraend (cadr parts))
     		   (added     (env:get-added   db minuend subtraend))
     		   (removed   (env:get-removed db minuend subtraend))
     		   (changed   (env:get-changed db minuend subtraend)))
     	      ;; (pp (hash-table->alist added))
     	      ;; (pp (hash-table->alist removed))
     	      ;; (pp (hash-table->alist changed))
     	      (if (args:get-arg "-o")
     		  (with-output-to-file
     		      (args:get-arg "-o")
     		    (lambda ()
     		      (env:print added removed changed)))
     		  (env:print added removed changed))
     	      (env:close-database db)
     	      (set! *didsomething* #t))
     	    (debug:print-error 0 *default-log-port* "Parameter to -envdelta should be new=start-end")))))
     
     ;;======================================================================
     ;; 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
     ;;======================================================================
     
     ;; Server? Start up here.
     ;;
     (if (args:get-arg "-server")
	 (if  (not (args:get-arg "-db"))
	      (debug:print 0 *default-log-port* "ERROR: -db required to start server")
	      (let ((tl        (launch:setup))
		    (dbname    (args:get-arg "-db"))) ;; transport-type (string->symbol (or (args:get-arg "-transport") "http"))))
		(rmt:server-launch dbname)
		(set! *didsomething* #t))))
	 
     ;; The adjutant is a bit different, it does NOT run (launch:setup) as it is not necessarily tied to
     ;; a specific Megatest area. Detail are being hashed out and this may change.
     ;;
     (if (args:get-arg "-adjutant")
         (begin
           (adjutant-run)
           (set! *didsomething* #t)))
     
     (if (or (args:get-arg "-list-servers")
             (args:get-arg "-kill-servers"))
         (let ((tl (launch:setup)))
           (if tl ;; all roads from here exit
     	  (let* ((servers (rmt:get-servers-info *toppath*))
     		 (fmtstr  "~8a~22a~20a~20a~8a\n"))
	    ;; id INTEGER PRIMARY KEY,
	    ;; host TEXT,
	    ;; port INTEGER,
	    ;; servkey TEXT,
	    ;; pid TEXT,
	    ;; ipaddr TEXT,
	    ;; apath TEXT,
	    ;; dbname TEXT,
	    ;; event_time 
     	    (format #t fmtstr "pid" "Interface:port" "State" "dbname" "apath")
     	    (format #t fmtstr "===" "==============" "=====" "======" "=====")
     	    (for-each ;;  ( mod-time host port start-time pid )
     	     (lambda (server)
	       (match-let
		(((id host port servkey pid ipaddr apath dbname event_time) server))
     		(format #t
     			fmtstr
     			pid
     			(conc host":"port)
     			(if (server-ready? host port servkey) "Running" "Dead")
     			dbname ;; (seconds->hr-min-sec mod)
     			apath
			)
     		 (if (args:get-arg "-kill-servers")
     		     (begin
     		       (debug:print-info 0 *default-log-port* "Attempting to kill server with pid " pid " !!needs completion!!")
     		       #;(server:kill server)))))
     	     servers)
     	    ;; (debug:print-info 1 *default-log-port* "Done with listservers")
     	    (set! *didsomething* #t)
     	    (exit))
     	  (exit))))
           ;; must do, would have to add checks to many/all calls below
     
     ;;======================================================================
     ;; Weird special calls that need to run *after* the server has started?
     ;;======================================================================
     
     (if (args:get-arg "-list-targets")
         (if (launch:setup)
             (let* ((rconfdat (configf:read-config (conc *toppath* "/runconfigs.config") #f #f))
		    (targets  (common:get-runconfig-targets rconfdat)))
               ;; (debug:print 1 *default-log-port* "Found "(length targets) " targets")
               (case (string->symbol (or (args:get-arg "-dumpmode") "alist"))
                 ((alist)
                  (for-each (lambda (x)
                              ;; (print "[" x "]"))
                              (print x))
                            targets))
                 ((json)
                  (json-write targets))
                 (else
                  (debug:print-error 0 *default-log-port* "dump output format " (args:get-arg "-dumpmode") " not supported for -list-targets")))
               (set! *didsomething* #t))))


     (if (args:get-arg "-show-runconfig")
         (let ((tl (launch:setup)))
           (push-directory *toppath*)
           (let ((data (full-runconfigs-read)))
     	;; keep this one local
     	(cond
     	 ((and (args:get-arg "-section")
     	       (args:get-arg "-var"))
     	  (let ((val (or (configf:lookup data (args:get-arg "-section")(args:get-arg "-var"))
     			 (configf:lookup data "default" (args:get-arg "-var")))))
     	    (if val (print val))))
     	 ((or (not (args:get-arg "-dumpmode"))
                   (string=? (args:get-arg "-dumpmode") "ini"))
     	  (configf:config->ini data))
     	 ((string=? (args:get-arg "-dumpmode") "sexp")
     	  (pp (hash-table->alist data)))
     	 ((string=? (args:get-arg "-dumpmode") "json")
     	  (json-write data))
     	 (else
     	  (debug:print-error 0 *default-log-port* "-dumpmode of " (args:get-arg "-dumpmode") " not recognised")))
     	(set! *didsomething* #t))
           (pop-directory)))
     
     (if (args:get-arg "-show-config")
         (let ((tl   (launch:setup))
     	  (data *configdat*)) ;; (configf:read-config "megatest.config" #f #t)))
           (push-directory *toppath*)
           ;; keep this one local
           (cond 
            ((and (args:get-arg "-section")
     	     (args:get-arg "-var"))
     	(let ((val (configf:lookup data (args:get-arg "-section")(args:get-arg "-var"))))
     	  (if val (print val))))
     
            ;; print just a section if only -section
     
            ((equal? (args:get-arg "-dumpmode") "sexp")
     	(pp (hash-table->alist data)))
            ((equal? (args:get-arg "-dumpmode") "json")
     	(json-write data))
            ((or (not (args:get-arg "-dumpmode"))
     	    (string=? (args:get-arg "-dumpmode") "ini"))
     	(configf:config->ini data))
            (else
     	(debug:print-error 0 *default-log-port* "-dumpmode of " (args:get-arg "-dumpmode") " not recognised")))
           (set! *didsomething* #t)
           (pop-directory)
           (bdat-time-to-exit-set! *bdat* #t)))
     
     (if (args:get-arg "-show-cmdinfo")
         (if (or (args:get-arg ":value")(get-environment-variable "MT_CMDINFO"))
     	(let ((data (common:read-encoded-string (or (args:get-arg ":value")(get-environment-variable "MT_CMDINFO")))))
     	  (if (equal? (args:get-arg "-dumpmode") "json")
     	      (json-write data)
     	      (pp data))
     	  (set! *didsomething* #t))
     	(debug:print-info 0 *default-log-port* "environment variable MT_CMDINFO is not set")))
     
     ;;======================================================================
     ;; Remove old run(s)
     ;;======================================================================
     
     ;; since several actions can be specified on the command line the removal
     ;; is done first
     (define (operate-on action #!key (mode #f)(target-in #f)(runname-in #f)(keys-in #f)(keyvals-in #f)) ;; #f is "use default"
       (let* ((runrec (runs:runrec-make-record))
     	 (target (or target-in   (common:args-get-target))) ;; eventually get rid of the call to common:args-get-target
     	 (runname (or runname-in
     		      (args:get-arg "-runname"))) ;; eventually get rid of the get-arg calls
     	 (testpatt (or (args:get-arg "-testpatt")
     		       (and (eq? action 'archive) ;; if it is an archive command fallback to MT_TEST_NAME and MT_ITEMPATH
     			    (common:get-full-test-name))
     		       (and (eq? action 'kill-runs)
     			    "%/%") ;; I'm just guessing that this is correct :(
     		       (common:args-get-testpatt #f) ;; (args:get-arg "-testpatt")))
     		       ))) ;;
         (cond
          ((not target)
           (debug:print-error 0 *default-log-port* "Missing required parameter for "
     			 action ", you must specify -target or -reqtarg")
           (exit 1))
          ((not runname)
           (debug:print-error 0 *default-log-port* "Missing required parameter for "
     			 action ", you must specify the run name pattern with -runname patt")
           (exit 2))
          ((not testpatt)
           (debug:print-error 0 *default-log-port* "Missing required parameter for "
     			 action ", you must specify the test pattern with -testpatt")
           (exit 3))
          (else
           (if (not (car *configinfo*))
     	  (begin
     	    (debug:print-error 0 *default-log-port* "Attempted " action "on test(s) but run area config file not found")
     	    (exit 1))
     	  ;; put test parameters into convenient variables
     	  (begin
     	    ;; check for correct version, exit with message if not correct

	    ;; TODO: restore this functionality
	    
	    ;; (common:exit-on-version-changed)
	    
     	    (runs:operate-on  action
     			      target
     			      runname
     			      testpatt
     			      state:  (common:args-get-state)
     			      status: (common:args-get-status)
     			      new-state-status: (args:get-arg "-set-state-status")
                                   mode: mode)))
           (set! *didsomething* #t)))))
     
     (if (args:get-arg "-kill-runs")
         (general-run-call 
          "-kill-runs"
          "kill runs"
          (lambda (target runname keys keyvals)
            (operate-on 'kill-runs mode: #f)
            )))
     
     (if (args:get-arg "-kill-rerun")
         (let* ((target-patt (common:args-get-target))
                (runname-patt (args:get-arg "-runname")))
           (cond ((not target-patt)
                  (debug:print-error 0 *default-log-port* "Missing target, must specify target for -kill-rerun with -target <target name>")
                  (exit 1))
                 ((not runname-patt)
                  (debug:print-error 0 *default-log-port* "Missing runname, must specify runname for -kill-rerun with -runname <run name>")
                  (exit 1))
                 ((string-search "[ ,%]" target-patt)
                  (debug:print-error 0 *default-log-port* "Invalid target ["target-patt"], must specify exact target (no wildcards) for -kill-rerun with -target <target name>")
                  (exit 1))
                 ((string-search "[ ,%]" runname-patt)
                  (debug:print-error 0 *default-log-port* "Invalid runname ["runname-patt"], must specify exact runname (no wildcards) for -kill-rerun with -runname <runname name>")
                  (exit 1))
                 (else
                  (general-run-call 
                   "-kill-runs"
                   "kill runs"
                   (lambda (target runname keys keyvals)
                     (operate-on 'kill-runs mode: #f)
                     ))
           
                  (thread-sleep! 15))
                 ;; fall thru and let "-run" loop fire
                 )))
     
     
     (if (args:get-arg "-remove-runs")
         (general-run-call 
          "-remove-runs"
          "remove runs"
          (lambda (target runname keys keyvals)
            (operate-on 'remove-runs mode: (if (args:get-arg "-keep-records")
                                               'remove-data-only
                                               'remove-all)))))
     
     (if (args:get-arg "-remove-keep")
         (general-run-call 
          "-remove-keep"
          "remove keep"
          (lambda (target runname keys keyvals)
            (let ((actions (map string->symbol
                                (string-split
     			    (or (args:get-arg "-actions")
     				"print")
     			    ",")))) ;; default to printing the output
              (runs:remove-all-but-last-n-runs-per-target target runname
     						     (string->number (args:get-arg "-remove-keep"))
     						     actions: actions)))))
     
     (if (args:get-arg "-set-state-status")
         (general-run-call 
          "-set-state-status"
          "set state and status"
          (lambda (target runname keys keyvals)
            (operate-on 'set-state-status))))
     
     (if (or (args:get-arg "-set-run-status")
     	(args:get-arg "-get-run-status"))
         (general-run-call
          "-set-run-status"
          "set run status"
          (lambda (target runname keys keyvals)
            (let* ((runsdat  (rmt:get-runs-by-patt keys runname 
     					(common:args-get-target)
     					#f #f #f #f))
     	      (header   (vector-ref runsdat 0))
     	      (rows     (vector-ref runsdat 1)))
     	 (if (null? rows)
     	     (begin
     	       (debug:print-info 0 *default-log-port* "No matching run found.")
     	       (exit 1))
     	     (let* ((row      (car (vector-ref runsdat 1)))
     		    (run-id   (db:get-value-by-header row header "id")))
     	       (if (args:get-arg "-set-run-status")
     		   (rmt:set-run-status run-id (args:get-arg "-set-run-status") msg: (args:get-arg "-m"))
     		   (print (rmt:get-run-status run-id))
     		   )))))))
     
     ;;======================================================================
     ;; Query runs
     ;;======================================================================
     
     ;; -fields runs:id,target,runname,comment+tests:id,testname,item_path+steps
     ;;
     ;; csi> (extract-fields-constraints "runs:id,target,runname,comment+tests:id,testname,item_path+steps")
     ;;         => (("runs" "id" "target" "runname" "comment") ("tests" "id" "testname" "item_path") ("steps"))
     ;;
     ;;   NOTE: remember that the cdr will be the list you expect (cdr ("runs" "id" "target" "runname" "comment")) => ("id" "target" "runname" "comment")
     ;;         and so alist-ref will yield what you expect
     ;;
     (define (extract-fields-constraints fields-spec)
       (map (lambda (table-spec) ;; runs:id,target,runname
     	 (let ((dat (string-split table-spec ":"))) ;; ("runs" "id,target,runname")
     	   (if (> (length dat) 1)
     	       (cons (car dat)(string-split (cadr dat) ",")) ;; "id,target,runname"
     	       dat)))
            (string-split fields-spec "+")))
     
     (define (get-value-by-fieldname datavec test-field-index fieldname)
       (let ((indx (hash-table-ref/default test-field-index fieldname #f)))
         (if indx
     	(if (>= indx (vector-length datavec))
     	    #f ;; index too high, should raise an error I suppose
     	    (vector-ref datavec indx))
     	#f)))
     
     
     
     
     
     (when (args:get-arg "-testdata-csv")
       (if (launch:setup)
           (let* ((keys        (rmt:get-keys)) ;; (db:get-keys dbstruct))
                  (runpatt     (or (args:get-arg "-runname") "%"))
                  (testpatt    (common:args-get-testpatt #f))
                  (datapatt    (args:get-arg "-testdata-csv"))
                  (match-data  (string-match "^([^/]+)/(.*)" (args:get-arg "-testdata-csv")))
                  (categorypatt (if match-data (list-ref match-data 1) "%"))
                  (setvarpatt  (if match-data
                                   (list-ref match-data 2)
                                   (args:get-arg "-testdata-csv")))
                  (runsdat     (rmt:get-runs-by-patt keys (or runpatt "%") 
                                                     (common:args-get-target) #f #f '("id" "runname" "state" "status" "owner" "event_time" "comment") 0))
                  (header      (db:get-header runsdat))
                  (access-mode (db:get-access-mode))
                  (testpatt    (common:args-get-testpatt #f))
                  (fields-spec (if (args:get-arg "-fields")
                                   (extract-fields-constraints (args:get-arg "-fields"))
                                   (list (cons "runs" (append keys (list "id" "runname" "state" "status" "owner" "event_time" "comment" "fail_count" "pass_count")))
                                         (cons "tests"  db:test-record-fields) ;; "id" "testname" "test_path")
                                         (list "steps" "id" "stepname"))))
                  (tests-spec  (let ((t (alist-ref "tests" fields-spec equal?)))
                                 (if (and t (null? t)) ;; all fields
                                     db:test-record-fields
                                     t)))
                  (adj-tests-spec (delete-duplicates (if tests-spec (cons "id" tests-spec) db:test-record-fields))) 
                  (test-field-index (make-hash-table))
                  (runs (db:get-rows runsdat))
                  )
             (if (and tests-spec (not (null? tests-spec))) ;; do some validation and processing of the test-spec
                 (let ((invalid-tests-spec (filter (lambda (x)(not (member x db:test-record-fields))) tests-spec)))
                   (if (null? invalid-tests-spec)
                       ;; generate the lookup map test-field-name => index-number
                       (let loop ((hed (car adj-tests-spec))
                                  (tal (cdr adj-tests-spec))
                                  (idx 0))
                         (hash-table-set! test-field-index hed idx)
                         (if (not (null? tal))(loop (car tal)(cdr tal)(+ idx 1))))
                       (begin
                         (debug:print-error 0 *default-log-port* "Invalid test fields specified: " (string-intersperse invalid-tests-spec ", "))
                         (exit)))))
             (let* ((table-header (string-split "target,run,test,itempath,category,var,value,comment" ","))
                    (table-rows
                     (apply append (map  
                                    (lambda (run)
                                      (let* ((target (string-intersperse (map (lambda (x)
     							 (db:get-value-by-header run header x))
     						       keys) "/"))
                                             (statuses (string-split (or (args:get-arg "-status") "") ","))
                                             (run-id  (db:get-value-by-header run header "id"))
                                             (runname (db:get-value-by-header run header "runname")) 
                                             (states  (string-split (or (args:get-arg "-state") "") ","))
                                             (tests   (if tests-spec
                                                          (rmt:get-tests-for-run run-id testpatt states statuses #f #f #f 'testname 'asc ;; (db:get-tests-for-run dbstruct run-id testpatt '() '() #f #f #f 'testname 'asc 
                                                                             ;; use qryvals if test-spec provided
                                                                             (if tests-spec
                                                                                 (string-intersperse adj-tests-spec ",")
                                                                                 ;; db:test-record-fields
                                                                                 #f)
                                                                             #f
                                                                             'normal)
                                                          '())))
                                        (apply append
                                               (map
                                                (lambda (test)
                                                  (let* (
                                                         (test-id      (if (member "id"           tests-spec)(get-value-by-fieldname test test-field-index "id"          ) #f)) ;; (db:test-get-id         test))
                                                         (testname     (if (member "testname"     tests-spec)(get-value-by-fieldname test test-field-index "testname"    ) #f)) ;; (db:test-get-testname   test))
                                                         (itempath     (if (member "item_path"    tests-spec)(get-value-by-fieldname test test-field-index "item_path"   ) #f)) ;; (db:test-get-item-path  test))
                                                         (fullname     (conc testname
                                                                             (if (equal? itempath "")
                                                                                 "" 
                                                                                 (conc "/" itempath ))))
                                                         (testdat-raw (map vector->list (rmt:read-test-data-varpatt run-id test-id categorypatt setvarpatt)))
                                                         (testdat (filter
                                                                   (lambda (x)
                                                                     (not (equal? "logpro"
                                                                                  (list-ref x 10))))
                                                                   testdat-raw)))
                                                    (map 
                                                     (lambda (item)
                                                       (receive (id test_id category
                                                                    variable value expected
                                                                    tol units comment status type)
                                                           (apply values item)
                                                         (list target runname testname itempath category variable value comment)))
                                                     testdat)))
                                                tests))))
                                    runs))))
               (print (string-join table-header ","))
               (for-each (lambda(table-row)
                           (print (string-join (map ->string table-row) ",")))
     
                         
                                 table-rows))))
       (set! *didsomething* #t)
       (bdat-time-to-exit-set! *bdat* #t))
     
     
     
     ;; NOTE: list-runs and list-db-targets operate on local db!!!
     ;;
     ;; IDEA: megatest list -runname blah% ...
     ;;
     (if (or (args:get-arg "-list-runs")
     	(args:get-arg "-list-db-targets"))
         (if (launch:setup)
     	(let* (;; (dbstruct    (make-dbr:dbstruct path: *toppath* local: (args:get-arg "-local")))
     	       (runpatt     (args:get-arg "-list-runs"))
                    (access-mode (db:get-access-mode))
     	       (testpatt    (common:args-get-testpatt #f))
     	       ;; (if (args:get-arg "-testpatt") 
     	       ;;  	        (args:get-arg "-testpatt") 
     	       ;;  	        "%"))
     	       (keys        (rmt:get-keys)) ;; (db:get-keys dbstruct))
     	       ;; (runsdat  (db:get-runs dbstruct runpatt #f #f '()))
     	;; (runsdat     (rmt:get-runs-by-patt keys (or runpatt "%") (common:args-get-target) ;; (db:get-runs-by-patt dbstruct keys (or runpatt "%") (common:args-get-target)
     	;; 		           	 #f #f '("id" "runname" "state" "status" "owner" "event_time" "comment") 0))
     	       (runsdat     (rmt:get-runs-by-patt keys (or runpatt "%") 
                                                       (common:args-get-target) #f #f '("id" "runname" "state" "status" "owner" "event_time" "comment") 0))
     	       (runstmp     (db:get-rows runsdat))
     	       (header      (db:get-header runsdat))
     	       ;; this is "-since" support. This looks at last mod times of <run-id>.db files
     	       ;; and collects those modified since the -since time.
     	       (runs        runstmp)
                             ;; (if (and (not (null? runstmp))
     			;;        (args:get-arg "-since"))
     			;;   (let ((changed-ids (db:get-changed-run-ids (string->number (args:get-arg "-since")))))
     			;;     (let loop ((hed (car runstmp))
     			;;   	     (tal (cdr runstmp))
     			;;   	     (res '()))
     			;;       (let ((new-res (if (member (db:get-value-by-header hed header "id") changed-ids)
     			;;   		       (cons hed res)
     			;;   		       res)))
     			;;         (if (null? tal)
     			;;   	  (reverse new-res)
     			;;   	  (loop (car tal)(cdr tal) new-res)))))
     			;;   runstmp))
     	       (db-targets  (args:get-arg "-list-db-targets"))
     	       (seen        (make-hash-table))
     	       (dmode       (let ((d (args:get-arg "-dumpmode"))) ;; json, sexpr
     			      (if d (string->symbol d) #f)))
     	       (data        (make-hash-table))
     	       (fields-spec (if (args:get-arg "-fields")
     				(extract-fields-constraints (args:get-arg "-fields"))
     				(list (cons "runs" (append keys (list "id" "runname" "state" "status" "owner" "event_time" "comment" "fail_count" "pass_count")))
     				      (cons "tests"  db:test-record-fields) ;; "id" "testname" "test_path")
     				      (list "steps" "id" "stepname"))))
     	       (runs-spec   (let ((r (alist-ref "runs"  fields-spec equal?))) ;; the check is now unnecessary
     			      (if (and r (not (null? r))) r (list "id" ))))
     	       (tests-spec  (let ((t (alist-ref "tests" fields-spec equal?)))
     			      (if (and t (null? t)) ;; all fields
     				  db:test-record-fields
     				  t)))
     	       (adj-tests-spec (delete-duplicates (if tests-spec (cons "id" tests-spec) db:test-record-fields))) ;; '("id"))))
     	       (steps-spec  (alist-ref "steps" fields-spec equal?))
     	       (test-field-index (make-hash-table)))
     	  (if (and tests-spec (not (null? tests-spec))) ;; do some validation and processing of the test-spec
     	      (let ((invalid-tests-spec (filter (lambda (x)(not (member x db:test-record-fields))) tests-spec)))
     		(if (null? invalid-tests-spec)
     		    ;; generate the lookup map test-field-name => index-number
     		    (let loop ((hed (car adj-tests-spec))
     			       (tal (cdr adj-tests-spec))
     			       (idx 0))
     		      (hash-table-set! test-field-index hed idx)
     		      (if (not (null? tal))(loop (car tal)(cdr tal)(+ idx 1))))
     		    (begin
     		      (debug:print-error 0 *default-log-port* "Invalid test fields specified: " (string-intersperse invalid-tests-spec ", "))
     		      (exit)))))
     	  ;; Each run
     	  (for-each 
     	   (lambda (run)
     	     (let ((targetstr (string-intersperse (map (lambda (x)
     							 (db:get-value-by-header run header x))
     						       keys) "/")))
     	       (if db-targets
     		   (if (not (hash-table-ref/default seen targetstr #f))
     		       (begin
     			 (hash-table-set! seen targetstr #t)
     			 ;; (print "[" targetstr "]"))))
     			 (if (not dmode)
     			     (print targetstr)
     			     (hash-table-set! data "targets" (cons targetstr (hash-table-ref/default data "targets" '())))
     			     )))
     		   (let* ((run-id  (db:get-value-by-header run header "id"))
     			  (runname (db:get-value-by-header run header "runname")) 
     			  (states  (string-split (or (args:get-arg "-state") "") ","))
     			  (statuses (string-split (or (args:get-arg "-status") "") ","))
     			  (tests   (if tests-spec
     				       (rmt:get-tests-for-run run-id testpatt states statuses #f #f #f 'testname 'asc ;; (db:get-tests-for-run dbstruct run-id testpatt '() '() #f #f #f 'testname 'asc 
     							     ;; use qryvals if test-spec provided
     							     (if tests-spec
     								 (string-intersperse adj-tests-spec ",")
     								 ;; db:test-record-fields
     								 #f)
     							     #f
     							     'normal)
     				       '())))
     		     (case dmode
     		       ((json ods sexpr)
     			(if runs-spec
     			    (for-each 
     			     (lambda (field-name)
     			       (mutils:hierhash-set! data (conc (db:get-value-by-header run header field-name)) targetstr runname "meta" field-name))
     			     runs-spec)))
     			;; (mutils:hierhash-set! data (db:get-value-by-header run header "status")     targetstr runname "meta" "status"     )
     			;; (mutils:hierhash-set! data (db:get-value-by-header run header "state")      targetstr runname "meta" "state"      )
     			;; (mutils:hierhash-set! data (conc (db:get-value-by-header run header "id"))  targetstr runname "meta" "id"         )
     			;; (mutils:hierhash-set! data (db:get-value-by-header run header "event_time") targetstr runname "meta" "event_time" )
     			;; (mutils:hierhash-set! data (db:get-value-by-header run header "comment")    targetstr runname "meta" "comment"    )
     			;; ;; add last entry twice - seems to be a bug in hierhash?
     			;; (mutils:hierhash-set! data (db:get-value-by-header run header "comment")    targetstr runname "meta" "comment"    )
     		       (else
     			(if (null? runs-spec)
     			    (print "Run: " targetstr "/" runname 
     				   " status: " (db:get-value-by-header run header "state")
     				   " run-id: " run-id ", number tests: " (length tests)
     				   " event_time: " (db:get-value-by-header run header "event_time"))
     			    (begin
     			      (if (not (member "target" runs-spec))
     			          ;; (display (conc "Target: " targetstr))
     			          (display (conc "Run: " targetstr "/" runname " ")))
     			      (for-each
     			       (lambda (field-name)
     				 (if (equal? field-name "target")
     				     (display (conc "target: " targetstr " "))
     				     (display (conc field-name ": " (db:get-value-by-header run header (conc field-name)) " "))))
     			       runs-spec)
     			      (newline)))))
     		       
     		     (for-each 
     		      (lambda (test)
     		      	(handle-exceptions
     			 exn
     			 (begin
     			   (debug:print-error 0 *default-log-port* "Bad data in test record? " test)
     			   (debug:print-error 5 *default-log-port* "exn=" (condition->list exn))
     			   (debug:print 0 *default-log-port* " message: " ((condition-property-accessor 'exn 'message) exn))
     			   (print-call-chain (current-error-port)))
     			 (let* ((test-id      (if (member "id"           tests-spec)(get-value-by-fieldname test test-field-index "id"          ) #f)) ;; (db:test-get-id         test))
     				(testname     (if (member "testname"     tests-spec)(get-value-by-fieldname test test-field-index "testname"    ) #f)) ;; (db:test-get-testname   test))
     				(itempath     (if (member "item_path"    tests-spec)(get-value-by-fieldname test test-field-index "item_path"   ) #f)) ;; (db:test-get-item-path  test))
     				(comment      (if (member "comment"      tests-spec)(get-value-by-fieldname test test-field-index "comment"     ) #f)) ;; (db:test-get-comment    test))
     				(tstate       (if (member "state"        tests-spec)(get-value-by-fieldname test test-field-index "state"       ) #f)) ;; (db:test-get-state      test))
     				(tstatus      (if (member "status"       tests-spec)(get-value-by-fieldname test test-field-index "status"      ) #f)) ;; (db:test-get-status     test))
     				(event-time   (if (member "event_time"   tests-spec)(get-value-by-fieldname test test-field-index "event_time"  ) #f)) ;; (db:test-get-event_time test))
     				(rundir       (if (member "rundir"       tests-spec)(get-value-by-fieldname test test-field-index "rundir"      ) #f)) ;; (db:test-get-rundir     test))
     				(final_logf   (if (member "final_logf"   tests-spec)(get-value-by-fieldname test test-field-index "final_logf"  ) #f)) ;; (db:test-get-final_logf test))
     				(run_duration (if (member "run_duration" tests-spec)(get-value-by-fieldname test test-field-index "run_duration") #f)) ;; (db:test-get-run_duration test))
     				(fullname     (conc testname
     						    (if (equal? itempath "")
     							"" 
     							(conc "(" itempath ")")))))
     			   (case dmode
     			     ((json ods sexpr)
     			      (if tests-spec
     				  (for-each
     				   (lambda (field-name)
     				     (mutils:hierhash-set! data  (get-value-by-fieldname test test-field-index field-name) targetstr runname "data" (conc test-id) field-name))
     				   tests-spec)))
     			     ;; ;; (mutils:hierhash-set! data  fullname   targetstr runname "data" (conc test-id) "tname"     )
     			     ;;  (mutils:hierhash-set! data  testname   targetstr runname "data" (conc test-id) "testname"  )
     			     ;;  (mutils:hierhash-set! data  itempath   targetstr runname "data" (conc test-id) "itempath"  )
     			     ;;  (mutils:hierhash-set! data  comment    targetstr runname "data" (conc test-id) "comment"   )
     			     ;;  (mutils:hierhash-set! data  tstate     targetstr runname "data" (conc test-id) "state"     )
     			     ;;  (mutils:hierhash-set! data  tstatus    targetstr runname "data" (conc test-id) "status"    )
     			     ;;  (mutils:hierhash-set! data  rundir     targetstr runname "data" (conc test-id) "rundir"    )
     			     ;;  (mutils:hierhash-set! data  final_logf targetstr runname "data" (conc test-id) "final_logf")
     			     ;;  (mutils:hierhash-set! data  run_duration targetstr runname "data" (conc test-id) "run_duration")
     			     ;;  (mutils:hierhash-set! data  event-time targetstr runname "data" (conc test-id) "event_time")
     			     ;;  ;; add last entry twice - seems to be a bug in hierhash?
     			     ;;  (mutils:hierhash-set! data  event-time targetstr runname "data" (conc test-id) "event_time")
     			     ;;  )
     			     (else
     			      (if (and tstate tstatus event-time)
     				  (format #t
     					  "  Test: ~25a State: ~15a Status: ~15a Runtime: ~5@as Time: ~22a Host: ~10a\n"
     					  (if fullname fullname "")
     					  (if tstate   tstate   "")
     					  (if tstatus  tstatus  "")
     					  (get-value-by-fieldname test test-field-index "run_duration");;(if test     (db:test-get-run_duration test) "")
     					  (if event-time event-time "")
     					  (get-value-by-fieldname test test-field-index "host")) ;;(if test (db:test-get-host test)) "")
     				  (print "  Test: " fullname
     					 (if tstate  (conc " State: "  tstate)  "")
     					 (if tstatus (conc " Status: " tstatus) "")
     					 (if (get-value-by-fieldname test test-field-index "run_duration")
     					     (conc " Runtime: " (get-value-by-fieldname test test-field-index "run_duration"))
     					     "")
     					 (if event-time (conc " Time: " event-time) "")
     					 (if (get-value-by-fieldname test test-field-index "host")
     					     (conc " Host: " (get-value-by-fieldname test test-field-index "host"))
     					     "")))
     			      (if (not (or (equal? (get-value-by-fieldname test test-field-index "status") "PASS")
     					   (equal? (get-value-by-fieldname test test-field-index "status") "WARN")
     					   (equal? (get-value-by-fieldname test test-field-index "state")  "NOT_STARTED")))
     				  (begin
     				    (print   (if (get-value-by-fieldname test test-field-index "cpuload")
     						 (conc "         cpuload:  "   (get-value-by-fieldname test test-field-index "cpuload"))
     						 "") ;; (db:test-get-cpuload test)
     					     (if (get-value-by-fieldname test test-field-index "diskfree")
     						 (conc "\n         diskfree: " (get-value-by-fieldname test test-field-index "diskfree")) ;; (db:test-get-diskfree test)
     						 "")
     					     (if (get-value-by-fieldname test test-field-index "uname")
     						 (conc "\n         uname:    " (get-value-by-fieldname test test-field-index "uname")) ;; (db:test-get-uname test)
     						 "")
     					     (if (get-value-by-fieldname test test-field-index "rundir")
     						 (conc "\n         rundir:   " (get-value-by-fieldname test test-field-index "rundir")) ;; (db:test-get-rundir test)
     						 "")
     ;;					     "\n         rundir:   " (get-value-by-fieldname test test-field-index "") ;; (sdb:qry 'getstr ;; (filedb:get-path *fdb* 
     ;; 					     (db:test-get-rundir test) ;; )
     					     )
     				    ;; Each test
     				    ;; DO NOT remote run
     				    (let ((steps (rmt:get-steps-for-test run-id (db:test-get-id test)))) ;; (db:get-steps-for-test dbstruct run-id (db:test-get-id test))))
     				      (for-each 
     				       (lambda (step)
     					 (format #t 
     						 "    Step: ~20a State: ~10a Status: ~10a Time ~22a\n"
     						 (tdb:step-get-stepname step)
     						 (tdb:step-get-state step)
     						 (tdb:step-get-status step)
     						 (tdb:step-get-event_time step)))
     				       steps)))))))))
     		      (if (args:get-arg "-sort")
     			  (sort tests
     				(lambda (a-test b-test)
     				  (let* ((key    (args:get-arg "-sort"))
     					 (first  (get-value-by-fieldname a-test test-field-index key))
     					 (second (get-value-by-fieldname b-test test-field-index key)))
     				    ((cond 
     				      ((and (number? first)(number? second)) <)
     				      ((and (string? first)(string? second)) string<=?)
     				      (else equal?))
     				     first second))))
     			  tests))))))
     	   runs)
     	  (case dmode
     	    ((json)  (json-write data))
     	    ((sexpr) (pp (common:to-alist data))))
     	  (let* ((metadat-fields (delete-duplicates
     				  (append keys '( "runname" "time" "owner" "pass_count" "fail_count" "state" "status" "comment" "id"))))
     		 (run-fields    '(
     				  "testname"
     				  "item_path"
     				  "state"
     				  "status"
     				  "comment"
     				  "event_time"
     				  "host"
     				  "run_id"
     				  "run_duration"
     				  "attemptnum"
     				  "id"
     				  "archived"
     				  "diskfree"
     				  "cpuload"
     				  "final_logf"
     				  "shortdir"
     				  "rundir"
     				  "uname"
     				  )
     				)
     		 (newdat          (common:to-alist data))
     		 (allrundat       (if (null? newdat)
     				      '()
     				      (car (map cdr newdat)))) ;; (car (map cdr (car (map cdr newdat)))))
     		 (runs            (append
     				   (list "runs" ;; sheetname
     					 metadat-fields)
     				   (map (lambda (run)
     					  ;; (print "run: " run)
     					  (let* ((runname (car run))
     						 (rundat  (cdr run))
     						 (metadat (let ((tmp (assoc "meta" rundat)))
     							    (if tmp (cdr tmp) #f))))
     					    ;; (print "runname: " runname "\n\nrundat: " )(pp rundat)(print "\n\nmetadat: ")(pp metadat)
     					    (if metadat
     						(map (lambda (field)
     						       (let ((tmp (assoc field metadat)))
     							 (if tmp (cdr tmp) "")))
     						     metadat-fields)
     						(begin
     						  (debug:print 0 *default-log-port* "WARNING: meta data for run " runname " not found")
     						  '()))))
     					allrundat)))
     		 ;; '( ( "target" ( "runname" ( "data" ( "runid" ( "id . "37" ) ( ... ))))
     		 (run-pages      (map (lambda (targdat)
     					(let* ((target  (car targdat))
     					       (runsdat (cdr targdat)))
     					  (if runsdat
     					      (map (lambda (rundat)
     						     (let* ((runname  (car rundat))
     							    (rundat   (cdr rundat))
     							    (testsdat (let ((tmp (assoc "data" rundat)))
     									(if tmp (cdr tmp) #f))))
     						       (if testsdat
     							   (let ((tests (map (lambda (test)
     									       (let* ((test-id  (car test))
     										      (test-dat (cdr test)))
     										 (map (lambda (field)
     											(let ((tmp (assoc field test-dat)))
     											  (if tmp (cdr tmp) "")))
     										      run-fields)))
     									     testsdat)))
     							     ;; (print "Target: " target "/" runname " tests:")
     							     ;; (pp tests)
     							     (cons (conc target "/" runname)
     								   (cons (list (conc target "/" runname))
     									 (cons '()
     									       (cons run-fields tests)))))
     							   (begin
     							     (debug:print 4 *default-log-port* "WARNING: run " target "/" runname " appears to have no data")
     							     ;; (pp rundat)
     							     '()))))
     						   runsdat)
     					      '())))
     				      newdat)) ;; we use newdat to get target
     		 (sheets         (filter (lambda (x)
     					   (not (null? x)))
     					 (cons runs (map car run-pages)))))
     	    ;; (print "allrundat:")
     	    ;; (pp allrundat)
     	    ;; (print "runs:")
     	    ;; (pp runs)
     	    ;(print "sheets: ")
     	    ;; (pp sheets)
     	    (if (eq? dmode 'ods)
     		(let* ((tempdir    (conc "/tmp/" (current-user-name) "/" (pseudo-random-integer 10000) "_" (current-process-id)))
     		       (outputfile (or (args:get-arg "-o") "out.ods"))
     		       (ouf        (if (string-match (regexp "^[/~]+.*") outputfile) ;; full path?
     				       outputfile
     				       (begin
     					 (debug:print 0 *default-log-port* "WARNING: path given, " outputfile " is relative, prefixing with current directory")
     					 (conc (current-directory) "/" outputfile)))))
     		  (create-directory tempdir #t)
     		  (ods:list->ods tempdir ouf sheets))))
     	  ;; (system (conc "rm -rf " tempdir))
     	  (set! *didsomething* #t)
	  (bdat-time-to-exit-set! *bdat* #t)
	  ) ;; end if true branch (end of a let)
	) ;; end if
         ) ;; end if -list-runs

     ;; list-waivers
     (if (and (args:get-arg "-list-waivers")
     	 (launch:setup))
         (let* ((runpatt     (or (args:get-arg "-runname") "%"))
     	   (testpatt    (common:args-get-testpatt #f))
     	   (keys        (rmt:get-keys)) 
     	   (runsdat     (rmt:get-runs-by-patt
     			 keys runpatt 
     			 (common:args-get-target) #f #f
     			 '("id" "runname" "state" "status" "owner" "event_time" "comment") 0))
     	   (runs        (db:get-rows runsdat))
     	   (header      (db:get-header runsdat))
     	   (results     (make-hash-table))  ;; [target] ( (testname/itempath . "comment") ... )
     	   (addtest     (lambda (target testname itempath comment)
     			  (hash-table-set! results target (cons (cons (conc testname "/" itempath) comment)
     								(hash-table-ref/default results target '())))))
     	   (last-target #f))
           (for-each
            (lambda (run)
     	 (let* ((run-id  (db:get-value-by-header run header "id"))
     		(target  (rmt:get-target run-id))
     		(runname (db:get-value-by-header run header "runname")) 
     		(tests   (rmt:get-tests-for-run
     			  run-id testpatt '("COMPLETED") '("WAIVED") #f #f #f 'testname 'asc							     ;; use qryvals if test-spec provided
     			  #f #f #f)))
     	   (if (not (equal? target last-target))
     	       (print "[" target "]"))
     	   (set! last-target target)
     	   (print "# " runname)
     	   (for-each
     	    (lambda (testdat)
     	      (let* ((testfullname (conc (db:test-get-testname testdat)
     					 (if (equal? "" (db:test-get-item-path testdat))
     					     ""
     					     (conc "/" (db:test-get-item-path testdat)))
     					 )))
     	      (print testfullname " " (db:test-get-comment testdat))))
     	    tests)))
            runs)
           (set! *didsomething* #t)))
           
     
     ;; get lock in db for full run for this directory
     ;; for all tests with deps
     ;;   walk tree of tests to find head tasks
     ;;   add head tasks to task queue
     ;;   add dependant tasks to task queue 
     ;;   add remaining tasks to task queue
     ;; for each task in task queue
     ;;   if have adequate resources
     ;;     launch task
     ;;   else
     ;;     put task in deferred queue
     ;; if still ok to run tasks
     ;;   process deferred tasks per above steps
     
     ;; run all tests are are Not COMPLETED and PASS or CHECK
     (if (or (args:get-arg "-runall")
     	(args:get-arg "-run")
     	(args:get-arg "-rerun-clean")
     	(args:get-arg "-rerun-all")
     	(args:get-arg "-runtests")
             (args:get-arg "-kill-rerun"))
         (let ((need-clean (or (args:get-arg "-rerun-clean")
                               (args:get-arg "-rerun-all")))
     	  (orig-cmdline (string-intersperse (argv) " ")))
           (general-run-call 
            "-runall"
            "run all tests"
            (lambda (target runname keys keyvals)
     	 (if (or (string-search "%" target)
     		 (string-search "%" runname)) ;; we are being asked to re-run multiple runs
     	     (let* ((run-specs (rmt:simple-get-runs runname #f #f target #f))) ;; list of simple-run records
     	       (debug:print-info 0 *default-log-port* "Pattern supplied for target or runname with "
     				 (length run-specs) " matches round. Running each in turn.")
     	       (if (null? run-specs)
     		   (debug:print 0 *default-log-port* "WARNING: No runs match target " target " and runname " runname))
     	       (for-each (lambda (spec) 
     			   (let* ((precmd     (if (args:get-arg "-precmd")(conc (args:get-arg "-precmd") " ") ""))
     				  (newcmdline (conc
     					       precmd
     					       (string-substitute
     						(conc "target " target)
     						(conc "target " (simple-run-target spec))
     						(string-substitute
     						 (conc "runname " runname)
     						 (conc "runname " (simple-run-runname spec))
     						 orig-cmdline)))))
     			     (debug:print 0 *default-log-port* "ORIG: " orig-cmdline)
     			     (debug:print 0 *default-log-port* "NEW:  " newcmdline)
     			     (system newcmdline)))
     			 run-specs))
     	     (handle-run-requests target runname keys keyvals need-clean))))))
     
     ;;======================================================================
     ;; run one test
     ;;======================================================================
     
     ;; 1. find the config file
     ;; 2. change to the test directory
     ;; 3. update the db with "test started" status, set running host
     ;; 4. process launch the test
     ;;    - monitor the process, update stats in the db every 2^n minutes
     ;; 5. as the test proceeds internally it calls megatest as each step is
     ;;    started and completed
     ;;    - step started, timestamp
     ;;    - step completed, exit status, timestamp
     ;; 6. test phone home
     ;;    - if test run time > allowed run time then kill job
     ;;    - if cannot access db > allowed disconnect time then kill job
     
     ;; == duplicated == (if (or (args:get-arg "-run")(args:get-arg "-runtests"))
     ;; == duplicated ==   (general-run-call 
     ;; == duplicated ==    "-runtests" 
     ;; == duplicated ==    "run a test" 
     ;; == duplicated ==    (lambda (target runname keys keyvals)
     ;; == duplicated ==      ;;
     ;; == duplicated ==      ;; May or may not implement it this way ...
     ;; == duplicated ==      ;;
     ;; == duplicated ==      ;; Insert this run into the tasks queue
     ;; == duplicated ==      ;; (open-run-close tasks:add tasks:open-db 
     ;; == duplicated ==      ;;    	     "runtests" 
     ;; == duplicated ==      ;;    	     user
     ;; == duplicated ==      ;;    	     target
     ;; == duplicated ==      ;;    	     runname
     ;; == duplicated ==      ;;    	     (args:get-arg "-runtests")
     ;; == duplicated ==      ;;    	     #f))))
     ;; == duplicated ==      (runs:run-tests target
     ;; == duplicated == 		     runname
     ;; == duplicated == 		     (common:args-get-testpatt #f) ;; (args:get-arg "-runtests")
     ;; == duplicated == 		     user
     ;; == duplicated == 		     args:arg-hash))))
     
     ;;======================================================================
     ;; Rollup into a run
     ;;======================================================================
     
     ;; (if (args:get-arg "-rollup")
     ;;     (general-run-call 
     ;;      "-rollup" 
     ;;      "rollup tests" 
     ;;      (lambda (target runname keys keyvals)
     ;;        (runs:rollup-run keys
     ;; 			keyvals
     ;; 			(or (args:get-arg "-runname")(args:get-arg ":runname") )
     ;; 			user))))
     
     ;;======================================================================
     ;; Lock or unlock a run
     ;;======================================================================
     
     (if (or (args:get-arg "-lock")(args:get-arg "-unlock"))
         (general-run-call 
          (if (args:get-arg "-lock") "-lock" "-unlock")
          "lock/unlock tests" 
          (lambda (target runname keys keyvals)
            (runs:handle-locking 
     		  target
     		  keys
     		  (or (args:get-arg "-runname")(args:get-arg ":runname") )
     		  (args:get-arg "-lock")
     		  (args:get-arg "-unlock")
     		  (bdat-user *bdat*)))))
     
     ;;======================================================================
     ;; Get paths to tests
     ;;======================================================================
     ;; Get test paths matching target, runname, and testpatt
     (if (or (args:get-arg "-test-files")(args:get-arg "-test-paths"))
         ;; if we are in a test use the MT_CMDINFO data
         (if (get-environment-variable "MT_CMDINFO")
     	(let* ((startingdir (current-directory))
     	       (cmdinfo   (common:read-encoded-string (get-environment-variable "MT_CMDINFO")))
     	       (transport (assoc/default 'transport cmdinfo))
     	       (testpath  (assoc/default 'testpath  cmdinfo))
     	       (test-name (assoc/default 'test-name cmdinfo))
     	       (runscript (assoc/default 'runscript cmdinfo))
     	       (db-host   (assoc/default 'db-host   cmdinfo))
     	       (run-id    (assoc/default 'run-id    cmdinfo))
     	       (itemdat   (assoc/default 'itemdat   cmdinfo))
     	       (state     (args:get-arg ":state"))
     	       (status    (args:get-arg ":status"))
     	       ;;(target    (args:get-arg "-target"))
     	       (target    (common:args-get-target))
     	       (toppath   (assoc/default 'toppath   cmdinfo)))
     	  (change-directory toppath)
     	  (if (not target)
     	      (begin
     		(debug:print-error 0 *default-log-port* "-target is required.")
     		(exit 1)))
     	  (if (not (launch:setup))
     	      (begin
     		(debug:print 0 *default-log-port* "Failed to setup, giving up on -test-paths or -test-files, exiting")
     		(exit 1)))
     	  (let* ((keys     (rmt:get-keys))
     		 ;; db:test-get-paths must not be run remote
     		 (paths    (tests:test-get-paths-matching keys target (args:get-arg "-test-files"))))
     	    (set! *didsomething* #t)
     	    (for-each (lambda (path)
     			(if (common:file-exists? path)
     			(print path)))	
     		      paths)))
     	;; else do a general-run-call
     	(general-run-call 
     	 "-test-files"
     	 "Get paths to test"
     	 (lambda (target runname keys keyvals)
     	   (let* ((db       #f)
     		  ;; DO NOT run remote
     		  (paths    (tests:test-get-paths-matching keys target (args:get-arg "-test-files"))))
     	     (for-each (lambda (path)
     			 (print path))
     		       paths))))))
     
     ;;======================================================================
     ;; Archive tests
     ;;======================================================================
     ;; Archive tests matching target, runname, and testpatt
     (if (equal? (args:get-arg "-archive") "replicate-db")
         (begin
               ;; check if source
               ;; check if megatest.db exist
              (launch:setup)
              (if (not (args:get-arg "-source"))
                  (begin 
                  (debug:print-info 1 *default-log-port* "Missing required argument -source <archive path>")
                  (exit 1)))
              (if (common:file-exists? (conc  *toppath* "/megatest.db"))
                  (begin  
                    (debug:print-info 1 *default-log-port* "File " (conc  *toppath* "/megatest.db") " already exists. Please remove it before trying to replicate db")
                    (exit 1)))
              (if (and (common:get-db-tmp-area) (> (length (directory   (common:get-db-tmp-area) #f)) 0))
                (begin
                (debug:print-info 1 *default-log-port* (common:get-db-tmp-area) " not empty. Please remove it before trying to replicate db")
                (exit 1)))    
               ;; check if timestamp 
               (let* ((source (args:get-arg "-source"))
                     (src     (if (not (equal? (substring source 0 1) "/"))
                                  (conc (current-directory) "/" source)
                                  source))
                     (ts (if (args:get-arg "-time-stamp")   (args:get-arg "-time-stamp") "latest")))
                   (if  (common:directory-exists? src)
                       (begin 
                       (archive:restore-db src ts)
                 (set! *didsomething* #t))
            (begin
              (debug:print-error 1 *default-log-port* "Path " source " not found")
              (exit 1))))))   
         ;; else do a general-run-call
        (if (and (args:get-arg "-archive") (not (equal? (args:get-arg "-archive") "replicate-db"))) 
         (begin
           ;; for the archive get we need to preserve the starting dir as part of the target path
           (if (and (args:get-arg "-dest")
     	       (not (equal? (substring (args:get-arg "-dest") 0 1) "/")))
     	  (let ((newpath  (conc (current-directory) "/" (args:get-arg "-dest"))))
     	    (debug:print-info 1 *default-log-port* "Preserving original path to destination, was " (args:get-arg "-dest") ", now " newpath)
     	    (hash-table-set! args:arg-hash "-dest" newpath)))
           (general-run-call 
            "-archive"
            "Archive"
            (lambda (target runname keys keyvals)
     	 (operate-on 'archive target-in: target runname-in: runname )))))
     
     ;;======================================================================
     ;; Extract a spreadsheet from the runs database
     ;;======================================================================

;; TODO: Reenable this functionality

     #;(if (args:get-arg "-extract-ods")
         (general-run-call
          "-extract-ods"
          "Make ods spreadsheet"
          (lambda (target runname keys keyvals)
            (let ((dbstruct   (make-dbr:dbstruct path: *toppath* local: #t))
     	     (outputfile (args:get-arg "-extract-ods"))
     	     (runspatt   (or (args:get-arg "-runname")(args:get-arg ":runname")))
     	     (pathmod    (args:get-arg "-pathmod")))
     	     ;; (keyvalalist (keys->alist keys "%")))
     	 (debug:print 2 *default-log-port* "Extract ods, outputfile: " outputfile " runspatt: " runspatt " keyvals: " keyvals)
     	 (db:extract-ods-file dbstruct outputfile keyvals (if runspatt runspatt "%") pathmod)
     	 (db:close-all dbstruct)
     	 (set! *didsomething* #t)))))
     
     ;;======================================================================
     ;; execute the test
     ;;    - gets called on remote host
     ;;    - receives info from the -execute param
     ;;    - passes info to steps via MT_CMDINFO env var (future is to use a dot file)
     ;;    - gathers host info and 
     ;;======================================================================
     
     (if (args:get-arg "-execute")
         (begin
           (launch:execute (args:get-arg "-execute"))
           (set! *didsomething* #t)))
     
     ;;======================================================================
     ;; recover from a test where the managing mtest was killed but the underlying
     ;; process might still be salvageable
     ;;======================================================================
     
     (if (args:get-arg "-recover-test")
         (let* ((params (string-split (args:get-arg "-recover-test") ",")))
           (if (> (length params) 1) ;; run-id and test-id
     	  (let ((run-id (string->number (car params)))
     		(test-id (string->number (cadr params))))
     	    (if (and run-id test-id)
     		(begin
     		  (launch:recover-test run-id test-id)
     		  (set! *didsomething* #t))
     		(begin
     		  (debug:print-error 0 *default-log-port* "bad run-id or test-id, must be integers")
     		  (exit 1)))))))
     
  (if (args:get-arg "-step")
      (begin
           (thread-sleep! 1.5)
           (megatest:step 
            (args:get-arg "-step")
            (or (args:get-arg "-state")(args:get-arg ":state"))
            (or (args:get-arg "-status")(args:get-arg ":status"))
            (args:get-arg "-setlog")
            (args:get-arg "-m"))
           ;; (if db (sqlite3:finalize! db))
           (set! *didsomething* #t)
           (thread-sleep! 1.5)))
         
     (if (or (args:get-arg "-setlog")       ;; since setting up is so costly lets piggyback on -test-status
     	;;     (not (args:get-arg "-step")))  ;; -setlog may have been processed already in the "-step" previous
     	;;     NEW POLICY - -setlog sets test overall log on every call.
     	(args:get-arg "-set-toplog")
     	(args:get-arg "-test-status")
     	(args:get-arg "-set-values")
     	(args:get-arg "-load-test-data")
     	(args:get-arg "-runstep")
     	(args:get-arg "-summarize-items"))
         (if (not (get-environment-variable "MT_CMDINFO"))
     	(begin
     	  (debug:print-error 0 *default-log-port* "MT_CMDINFO env var not set, commands -test-status, -runstep and -setlog must be called *inside* a megatest environment!")
     	  (exit 5))
     	(let* ((startingdir (current-directory))
     	       (cmdinfo   (common:read-encoded-string (get-environment-variable "MT_CMDINFO")))
     	       (transport (assoc/default 'transport cmdinfo))
     	       (testpath  (assoc/default 'testpath  cmdinfo))
     	       (test-name (assoc/default 'test-name cmdinfo))
     	       (runscript (assoc/default 'runscript cmdinfo))
     	       (db-host   (assoc/default 'db-host   cmdinfo))
     	       (run-id    (assoc/default 'run-id    cmdinfo))
     	       (test-id   (assoc/default 'test-id   cmdinfo))
     	       (itemdat   (assoc/default 'itemdat   cmdinfo))
     	       (work-area (assoc/default 'work-area cmdinfo))
     	       (db        #f) ;; (open-db))
     	       (state     (args:get-arg ":state"))
     	       (status    (args:get-arg ":status"))
     	       (stepname  (args:get-arg "-step")))
     	  (if (not (launch:setup))
     	      (begin
     		(debug:print 0 *default-log-port* "Failed to setup, exiting")
     		(exit 1)))
     
     	  (if (args:get-arg "-runstep")(debug:print-info 1 *default-log-port* "Running -runstep, first change to directory " work-area))
     	  (change-directory work-area)
     	  ;; can setup as client for server mode now
     	  ;; (client:setup)
     
     	  (if (args:get-arg "-load-test-data")
     	      ;; has sub commands that are rdb:
     	      ;; DO NOT put this one into either rmt: or open-run-close
     	      (tdb:load-test-data run-id test-id))
     	  (if (args:get-arg "-setlog")
     	      (let ((logfname (args:get-arg "-setlog")))
     		(rmt:test-set-log! run-id test-id logfname)))
     	  (if (args:get-arg "-set-toplog")
     	      ;; DO NOT run remote
     	      (tests:test-set-toplog! run-id test-name (args:get-arg "-set-toplog")))
     	  (if (args:get-arg "-summarize-items")
     	      ;; DO NOT run remote
     	      (tests:summarize-items run-id test-id test-name #t)) ;; do force here
     	  (if (args:get-arg "-runstep")
     	      (if (null? remargs)
     		  (begin
     		    (debug:print-error 0 *default-log-port* "nothing specified to run!")
     		    (if db (sqlite3:finalize! db))
     		    (exit 6))
     		  (let* ((stepname   (args:get-arg "-runstep"))
     			 (logprofile (args:get-arg "-logpro"))
     			 (logfile    (conc stepname ".log"))
     			 (cmd        (if (null? remargs) #f (car remargs)))
     			 (params     (if cmd (cdr remargs) '()))
     			 (exitstat   #f)
     			 (shell      (let ((sh (get-environment-variable "SHELL") ))
     				       (if sh 
     					   (last (string-split sh "/"))
     					   "bash")))
     			 (redir      (case (string->symbol shell)
     				       ((tcsh csh ksh)    ">&")
     				       ((zsh bash sh ash) "2>&1 >")
     				       (else ">&")))
     			 (fullcmd    (conc "(" (string-intersperse 
     						(cons cmd params) " ")
     					   ") " redir " " logfile)))
     		    ;; mark the start of the test
     		    (rmt:teststep-set-status! run-id test-id stepname "start" "n/a" (args:get-arg "-m") logfile)
     		    ;; run the test step
     		    (debug:print-info 2 *default-log-port* "Running \"" fullcmd "\" in directory \"" startingdir)
     		    (change-directory startingdir)
     		    (set! exitstat (system fullcmd))
     		    (set! *globalexitstatus* exitstat)
     		    ;; (change-directory testpath)
     		    ;; run logpro if applicable ;; (process-run "ls" (list "/foo" "2>&1" "blah.log"))
     		    (if logprofile
     			(let* ((htmllogfile (conc stepname ".html"))
     			       (oldexitstat exitstat)
     			       (cmd         (string-intersperse (list "logpro" logprofile htmllogfile "<" logfile ">" (conc stepname "_logpro.log")) " ")))
     			  (debug:print-info 2 *default-log-port* "running \"" cmd "\"")
     			  (change-directory startingdir)
     			  (set! exitstat (system cmd))
     			  (set! *globalexitstatus* exitstat) ;; no necessary
     			  (change-directory testpath)
     			  (rmt:test-set-log! run-id test-id htmllogfile)))
     		    (let ((msg (args:get-arg "-m")))
     		      (rmt:teststep-set-status! run-id test-id stepname "end" exitstat msg logfile))
     		    )))
     	  (if (or (args:get-arg "-test-status")
     		  (args:get-arg "-set-values"))
     	      (let ((newstatus (cond
     				((number? status)       (if (equal? status 0) "PASS" "FAIL"))
     				((and (string? status)
     				      (string->number status))(if (equal? (string->number status) 0) "PASS" "FAIL"))
     				(else status)))
     		    ;; transfer relevant keys into a hash to be passed to test-set-status!
     		    ;; could use an assoc list I guess. 
     		    (otherdata (let ((res (make-hash-table)))
     				 (for-each (lambda (key)
     					     (if (args:get-arg key)
     						 (hash-table-set! res key (args:get-arg key))))
     					   (list ":value" ":tol" ":expected" ":first_err" ":first_warn" ":units" ":category" ":variable"))
     				 res)))
     		(if (and (args:get-arg "-test-status")
     			 (or (not state)
     			     (not status)))
     		    (begin
     		      (debug:print-error 0 *default-log-port* "You must specify :state and :status with every call to -test-status\n" help)
     		      (if (sqlite3:database? db)(sqlite3:finalize! db))
     		      (exit 6)))
     		(let* ((msg    (args:get-arg "-m"))
     		       (numoth (length (hash-table-keys otherdata))))
     		  ;; Convert to rpc inside the tests:test-set-status! call, not here
     		  (tests:test-set-status! run-id test-id state newstatus msg otherdata work-area: work-area))))
     	  (if (sqlite3:database? db)(sqlite3:finalize! db))
     	  (set! *didsomething* #t))))
     
     ;;======================================================================
     ;; Various helper commands can go below here
     ;;======================================================================
     
     (if (or (args:get-arg "-showkeys")
             (args:get-arg "-show-keys"))
         (let ((db #f)
     	  (keys #f))
           (if (not (launch:setup))
     	  (begin
     	    (debug:print 0 *default-log-port* "Failed to setup, exiting")
     	    (exit 1)))
           (set! keys (rmt:get-keys)) ;;  db))
           (debug:print 1 *default-log-port* "Keys: " (string-intersperse keys ", "))
           (if (sqlite3:database? db)(sqlite3:finalize! db))
           (set! *didsomething* #t)))
     
     (if (args:get-arg "-gui")
         (begin
           (debug:print 0 *default-log-port* "Look at the dashboard for now")
           ;; (megatest-gui)
           (set! *didsomething* #t)))
     
     (if (args:get-arg "-create-megatest-area")
         (begin
           (genexample:mk-megatest.config)
           (set! *didsomething* #t)))
     
     (if (args:get-arg "-create-test")
         (let ((testname (args:get-arg "-create-test")))
           (genexample:mk-megatest-test testname)
           (set! *didsomething* #t)))
     
     ;;======================================================================
     ;; Update the database schema, clean up the db
     ;;======================================================================

;; TODO: Restore this functionality

      #;(if (args:get-arg "-rebuild-db")
         (begin
           (if (not (launch:setup))
     	  (begin
     	    (debug:print 0 *default-log-port* "Failed to setup, exiting") 
     	    (exit 1)))
           ;; keep this one local
           ;; (open-run-close patch-db #f)
           (let ((dbstruct (db:setup #f areapath: *toppath*)))
             (common:cleanup-db dbstruct full: #t))
           (set! *didsomething* #t)))
     
     #;(if (args:get-arg "-cleanup-db")
         (begin
           (if (not (launch:setup))
     	  (begin
     	    (debug:print 0 *default-log-port* "Failed to setup, exiting") 
     	    (exit 1)))
           (let ((dbstruct (db:setup #f areapath: *toppath*)))
             (common:cleanup-db dbstruct))
           (set! *didsomething* #t)))
     
     (if (args:get-arg "-mark-incompletes")
         (begin
           (if (not (launch:setup))
     	  (begin
     	    (debug:print 0 *default-log-port* "Failed to setup, exiting")
     	    (exit 1)))
           (runs:find-and-mark-incomplete-and-check-end-of-run #f)
           (set! *didsomething* #t)))
     
     ;;======================================================================
     ;; Update the tests meta data from the testconfig files
     ;;======================================================================
     
     (if (args:get-arg "-update-meta")
         (begin
           (if (not (launch:setup))
     	  (begin
     	    (debug:print 0 *default-log-port* "Failed to setup, exiting") 
     	    (exit 1)))
           (runs:update-all-test_meta #f)
           (set! *didsomething* #t)))
     
     ;;======================================================================
     ;; Start a repl
     ;;======================================================================
     
     ;; fakeout readline
     ;; (include "readline-fix.scm")
     
     
     (when (args:get-arg "-diff-rep")
       (when (and
              (not (args:get-arg "-diff-html"))
              (not (args:get-arg "-diff-email")))
         (debug:print 0 *default-log-port* "Must specify -diff-html or -diff-email with -diff-rep")
         (set! *didsomething* 1)
         (exit 1))
       
       (let* ((toppath (launch:setup)))
         (do-diff-report
          (args:get-arg "-src-target")
          (args:get-arg "-src-runname")
          (args:get-arg "-target")
          (args:get-arg "-runname")
          (args:get-arg "-diff-html")
          (args:get-arg "-diff-email"))
         (set! *didsomething* #t)
         (exit 0)))
     
     (if (or (get-environment-variable "MT_RUNSCRIPT")
     	(args:get-arg "-repl")
     	(args:get-arg "-load"))
         (let* ((toppath (launch:setup)))
		
     	        ;; (dbstruct (if (and toppath
		;; 	      #;(common:on-homehost?))
		;; 	 (db:setup #f) ;; sets up main.db
		;; 	 #f))) ;; make-dbr:dbstruct path: toppath local: (args:get-arg "-local")) #f)))
	   (if *toppath*
	       (cond
		((get-environment-variable "MT_RUNSCRIPT")
		 ;; How to run megatest scripts
		 ;;
		 ;; #!/bin/bash
		 ;;
		 ;; export MT_RUNSCRIPT=yes
		 ;; megatest << EOF
		 ;; (print "Hello world")
		 ;; (exit)
		 ;; EOF
		 
		 (repl))
		(else
		 (begin
		   ;; (set! *db* dbstruct)
		   ;; (import extras) ;; might not be needed
		   ;; (import chicken.csi)
		   ;; (import readline)
		   #;(import apropos
			   archivemod
			   commonmod
			   configfmod
			   dbmod
			   debugprint
			   ezstepsmod
			   launchmod
			   processmod
			   rmtmod
			   runsmod
			   servermod
			   tasksmod
			   testsmod)
		   
		   (set-history-length! 300)
		   (load-history-from-file ".megatest_history")
		   (current-input-port (make-linenoise-port))
		   ;; (import (prefix sqlite3 sqlite3:)) ;; doesn't work ...
		   
		   ;; (if *use-new-readline*
		   ;; 	  (begin
		   ;; 	    (install-history-file (get-environment-variable "HOME") ".megatest_history") ;;  [homedir] [filename] [nlines])
		   ;; 	    (current-input-port (make-readline-port "megatest> ")))
		   ;; 	  (begin
		   ;; 	    (gnu-history-install-file-manager
		   ;; 	     (string-append
		   ;; 	      (or (get-environment-variable "HOME") ".") "/.megatest_history"))
		   ;; 	    (current-input-port (make-gnu-readline-port "megatest> "))))
		   (if (args:get-arg "-repl")
		       (repl)
		       (load (args:get-arg "-load")))
		   ;; (db:close-all dbstruct) <= taken care of by on-exit call
		   )
		 (exit)))
	       (set! *didsomething* #t))))
     
     ;;======================================================================
     ;; Wait on a run to complete
     ;;======================================================================
     
     (if (and (args:get-arg "-run-wait")
     	 (not (or (args:get-arg "-run")
     		  (args:get-arg "-runtests")))) ;; run-wait is built into runtests now
         (begin
           (if (not (launch:setup))
     	  (begin
     	    (debug:print 0 *default-log-port* "Failed to setup, exiting") 
     	    (exit 1)))
           (operate-on 'run-wait)
           (set! *didsomething* #t)))
     
     ;; ;; ;; redo me ;; Not converted to use dbstruct yet
     ;; ;; ;; redo me ;;
     ;; ;; ;; redo me (if (args:get-arg "-convert-to-norm")
     ;; ;; ;; redo me     (let* ((toppath (setup-for-run))
     ;; ;; ;; redo me 	   (dbstruct (if toppath (make-dbr:dbstruct path: toppath local: #t))))
     ;; ;; ;; redo me       (for-each 
     ;; ;; ;; redo me        (lambda (field)
     ;; ;; ;; redo me 	 (let ((dat '()))
     ;; ;; ;; redo me 	   (debug:print-info 0 *default-log-port* "Getting data for field " field)
     ;; ;; ;; redo me 	   (sqlite3:for-each-row
     ;; ;; ;; redo me 	    (lambda (id val)
     ;; ;; ;; redo me 	      (set! dat (cons (list id val) dat)))
     ;; ;; ;; redo me 	    (db:get-db db run-id)
     ;; ;; ;; redo me 	    (conc "SELECT id," field " FROM tests;"))
     ;; ;; ;; redo me 	   (debug:print-info 0 *default-log-port* "found " (length dat) " items for field " field)
     ;; ;; ;; redo me 	   (let ((qry (sqlite3:prepare db (conc "UPDATE tests SET " field "=? WHERE id=?;"))))
     ;; ;; ;; redo me 	     (for-each
     ;; ;; ;; redo me 	      (lambda (item)
     ;; ;; ;; redo me 		(let ((newval ;; (sdb:qry 'getid 
     ;; ;; ;; redo me 		       (cadr item))) ;; )
     ;; ;; ;; redo me 		  (if (not (equal? newval (cadr item)))
     ;; ;; ;; redo me 		      (debug:print-info 0 *default-log-port* "Converting " (cadr item) " to " newval " for test #" (car item)))
     ;; ;; ;; redo me 		  (sqlite3:execute qry newval (car item))))
     ;; ;; ;; redo me 	      dat)
     ;; ;; ;; redo me 	     (sqlite3:finalize! qry))))
     ;; ;; ;; redo me        (db:close-all dbstruct)
     ;; ;; ;; redo me        (list "uname" "rundir" "final_logf" "comment"))
     ;; ;; ;; redo me       (set! *didsomething* #t)))

;; TODO: restore this functionality

     #;(if (args:get-arg "-import-megatest.db")
         (begin
           (db:multi-db-sync 
            (db:setup #f)
            'killservers
            'dejunk
            'adj-testids
            'old2new
            ;; 'new2old
            )
           (set! *didsomething* #t)))
     
     #;(when (args:get-arg "-sync-brute-force")
       ((server:get-bruteforce-syncer (db:setup #t) persist-until-sync: #t))
       (set! *didsomething* #t))
     
     #;(if (args:get-arg "-sync-to-megatest.db")
         (let* ((dbstruct (db:setup #f))
     	   (tmpdbpth (cdr (dbr:dbstruct-tmpdb dbstruct)))
     	   (lockfile (conc tmpdbpth ".lock"))
     	   (locked   (common:simple-file-lock lockfile)) 
     	   (res      (if locked
     			 (db:multi-db-sync 
     			  dbstruct
     			  'new2old)
     			 #f)))
           (if res
     	  (begin
     	    (common:simple-file-release-lock lockfile)
     	    (print "Synced " res " records to megatest.db"))
     	  (print "Skipping sync, there is a sync in progress."))
           (set! *didsomething* #t)))
     
     (if (args:get-arg "-sync-to")
         (let ((toppath (launch:setup)))
           (tasks:sync-to-postgres *configdat* (args:get-arg "-sync-to"))
           (set! *didsomething* #t)))
     
     (if (args:get-arg "-list-test-time")
          (let* ((toppath (launch:setup))) 
          (task:get-test-times)  
          (set! *didsomething* #t)))
     
     (if (args:get-arg "-list-run-time")
          (let* ((toppath (launch:setup))) 
          (task:get-run-times)  
          (set! *didsomething* #t)))
          
     (if (args:get-arg "-generate-html")
         (let* ((toppath (launch:setup)))
           (if (tests:create-html-tree #f)
               (debug:print-info 0 *default-log-port* "HTML output created in " toppath "/lt/page0.html")
               (debug:print 0 *default-log-port* "Failed to create HTML output in " toppath "/lt/runs-index.html"))
           (set! *didsomething* #t)))
     
     (if (args:get-arg "-generate-html-structure")
         (let* ((toppath (launch:setup)))
           ;(if (tests:create-html-tree #f)
      				(if (tests:create-html-summary #f)
               (debug:print-info 0 *default-log-port* "HTML output created in " toppath "/lt/targets.html")
               (debug:print 0 *default-log-port* "Failed to create HTML output in " toppath "/lt/runs-index.html"))
           (set! *didsomething* #t)))
     
     (if (args:get-arg "-syscheck")
         (begin
           (mutils:syscheck common:raw-get-remote-host-load
     		       server:get-best-guess-address
     		       configf:read-config)
           (set! *didsomething* #t)))
     
     (if (args:get-arg "-extract-skeleton")
         (let* ((toppath (launch:setup)))
           (genexample:extract-skeleton-area (args:get-arg "-extract-skeleton"))
           (set! *didsomething* #t)))
     
     ;;======================================================================
     ;; Exit and clean up
     ;;======================================================================
     
     (if (not *didsomething*)
         (debug:print 0 *default-log-port* help)
         (bdat-time-to-exit-set! *bdat* #t)
         )
     ;;(debug:print-info 13 *default-log-port* "thread-join! watchdog")
     
     ;; join the watchdog thread if it has been thread-start!ed  (it may not have been started in the case of a server that never enters running state)
     ;;   (symbols returned by thread-state: created ready running blocked suspended sleeping terminated dead)
     ;; TODO: for multiple areas, we will have multiple watchdogs; and multiple threads to manage
     #;(let* ((watchdog (bdat-watchdog *bdat*)))
       (if (thread? watchdog)
	   (case (thread-state watchdog)
	     ((ready running blocked sleeping terminated dead)
	      (thread-join! watchdog)))))
     
     (bdat-time-to-exit-set! *bdat* #t)
     
     (if (not (eq? *globalexitstatus* 0))
         (if (or (args:get-arg "-run")(args:get-arg "-runtests")(args:get-arg "-runall"))
             (begin
	       (debug:print 0 *default-log-port* "NOTE: Subprocesses with non-zero exit code detected: " *globalexitstatus*)
	       (exit 0))
             (case *globalexitstatus*
	       ((0)(exit 0))
	       ((1)(exit 1))
	       ((2)(exit 2))
	       (else (exit 3)))))
     )

;; (import megatest-main commonmod)
;; (import srfi-18)

(thread-join!
 (thread-start!
  (make-thread main)))

)