Megatest

  ;; (tests:test-set-status! test-id "RUNNING" "n/a" #f #f)
  ;; Since we should have a clean slate at this time there is no need to do 
  ;; any of the other stuff that tests:test-set-status! does. Let's just 
  ;; force RUNNING/n/a

  ;; (thread-sleep! 0.3)
  ;; (tests:test-force-state-status! run-id test-id "RUNNING" "n/a")
  (common:soft-lock
   (lambda ()
     (rmt:set-state-status-and-roll-up-items run-id test-name item-path "RUNNING" #f #f))
    "set-state-status-roll-up")
  ;; (thread-sleep! 0.3) ;; NFS slowness has caused grief here

  ;; if there is a runscript do it first
  (if fullrunscript
      (let ((pid (process-run fullrunscript)))
	(rmt:test-set-top-process-pid run-id test-id pid)
	(let loop ((i 0))

            #t)
           (else #f))))
    (when do-scan?
      (debug:print 1 *default-log-port* "INFO: search and mark zombie tests")
      (rmt:set-var key (current-seconds))
      (rmt:find-and-mark-incomplete run-id #f))))

;; weak locking - slow down concurrent activities but don't entirely stop them from
;; overlapping. wait for up to 5 seconds
;;
(define (common:soft-lock proc keyname #!key (wait-time 5))
  (let* ((start-time (current-seconds))
	 (my-key     (conc (current-process-id) "-" (get-host-name))))
    (let loop ((key-val (rmt:no-sync-get/default keyname #f)))
      (if (and key-val
	       (not (equal? key-val my-key))
	       (< (- (current-seconds) start-time) wait-time))
	  (begin
	    (thread-sleep! 0.5)
	    (debug:print-info 0 *default-log-port* "Still trying to lock for " keyname)
	    (loop (current-seconds))) ;; try again
	  (begin ;; either we got the lock or we timed out - proceed as if 
	    (rmt:no-sync-set keyname my-key)
	    (if (equal? (rmt:no-sync-get/default keyname #f) my-key)
		(begin
		  (debug:print-info 0 *default-log-port* "Got lock for " keyname)
		  (proc)
		  (rmt:no-sync-del! keyname)
		  (debug:print-info 0 *default-log-port* "Released lock for " keyname))
		(common:soft-lock proc keyname wait-time: wait-time)))))))

;; 1. look though disks list for disk with most space
;; 2. create run dir on disk, path name is meaningful
;; 3. create link from run dir to megatest runs area 
;; 4. remotely run the test on allocated host
;;    - could be ssh to host from hosts table (update regularly with load)
;;    - could be netbatch

	    (debug:print-info 0 *default-log-port* "attempting to preclean directory " (db:test-get-rundir testinfo) " for test " test-name "/" item-path)
	    (runs:remove-test-directory testinfo 'remove-data-only))) ;; remove data only, do not perturb the record
      
      ;; prevent overlapping actions - set to LAUNCHED as early as possible
      ;;
      ;; the following call handles waiver propogation. cannot yet condense into roll-up-pass-fail
      (tests:test-set-status! run-id test-id "LAUNCHED" "n/a" #f #f) ;; (if launch-results launch-results "FAILED"))
      (common:soft-lock
       (lambda ()
	 (rmt:set-state-status-and-roll-up-items run-id test-name item-path #f "LAUNCHED" #f))
       "set-state-status-roll-up")
      ;; (pp (hash-table->alist tconfig))
      (set! diskpath (get-best-disk *configdat* tconfig))
      (if diskpath
	  (let ((dat  (create-work-area run-id run-info keyvals test-id test-path diskpath test-name itemdat)))
	    (set! work-area (car dat))
	    (set! toptest-work-area (cadr dat))
	    (debug:print-info 2 *default-log-port* "Using work area " work-area))