Index: client.scm
==================================================================
--- client.scm
+++ client.scm
@@ -28,10 +28,17 @@
 
 (declare (uses common))
 (declare (uses db))
 (declare (uses tasks)) ;; tasks are where stuff is maintained about what is running.
 
+(module client
+*
+
+)
+
+(import client)
+
 (include "common_records.scm")
 (include "db_records.scm")
 
 ;; client:get-signature
 (define (client:get-signature)
@@ -44,13 +51,10 @@
 #;(define (client:logout serverdat)
   (let ((ok (and (socket? serverdat)
 		 (cdb:logout serverdat *toppath* (client:get-signature)))))
     ok))
 
-(define (client:setup areapath #!key (remaining-tries 100) (failed-connects 0))
-  (client:setup-http areapath remaining-tries: remaining-tries failed-connects: failed-connects))
-
 ;; Do all the connection work, look up the transport type and set up the
 ;; connection if required.
 ;;
 ;; There are two scenarios. 
 ;;   1. We are a test manager and we received *transport-type* and *runremote* via cmdline
@@ -60,17 +64,27 @@
 ;; client:setup
 ;;
 ;; lookup_server, need to remove *runremote* stuff
 ;;
  
-(define (client:setup-http areapath #!key (remaining-tries 100) (failed-connects 0)(area-dat #f))
+;;(define (http-transport:server-dat-make-url runremote)
+(define (client:get-url runremote)
+  (if (and (remote-iface runremote)
+	   (remote-port  runremote))
+      (conc "http://" 
+	    (remote-iface runremote)
+	    ":"
+	    (remote-port  runremote))
+      #f))
+
+(define (client:setup areapath runremote #!key (remaining-tries 100) (failed-connects 0)(area-dat #f))
   (mutex-lock! *rmt-mutex*)
-  (let ((res (client:setup-http-baby areapath remaining-tries: remaining-tries failed-connects: failed-connects area-dat: area-dat)))
+  (let ((res (client:setup-http areapath runremote remaining-tries: remaining-tries failed-connects: failed-connects area-dat: area-dat)))
     (mutex-unlock! *rmt-mutex*)
     res))
 
-(define (client:setup-http-baby areapath #!key (remaining-tries 100) (failed-connects 0)(area-dat #f))
+(define (client:setup-http areapath runremote #!key (remaining-tries 100) (failed-connects 0))
   (debug:print-info 2 *default-log-port* "client:setup remaining-tries=" remaining-tries)
   (server:start-and-wait areapath)
   (if (<= remaining-tries 0)
       (begin
 	(debug:print-error 0 *default-log-port* "failed to start or connect to server")
@@ -77,48 +91,72 @@
 	(exit 1))
       ;;
       ;; Alternatively here, we can get the list of candidate servers and work our way
       ;; through them searching for a good one.
       ;;
-      (let* ((server-dat (server:choose-server areapath 'best))
-	     (runremote  (or area-dat *runremote*)))
+      (let* ((server-dat (server:choose-server areapath 'best))) ;; list host port start-time server-id pid
+;;	     (runremote  (or area-dat *runremote*)))
 	(if (not server-dat) ;; no server found
-	    (client:setup-http-baby areapath remaining-tries: (- remaining-tries 1))
+	    (begin
+	      (if (< remaining-tries 99)(thread-sleep! 1)) ;; obviously it needs time
+	      (client:setup-http areapath runremote remaining-tries: (- remaining-tries 1)))
 	    (match server-dat
 	      ((host port start-time server-id pid)
 	       (debug:print-info 4 *default-log-port* "client:setup server-dat=" server-dat ", remaining-tries=" remaining-tries)
-	       (if (and (not area-dat)
-			(not *runremote*))
-                   (begin       
-		     (set! *runremote* (make-remote))
-                     (let* ((server-info (remote-server-info *runremote*))) 
+	       (if (not runremote)
+                   (begin
+		     ;; Here we are creating a runremote where there was none or it was clobbered with #f
+		     ;;
+		     (set! runremote (make-remote))
+                     (let* ((server-info (server:check-if-running areapath)))
+		       (remote-server-info-set! runremote server-info)
                        (if server-info
                            (begin
-                             (remote-server-url-set! *runremote* (server:record->url server-info))
-                             (remote-server-id-set! *runremote* (server:record->id server-info)))))))
+                             (remote-server-url-set! runremote (server:record->url server-info))
+                             (remote-server-id-set! runremote (server:record->id server-info)))))))
+	       ;; at this point we have a runremote
 	       (if (and host port server-id)
-		   (let* ((start-res (http-transport:client-connect host port server-id))
-			  (ping-res  (rmt:login-no-auto-client-setup start-res)))
-		     (if (and start-res
-			      ping-res)
-			 (let ((runremote (or area-dat *runremote*))) ;; it might have been generated only a few statements ago
-			   (if runremote
-			       (begin
-				 (remote-conndat-set! runremote start-res) ;; (hash-table-set! runremote run-id start-res)
-				 (debug:print-info 2 *default-log-port* "connected to " (http-transport:server-dat-make-url start-res))
-				 start-res)
-			       (client:setup-http-baby areapath remaining-tries: (- remaining-tries 1))))
+		   (let* ((nada     (client:connect host port server-id runremote))
+			  (ping-res (rmt:login-no-auto-client-setup runremote)))
+		     (if ping-res
+			 (if runremote
+			     (begin
+			       (debug:print-info 2 *default-log-port* "connected to " (client:get-url runremote))
+			       runremote)
+			     (client:setup-http areapath runremote remaining-tries: (- remaining-tries 1)))
 			 (begin    ;; login failed but have a server record, clean out the record and try again
 			   (debug:print-info 0 *default-log-port* "client:setup, login unsuccessful, will attempt to start server ... start-res=" start-res ", server-dat=" server-dat) ;; had runid.  Fixes part of Randy;s ticket 1405717332
-			   (http-transport:close-connections *runremote*)
+			   (http-transport:close-connections runremote)
 			   (thread-sleep! 1)
-			   (client:setup-http-baby areapath remaining-tries: (- remaining-tries 1))
+			   (client:setup-http-baby areapath runremote remaining-tries: (- remaining-tries 1))
 			   )))
 		   (begin    ;; no server registered
 		     ;; (server:kind-run areapath)
 		     (server:start-and-wait areapath)
 		     (debug:print-info 0 *default-log-port* "client:setup, no server registered, remaining-tries=" remaining-tries)
 		     (thread-sleep! 1) ;; (+ 5 (random (- 20 remaining-tries))))  ;; give server a little time to start up, randomize a little to avoid start storms.
-		     (client:setup-http-baby areapath remaining-tries: (- remaining-tries 1)))))
+		     (client:setup-http areapath runremote remaining-tries: (- remaining-tries 1)))))
 	      (else
 	       (debug:print 0 *default-log-port* "ERROR: malformed server-dat="server-dat)))))))
 
+;;
+;; connect - stored in remote-condat
+;;
+;; (define (http-transport:client-connect iface port server-id runremote)
+(define (client:connect iface port server-id runremote-in)
+  (let* ((runremote (or runremote-in
+			(make-runremote))))
+    (debug:print-info 2 *default-log-port* "Connecting to server at "iface":"port", id "server-id)
+    (let* ((api-url      (conc "http://" iface ":" port "/api"))
+	   (api-uri      (uri-reference (conc "http://" iface ":" port "/api")))
+	   (api-req      (make-request method: 'POST uri: api-uri)))
+      ;;	 (server-dat   (vector iface port api-uri api-url api-req (current-seconds) server-id)))
+      (remote-iface-set!   runremote iface)
+      (remote-port-set!    runremote port)
+      (remote-server-id-set! runremote server-id)
+      (remote-connect-time-set! runremote (current-seconds))
+      (remote-last-access-set! runremote (current-seconds))
+      (remote-api-url-set! runremote api-url)
+      (remote-api-uri-set! runremote api-uri)
+      (remote-api-req-set! runremote api-req)
+      runremote)))
+

Index: common.scm
==================================================================
--- common.scm
+++ common.scm
@@ -315,26 +315,34 @@
     (else "FAIL")))
 
 (define (common:logpro-exit-code->test-status exit-code)
   (status-sym->string (common:logpro-exit-code->status-sym exit-code)))
 
+;; 
 (defstruct remote
   (hh-dat            (let ((res (or (server:choose-server *toppath* 'homehost)
 				    (cons #f #f))))
 		       (assert (pair? res)(conc "FATAL: hh-dat should be a pair, got "res))
 		       res))
   (server-url        #f) ;; (server:check-if-running *toppath*) #f))
   (server-id         #f)
-  (server-info       (if *toppath* (server:check-if-running *toppath*) #f))
+  (server-info       #f) ;; (if *toppath* (server:check-if-running *toppath*) #f))
   (last-server-check 0)  ;; last time we checked to see if the server was alive
-  (connect-time      (current-seconds))
-  (conndat           #f)
-  (transport         *transport-type*)
+  (connect-time      (current-seconds)) ;; when we first connected
+  (last-access       (current-seconds)) ;; last time we talked to server
+  (conndat           #f) ;; iface port api-uri api-url api-req seconds server-id
   (server-timeout    (server:expiration-timeout))
   (force-server      #f)
   (ro-mode           #f)  
-  (ro-mode-checked   #f)) ;; flag that indicates we have checked for ro-mode
+  (ro-mode-checked   #f) ;; flag that indicates we have checked for ro-mode
+
+  ;; conndat stuff
+  (iface             #f) ;; TODO: Consolidate this data with server-url and server-info above
+  (port              #f)
+  (api-url           #f)
+  (api-uri           #f)
+  (api-req           #f))
 
 ;; launching and hosts
 (defstruct host
   (reachable    #f)
   (last-update  0)

Index: http-transport.scm
==================================================================
--- http-transport.scm
+++ http-transport.scm
@@ -241,25 +241,17 @@
   (mutex-lock! *http-mutex*)
   (set! *http-requests-in-progress* (+ 1 *http-requests-in-progress*)))
 
 ;; Send "cmd" with json payload "params" to serverdat and receive result
 ;;
-(define (http-transport:client-api-send-receive run-id serverdat cmd params #!key (numretries 3)(area-dat #f))
-  (let* ((fullurl    (if (vector? serverdat)
-			 (http-transport:server-dat-get-api-req serverdat)
-			 (begin
-			   (debug:print 0 *default-log-port* "FATAL ERROR: http-transport:client-api-send-receive called with no server info")
-			   (exit 1))))
+(define (http-transport:client-api-send-receive run-id runremote cmd params #!key (numretries 3))
+  (assert (remote? runremote) "FATAL: http-transport:client-api-send-receive called with serverdat="serverdat)
+  (let* ((fullurl    (remote-api-req runremote))
 	 (res        (vector #f "uninitialized"))
 	 (success    #t)
 	 (sparams    (db:obj->string params transport: 'http))
-	 (runremote  (or area-dat *runremote*))
-         (server-id   (if (vector? serverdat) 
-                           (http-transport:server-dat-get-server-id serverdat)
-                           (begin
-			     (debug:print 0 *default-log-port* "FATAL ERROR: http-transport:client-api-send-receive called with no server info")
-			     (exit 1)))))
+         (server-id  (remote-server-id runremote)))
        (debug:print-info 11 *default-log-port* "cmd=" cmd " fullurl=" fullurl " server-id=" server-id " current time:" (current-seconds)) 
 
        ;; set up the http-client here
        (max-retry-attempts 1)
        ;; consider all requests indempotent
@@ -286,21 +278,12 @@
                                                       (debug:print 0 *default-log-port* "WARNING: failure in with-input-from-request to " fullurl ".")
                                                       (debug:print 0 *default-log-port* " message: " msg ", exn=" exn)
                                                       (debug:print 0 *default-log-port* " cmd: " cmd " params: " params " key:" (or server-id "thekey"))
                                                       (debug:print 0 *default-log-port* " call-chain: " call-chain)))
 						;; what if another thread is communicating ok? Can't happen due to mutex
-						(set! *runremote* #f)
-						(set! runremote #f)
-						;; (if runremote
-						;;    (remote-conndat-set! runremote #f))
-						;; Killing associated server to allow clean retry.")
-						;; (tasks:kill-server-run-id run-id)  ;; better to kill the server in the logic that called this routine?
+						(http-transport:close-connections runremote)
 						(mutex-unlock! *http-mutex*)
-						;; (signal (make-composite-condition
-						;;          (make-property-condition 'commfail 'message "failed to connect to server")))
-						;; "communications failed"
-						;; (close-all-connections!)
 						(close-connection! fullurl)
 						(db:obj->string #f))
 					      (with-input-from-request ;; was dat
 					       fullurl 
 					       (list (cons 'key (or server-id   "thekey"))
@@ -347,69 +330,23 @@
 		       'message "nmsg-transport:client-api-send-receive-raw timed out talking to server")))))))
 
 ;; careful closing of connections stored in *runremote*
 ;;
 (define (http-transport:close-connections runremote)
-  (let* (;; (runremote  (or area-dat *runremote*))
-	 (server-dat (if runremote
-                         (remote-conndat runremote)
-                         #f))) ;; (hash-table-ref/default *runremote* run-id #f)))
-    (if (vector? server-dat)
-	(let ((api-dat (http-transport:server-dat-get-api-uri server-dat)))
-	  (handle-exceptions
+  (if (remote? runremote)
+      (let ((api-dat (remote-api-uri runremote)))
+	(handle-exceptions
 	    exn
-	    (begin
-	      (print-call-chain *default-log-port*)
-	      (debug:print-error 0 *default-log-port* " closing connection failed with error: " ((condition-property-accessor 'exn 'message) exn) ", exn=" exn))
-	    (if (args:any-defined? "-server" "-execute" "-run")
-		(debug:print-info 0 *default-log-port* "Closing connections to "api-dat))
-	    (close-connection! api-dat)
-	    ;; (close-connection! (http-transport:server-dat-make-url server-dat))
-	    (remote-conndat-set! runremote #f)
-	    #t))
-	#f)))
-
-
-(define (make-http-transport:server-dat)(make-vector 6))
-(define (http-transport:server-dat-get-iface         vec)    (vector-ref  vec 0))
-(define (http-transport:server-dat-get-port          vec)    (vector-ref  vec 1))
-(define (http-transport:server-dat-get-api-uri       vec)    (vector-ref  vec 2))
-(define (http-transport:server-dat-get-api-url       vec)    (vector-ref  vec 3))
-(define (http-transport:server-dat-get-api-req       vec)    (vector-ref  vec 4))
-(define (http-transport:server-dat-get-last-access   vec)    (vector-ref  vec 5))
-;(define (http-transport:server-dat-get-socket        vec)    (vector-ref  vec 6))
-(define (http-transport:server-dat-get-server-id     vec)    (vector-ref  vec 6))
-
-(define (http-transport:server-dat-make-url vec)
-  (if (and (http-transport:server-dat-get-iface vec)
-	   (http-transport:server-dat-get-port  vec))
-      (conc "http://" 
-	    (http-transport:server-dat-get-iface vec)
-	    ":"
-	    (http-transport:server-dat-get-port  vec))
+	  (begin
+	    (print-call-chain *default-log-port*)
+	    (debug:print-error 0 *default-log-port* " closing connection failed with error: " ((condition-property-accessor 'exn 'message) exn) ", exn=" exn))
+	  (if (args:any-defined? "-server" "-execute" "-run")
+	      (debug:print-info 0 *default-log-port* "Closing connections to "api-dat))
+	  (close-connection! api-dat)
+	  (remote-conndat-set! runremote #f)
+	  #t))
       #f))
-
-(define (http-transport:server-dat-update-last-access vec)
-  (if (vector? vec)
-      (vector-set! vec 5 (current-seconds))
-      (begin
-	(print-call-chain (current-error-port))
-	(debug:print-error 0 *default-log-port* "call to http-transport:server-dat-update-last-access with non-vector!!"))))
-
-;;
-;; connect
-;;
-(define (http-transport:client-connect iface port server-id)
-  (debug:print-info 2 *default-log-port* "Connecting to server at "iface":"port", id "server-id)
-  (let* ((api-url      (conc "http://" iface ":" port "/api"))
-	 (api-uri      (uri-reference (conc "http://" iface ":" port "/api")))
-	 (api-req      (make-request method: 'POST uri: api-uri))
-	 (server-dat   (vector iface port api-uri api-url api-req (current-seconds) server-id)))
-    server-dat))
-
-
-
 
 ;; run http-transport:keep-running in a parallel thread to monitor that the db is being 
 ;; used and to shutdown after sometime if it is not.
 ;;
 (define (http-transport:keep-running) 

Index: rmt.scm
==================================================================
--- rmt.scm
+++ rmt.scm
@@ -49,11 +49,11 @@
 			(remote-conndat runremote)
 			#f)))
 	  (if cinfo
 	      cinfo
 	      (if (server:check-if-running areapath)
-		  (client:setup areapath)
+		  (client:setup areapath runremote)
 		  #f))))
 
 (define (rmt:on-homehost? runremote)
   (let* ((hh-dat (remote-hh-dat runremote)))
     (if (pair? hh-dat)
@@ -169,13 +169,13 @@
      ;;DOT CASE4 [label="reset\nconnection"];
      ;;DOT MUTEXLOCK -> CASE4 [label="have connection,\nlast_access > expire_time"]; {rank=same "case 4" CASE4}
      ;;DOT CASE4 -> "rmt:send-receive";
      ;; reset the connection if it has been unused too long
      ((and runremote
-           (remote-conndat runremote)
+           ;; (remote-conndat runremote)
 	   (> (current-seconds) ;; if it has been more than server-timeout seconds since last contact, close this connection and start a new on
-	      (+ (http-transport:server-dat-get-last-access (remote-conndat runremote))
+	      (+ (remote-last-access runremote)
 		 (remote-server-timeout runremote))))
       (debug:print-info 0 *default-log-port* "Connection to " (remote-server-url runremote) " expired due to no accesses, forcing new connection.")
       (http-transport:close-connections runremote)
       ;; moving this setting of runremote conndat to #f to inside the http-transport:close-connections
       ;; (remote-conndat-set! runremote #f) ;; invalidate the connection, thus forcing a new connection.
@@ -198,27 +198,27 @@
      ;;DOT MUTEXLOCK -> CASE6 [label="on homehost,\nwrite query,\nhave server,\ncan't reach it"]; {rank=same "case 6" CASE6};
      ;;DOT CASE6 -> "rmt:send-receive";
      ;; on homehost and this is a write, we already have a server, but server has died
 
      ;; reinstate this keep-alive section but inject a time condition into the (add ...
-     
-     #;((and (cdr (remote-hh-dat runremote))           ;; on homehost
-           (not (member cmd api:read-only-queries))  ;; this is a write
-           (remote-server-url runremote)             ;; have a server
-           (not (server:ping (remote-server-url runremote) (remote-server-id runremote))))  ;; server has died. NOTE: this is not a cheap call! Need better approach.
-      (debug:print 0 *default-log-port* "WARNING: server appears to have died, trying to reconnect, case 6")
-      (http-transport:close-connections area-dat: runremote) ;; make sure to clean up
-      (set! *runremote* (make-remote))
-      (let* ((server-info (remote-server-info *runremote*))) 
-            (if server-info
-		(begin
-		  (remote-server-url-set! *runremote* (server:record->url server-info))
-                  (remote-server-id-set! *runremote* (server:record->id server-info)))))
-      (remote-force-server-set! runremote (common:force-server?))
-      (mutex-unlock! *rmt-mutex*)
-      (debug:print-info 12 *default-log-port* "rmt:send-receive, case  6")
-      (rmt:send-receive cmd rid params attemptnum: attemptnum))
+     ;;
+     ;; ((and (cdr (remote-hh-dat runremote))           ;; on homehost
+     ;;       (not (member cmd api:read-only-queries))  ;; this is a write
+     ;;       (remote-server-url runremote)             ;; have a server
+     ;;       (not (server:ping (remote-server-url runremote) (remote-server-id runremote))))  ;; server has died. NOTE: this is not a cheap call! Need better approach.
+     ;;  (debug:print 0 *default-log-port* "WARNING: server appears to have died, trying to reconnect, case 6")
+     ;;  (http-transport:close-connections area-dat: runremote) ;; make sure to clean up
+     ;;  (set! *runremote* (make-remote))
+     ;;  (let* ((server-info (remote-server-info *runremote*))) 
+     ;;        (if server-info
+     ;; 		(begin
+     ;; 		  (remote-server-url-set! *runremote* (server:record->url server-info))
+     ;;              (remote-server-id-set! *runremote* (server:record->id server-info)))))
+     ;;  (remote-force-server-set! runremote (common:force-server?))
+     ;;  (mutex-unlock! *rmt-mutex*)
+     ;;  (debug:print-info 12 *default-log-port* "rmt:send-receive, case  6")
+     ;;  (rmt:send-receive cmd rid params attemptnum: attemptnum))
 
      ;;DOT CASE7 [label="homehost\nwrite"];
      ;;DOT MUTEXLOCK -> CASE7 [label="server not required,\non homehost,\na write,\nhave a server"]; {rank=same "case 7" CASE7};
      ;;DOT CASE7 -> "rmt:open-qry-close-locally";
      ;; on homehost and this is a write, we already have a server
@@ -282,64 +282,39 @@
      ;;DOT CASE11 -> "RESULT" [label="call succeeded"];
      ;; not on homehost, do server query
      (else (extras-case-11 *default-log-port* runremote cmd params attemptnum rid)))))
     ;;DOT }
 
-;; No Title 
-;; Error: (vector-ref) out of range
-;; #(#<condition: (exn type)> (#("db.scm:3740: regex#regexp" #f #f) #("db.scm:3739: regex#string-substitute" #f #f) #("db.scm:3738: base64#base64-decode" #f #f) #("db.scm:3737: z3#z3:decode-buffer" #f #f) #("db.scm:3736: with-input-from-string" #f #f) #("db.scm:3741: s11n#deserialize" #f #f) #("api.scm:374: api:execute-requests" #f #f) #("api.scm:139: call-with-current-continuation" #f #f) #("api.scm:139: with-exception-handler" #f #f) #("api.scm:139: ##sys#call-with-values" #f #f) #("api.scm:158: string->symbol" #f #f) #("api.scm:160: current-milliseconds" #f #f) #("api.scm:161: dbr:dbstruct-read-only" #f #f) #("api.scm:139: k15" #f #f) #("api.scm:139: g19" #f #f) #("api.scm:142: get-call-chain" #f #f)) #("get-test-info-by-id" (1102 507299)))
-;; 6
-;; 
-;; 	Call history:
-;; 
-;; 	http-transport.scm:306: thread-terminate!	  
-;; 	http-transport.scm:307: debug:print-info	  
-;; 	common_records.scm:235: debug:debug-mode	  
-;; 	rmt.scm:259: k587	  
-;; 	rmt.scm:259: g591	  
-;; 	rmt.scm:276: http-transport:server-dat-update-last-access	  
-;; 	http-transport.scm:364: current-seconds	  
-;; 	rmt.scm:282: debug:print-info	  
-;; 	common_records.scm:235: debug:debug-mode	  
-;; 	rmt.scm:283: mutex-unlock!	  
-;; 	rmt.scm:287: extras-transport-succeded	  	<--
-;; +-----------------------------------------------------------------------------+
-;; | Exit Status    : 70  
-;;  
-
 ;; bunch of small functions factored out of send-receive to make debug easier
 ;;
 
 (define (extras-case-11 *default-log-port* runremote cmd params attemptnum rid)
   ;; (mutex-unlock! *rmt-mutex*)
   (debug:print-info 12 *default-log-port* "rmt:send-receive, case  9")
   ;; (mutex-lock! *rmt-mutex*)
   (let* ((conninfo (remote-conndat runremote))
-	 (dat-in      (case (remote-transport runremote)
-		     ((http) (condition-case ;; handling here has
-					     ;; caused a lot of
-					     ;; problems. However it
-					     ;; is needed to deal with
-					     ;; attemtped
-					     ;; communication to
-					     ;; servers that have gone
-					     ;; away
-			      (http-transport:client-api-send-receive 0 conninfo cmd params)
-                              ((servermismatch)  (vector #f "Server id mismatch" ))
-			      ((commfail)(vector #f "communications fail"))
-			      ((exn)(vector #f "other fail" (print-call-chain)))))
-		     (else
-		      (debug:print 0 *default-log-port* "ERROR: transport " (remote-transport runremote) " not supported")
-		      (exit))))
+	 (dat-in  (condition-case ;; handling here has
+			     ;; caused a lot of
+			     ;; problems. However it
+			     ;; is needed to deal with
+			     ;; attemtped
+			     ;; communication to
+			     ;; servers that have gone
+			     ;; away
+			     (http-transport:client-api-send-receive 0 runremote cmd params)
+			     ;; (http-transport:client-api-send-receive 0 conninfo cmd params runremote)
+			     ((servermismatch)  (vector #f "Server id mismatch" ))
+			     ((commfail)(vector #f "communications fail"))
+			     ((exn)(vector #f "other fail" (print-call-chain)))))
 	 (dat      (if (and (vector? dat-in) ;; ... check it is a correct size
 			    (> (vector-length dat-in) 1))
 		       dat-in
 		       (vector #f (conc "communications fail (type 2), dat-in=" dat-in))))
 	 (success  (if (vector? dat) (vector-ref dat 0) #f))
 	 (res      (if (vector? dat) (vector-ref dat 1) #f)))
     (if (and (vector? conninfo) (< 5 (vector-length conninfo)))
-	(http-transport:server-dat-update-last-access conninfo) ;; refresh access time
+	(remote-last-access-set! runremote (current-seconds)) ;; refresh access time
 	(begin
 	  (debug:print 0 *default-log-port* "INFO: Should not get here! conninfo=" conninfo)
 	  (set! conninfo #f)
 	  (http-transport:close-connections runremote)))
     (debug:print-info 13 *default-log-port* "rmt:send-receive, case  9. conninfo=" conninfo " dat=" dat " runremote = " runremote)
@@ -431,18 +406,13 @@
 		(mutex-lock! *db-multi-sync-mutex*)
 /		(set! *db-last-access* start-time)  ;; THIS IS PROBABLY USELESS? (we are on a client)
                 (mutex-unlock! *db-multi-sync-mutex*)))))
     res))
 
-(define (rmt:send-receive-no-auto-client-setup connection-info cmd run-id params)
+(define (rmt:send-receive-no-auto-client-setup runremote cmd run-id params)
   (let* ((run-id   (if run-id run-id 0))
-	 (res  	   ;; (handle-exceptions
-		   ;;     exn
-		   ;;   (begin
-		   ;;     (print "transport failed. exn=" exn)
-		   ;;     #f)
-		     (http-transport:client-api-send-receive run-id connection-info cmd params))) ;; )
+	 (res  	   (http-transport:client-api-send-receive run-id runremote cmd params)))
     (if (and res (vector-ref res 0))
 	(vector-ref res 1) ;;; YES!! THIS IS CORRECT!! CHANGE IT HERE, THEN CHANGE rmt:send-receive ALSO!!!
 	#f)))
 
 ;;======================================================================
@@ -469,15 +439,12 @@
   (rmt:send-receive 'login run-id (list *toppath* megatest-version (client:get-signature))))
 
 ;; This login does no retries under the hood - it acts a bit like a ping.
 ;; Deprecated for nmsg-transport.
 ;;
-(define (rmt:login-no-auto-client-setup connection-info)
-  (case *transport-type* ;; run-id of 0 is just a placeholder
-    ((http)(rmt:send-receive-no-auto-client-setup connection-info 'login 0 (list *toppath* megatest-version (client:get-signature))))
-    ;;((nmsg)(nmsg-transport:client-api-send-receive run-id connection-info 'login (list *toppath* megatest-version run-id *my-client-signature*)))
-    ))
+(define (rmt:login-no-auto-client-setup runremote)
+  (rmt:send-receive-no-auto-client-setup runremote 'login 0 (list *toppath* megatest-version (client:get-signature))))
 
 ;; hand off a call to one of the db:queries statements
 ;; added run-id to make looking up the correct db possible 
 ;;
 (define (rmt:general-call stmtname run-id . params)

Index: server.scm
==================================================================
--- server.scm
+++ server.scm
@@ -664,48 +664,43 @@
 ;; called in megatest.scm, host-port is string hostname:port
 ;;
 ;; NOTE: This is NOT called directly from clients as not all transports support a client running
 ;;       in the same process as the server.
 ;;
-(define (server:ping host-port-in server-id #!key (do-exit #f))
-  (let ((host:port (if (not host-port-in) ;; use read-dotserver to find
-		       #f ;; (server:check-if-running *toppath*)
-		;; (if (number? host-port-in) ;; we were handed a server-id
-		;; 	   (let ((srec (tasks:get-server-by-id (db:delay-if-busy (tasks:open-db)) host-port-in)))
-		;; 	     ;; (print "srec: " srec " host-port-in: " host-port-in)
-		;; 	     (if srec
-		;; 		 (conc (vector-ref srec 3) ":" (vector-ref srec 4))
-		;; 		 (conc "no such server-id " host-port-in)))
-		       host-port-in))) ;; )
-    (let* ((host-port (if host:port
-			  (let ((slst (string-split   host:port ":")))
-			    (if (eq? (length slst) 2)
-				(list (car slst)(string->number (cadr slst)))
-				#f))
-			  #f)))
-;;	   (toppath       (launch:setup)))
-      ;; (print "host-port=" host-port)
-      (if (not host-port)
-	  (begin
-	    (if host-port-in
-		(debug:print 0 *default-log-port*  "ERROR: bad host:port"))
-	    (if do-exit (exit 1))
-	    #f)
-	  (let* ((iface      (car host-port))
-		 (port       (cadr host-port))
-		 (server-dat (http-transport:client-connect iface port server-id))
-		 (login-res  (rmt:login-no-auto-client-setup server-dat)))
-	    (if (and (list? login-res)
-		     (car login-res))
-		(begin
-		  ;; (print "LOGIN_OK")
-		  (if do-exit (exit 0))
-		  #t)
-		(begin
-		  ;; (print "LOGIN_FAILED")
-		  (if do-exit (exit 1))
-		  #f)))))))
+(define (server:ping host:port server-id #!key (do-exit #f))
+  (let* ((host-port (cond
+		     ((string? host:port)
+		      (let ((slst (string-split   host:port ":")))
+			(if (eq? (length slst) 2)
+			    (list (car slst)(string->number (cadr slst)))
+			    #f)))
+		     (else
+		      #f))))
+    (cond
+     ((and (list? host-port)
+	   (eq? (length host-port) 2))
+      (let* ((myrunremote (make-remote))
+	     (iface       (car host-port))
+	     (port        (cadr host-port))
+	     (server-dat  (client:connect iface port server-id myrunremote))
+	     (login-res   (rmt:login-no-auto-client-setup myrunremote)))
+	(if (and (list? login-res)
+		 (car login-res))
+	    (begin
+	      ;; (print "LOGIN_OK")
+	      (if do-exit (exit 0))
+	      #t)
+	    (begin
+	      ;; (print "LOGIN_FAILED")
+	      (if do-exit (exit 1))
+	      #f))))
+     (else 
+      (if host:port
+	  (debug:print 0 *default-log-port*  "ERROR: bad host:port "host:port))
+      (if do-exit
+	  (exit 1)
+	  #f)))))
 
 ;; run ping in separate process, safest way in some cases
 ;;
 (define (server:ping-server ifaceport)
   (with-input-from-pipe