Megatest

			(tasks:server-set-state! (db:delay-if-busy tdbdat) server-id "dbprep")
                        ;;(BB> "http-transport: ->dbprep")
			(thread-sleep! 0.5) ;; give some margin for queries to complete before switching from file based access to server based access
			(set! *dbstruct-db*  (db:setup)) ;;  run-id))
			(set! server-going #t)
			(tasks:server-set-state! (db:delay-if-busy tdbdat) server-id "running")
                        ;;(BB> "http-transport: ->running")
			(server:write-dotserver *toppath* iface port (current-process-id) 'http)
			(server:write-dotserver *toppath* iface port (current-process-id) 'http) ;; create file .server
                        (thread-start! *watchdog*)
                        (server:complete-attempt *toppath*))
                        (server:complete-attempt *toppath*)) ;; delete file .starting-server
		      (begin ;; gotta exit nicely
                        ;;(BB> "http-transport: ->collision")
			(tasks:server-set-state! (db:delay-if-busy tdbdat) server-id "collision")
			(http-transport:server-shutdown server-id port))))))
      
      ;; when things go wrong we don't want to be doing the various queries too often
      ;; so we strive to run this stuff only every four seconds or so.

	   (lambda ()
	     (read-line)))
	 #f))))

(define (server:read-dotserver->server-url areapath)
  (let* ((temp (server:read-dotserver areapath))
         (tokens (if temp (string-split temp ":") '())))
    (if (eq? 3 (length tokens))
    (if (eq? 4 (length tokens))
        (string-join (list-ref tokens 0) ":" (list-ref tokens 1))
        #f)))

(define (server:read-dotserver->pid areapath)
  (let* ((temp (server:read-dotserver areapath))
         (tokens (if temp (string-split temp ":") '())))
    (if (eq? 3 (length tokens))
    (if (eq? 4 (length tokens))
        (list-ref tokens 2)
        #f)))

(define (server:read-dotserver->transport areapath)
  (let* ((temp (server:read-dotserver areapath))
         (tokens (if temp (string-split temp ":") '())))
    (if (eq? 4 (length tokens))
        (string->symbol (list-ref tokens 3))
        #f)))

(define (server:running-or-starting? areapath) ;; Note: may be unreiable on non-homehost due to NFS lag
  (or (server:read-dotserver areapath) (server:start-attempted? areapath)))

;; write a .server file in *toppath* with hostport
;; return #t on success, #f otherwise
;;
(define (server:write-dotserver areapath hostportpid)
(define (server:write-dotserver areapath host port pid transport)
  (let ((lock-file   (conc areapath "/.server.lock"))
	(server-file (conc areapath "/.server")))
	(server-file (conc areapath "/.server"))
        (payload (conc host ":" port ":" pid ":" transport)))
    (if (common:simple-file-lock lock-file)
	(let ((res (handle-exceptions
		    exn
		    #f ;; failed for some reason, for the moment simply return #f
		    (with-output-to-file server-file
		      (lambda ()
			(print hostportpid)))
			(print payload)))
		    #t)))
	  (debug:print-info 0 *default-log-port* "server file " server-file " for " hostportpid " created")
	  (debug:print-info 0 *default-log-port* "server file " server-file " for " payload " created")
	  (common:simple-file-release-lock lock-file)
	  res)
	#f)))

(define (server:remove-dotserver-file areapath hostport)
  (let ((serverurl   (server:read-dotserver->server-url areapath))
	(server-file (conc areapath "/.server"))

     (conc "SELECT " selstr " FROM servers WHERE state in ('available','running','dbprep') ORDER BY start_time DESC;")
     )
    (vector header res)))

(define (tasks:get-server mdb run-id #!key (retries 10))
  (let ((res  #f)
	(best #f))

    (set! res (vector id interface port pubport transport pid hostname)))

    
    (handle-exceptions
     exn
     (begin
       (print-call-chain (current-error-port))
       (debug:print 0 *default-log-port* "WARNING: tasks:get-server db access error.")
       (debug:print 0 *default-log-port* " message: " ((condition-property-accessor 'exn 'message) exn))
       (debug:print 0 *default-log-port* " for run " run-id)