Index: rmt.scm
==================================================================
--- rmt.scm
+++ rmt.scm
@@ -76,11 +76,11 @@
 	(mutex-lock! *send-receive-mutex*)
 	(if (not *runremote*)(set! *runremote* (make-remote)))
 	(let ((ulex:conn (remote-ulex:conn *runremote*)))
 	  (if (not ulex:conn)(remote-ulex:conn-set! *runremote* (rmtmod:setup-ulex *toppath*)))
 	  (rmtmod:send-receive-ulex ulex:conn cmd rid params attemptnum area-dat)))
-      (rmt:send-receive-orig *default-log-port* runremote *rmt-mutex* areapath *db-multi-sync-mutex* cmd rid params attemptnum: attemptnum area-dat: area-dat))))
+      (rmt:send-receive-orig *default-log-port* runremote *rmt-mutex* areapath *db-multi-sync-mutex* cmd rid params attemptnum: attemptnum area-dat: area-dat ro-queries: api:read-only-queries))))
 
 ;; RA => e.g. usage (rmt:send-receive 'get-var #f (list varname))
 ;;
 ;;  add multi-sync-mutex 
 ;;
@@ -90,11 +90,11 @@
                         payload: `((rid . ,rid)
                                    (params . ,params)))
                           
   
   ;; do all the prep locked under the rmt-mutex
-  (mutex-lock! rmt-mutex)
+  ;;(mutex-lock! rmt-mutex)
   
   ;; 1. check if server is started IFF cmd is a write OR if we are not on the homehost, store in runremote
   ;; 2. check the age of the connections. refresh the connection if it is older than timeout-20 seconds.
   ;; 3. do the query, if on homehost use local access
   ;;
@@ -115,13 +115,13 @@
       (exit 1))
 
      ;; readonly mode, read request-  handle it - case 2
      ((and readonly-mode
            (member cmd api:read-only-queries)) 
-      (mutex-unlock! rmt-mutex)
+      ;; (mutex-unlock! rmt-mutex)
       (debug:print-info 12 log-port "rmt:send-receive, case 2")
-      (rmt:open-qry-close-locally log-port multi-sync-mutex cmd 0 params)
+      (rmt:open-qry-close-locally log-port multi-sync-mutex cmd 0 params ro-queries: api:read-only-queries)
       )
 
      ;; readonly mode, write request.  Do nothing, return #f
      (readonly-mode (extras-readonly-mode rmt-mutex log-port cmd params))
 
@@ -136,41 +136,41 @@
 	      (+ (http-transport:server-dat-get-last-access (remote-conndat runremote))
 		 (remote-server-timeout runremote))))
       (debug:print-info 0 log-port "Connection to " (remote-server-url runremote) " expired due to no accesses, forcing new connection.")
       (http-transport:close-connections area-dat: runremote)
       (remote-conndat-set! runremote #f) ;; invalidate the connection, thus forcing a new connection.
-      (mutex-unlock! rmt-mutex)
+      ;; (mutex-unlock! rmt-mutex)
       (rmt:send-receive-orig log-port runremote rmt-mutex toppath multi-sync-mutex cmd rid params attemptnum: attemptnum))
      
 
      ;; on homehost and this is a read
      ((and (not (remote-force-server runremote)) ;; honor forced use of server, i.e. server NOT required
 	   (cdr (remote-hh-dat runremote))       ;; on homehost
            (member cmd api:read-only-queries))   ;; this is a read
-      (mutex-unlock! rmt-mutex)
+      ;; (mutex-unlock! rmt-mutex)
       (debug:print-info 12 log-port "rmt:send-receive, case  5")
-      (rmt:open-qry-close-locally log-port multi-sync-mutex cmd 0 params))
+      (rmt:open-qry-close-locally log-port multi-sync-mutex cmd 0 params ro-queries: api:read-only-queries))
 
      ;; on homehost and this is a write, we already have a server, but server has died
      ((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))))  ;; server has died. NOTE: this is not a cheap call! Need better approach.
       (set! *runremote* (make-remote))
       (remote-force-server-set! runremote (common:force-server?))
-      (mutex-unlock! rmt-mutex)
+      ;; (mutex-unlock! rmt-mutex)
       (debug:print-info 12 log-port "rmt:send-receive, case  6")
       (rmt:send-receive-orig log-port runremote rmt-mutex toppath  multi-sync-mutex cmd rid params attemptnum: attemptnum))
 
      ;; on homehost and this is a write, we already have a server
      ((and (not (remote-force-server runremote))     ;; honor forced use of server, i.e. server NOT required
 	   (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
-      (mutex-unlock! rmt-mutex)
+      ;;(mutex-unlock! rmt-mutex)
       (debug:print-info 12 log-port "rmt:send-receive, case  4.1")
-      (rmt:open-qry-close-locally  log-port multi-sync-mutex cmd 0 params))
+      (rmt:open-qry-close-locally  log-port multi-sync-mutex cmd 0 params ro-queries: api:read-only-queries))
 
      ;;  on homehost, no server contact made and this is a write, passively start a server 
      ((and (not (remote-force-server runremote))     ;; honor forced use of server, i.e. server NOT required
 	   (cdr (remote-hh-dat runremote))           ;; have homehost
            (not (remote-server-url runremote))       ;; no connection yet
@@ -181,31 +181,31 @@
 	    (remote-server-url-set! runremote server-url) ;; the string can be consumed by the client setup if needed
 	    (if (common:force-server?)
 		(server:start-and-wait toppath)
 		(server:kind-run toppath))))
       (remote-force-server-set! runremote (common:force-server?))
-      (mutex-unlock! rmt-mutex)
+      ;; (mutex-unlock! rmt-mutex)
       (debug:print-info 12 log-port "rmt:send-receive, case  8.1")
-      (rmt:open-qry-close-locally  log-port multi-sync-mutex cmd 0 params))
+      (rmt:open-qry-close-locally  log-port multi-sync-mutex cmd 0 params ro-queries: api:read-only-queries))
 
      ((or (and (remote-force-server runremote)              ;; we are forcing a server and don't yet have a connection to one
 	       (not (remote-conndat runremote)))
 	  (and (not (cdr (remote-hh-dat runremote)))        ;; not on a homehost 
 	       (not (remote-conndat runremote))))           ;; and no connection
       (debug:print-info 12 log-port "rmt:send-receive, case 9, hh-dat: " (remote-hh-dat runremote) " conndat: " (remote-conndat runremote))
-      (mutex-unlock! rmt-mutex)
+      ;;(mutex-unlock! rmt-mutex)
       (if (not (server:check-if-running toppath)) ;; who knows, maybe one has started up?
 	  (server:start-and-wait toppath))
       (remote-conndat-set! runremote (rmt:get-connection-info toppath)) ;; calls client:setup which calls client:setup-http
       (rmt:send-receive-orig log-port runremote rmt-mutex toppath multi-sync-mutex cmd rid params attemptnum: attemptnum)) ;; TODO: add back-off timeout as
 
      ;; all set up if get this far, dispatch the query
      ((and (not (remote-force-server runremote))
 	   (cdr (remote-hh-dat runremote))) ;; we are on homehost
-      (mutex-unlock! rmt-mutex)
+      ;;(mutex-unlock! rmt-mutex)
       (debug:print-info 12 log-port "rmt:send-receive, case 10")
-      (rmt:open-qry-close-locally  log-port multi-sync-mutex cmd (if rid rid 0) params))
+      (rmt:open-qry-close-locally  log-port multi-sync-mutex cmd (if rid rid 0) params ro-queries: api:read-only-queries))
 
      ;; not on homehost, do server query
      (else (extras-case-11 log-port runremote cmd params attemptnum rid)))))
 
 ;; bunch of small functions factored out of send-receive to make debug easier

Index: rmtmod.scm
==================================================================
--- rmtmod.scm
+++ rmtmod.scm
@@ -75,12 +75,12 @@
   (set! db:setup                         dbsetup)
   (set! apt:execute-requests             exec-req)
   (set! api:read-only-queries	         read-only-queries)
   )
 
-(define (rmt:open-qry-close-locally log-port multi-sync-mutex cmd run-id params #!key (remretries 5))
-  (let* ((qry-is-write   (not (member cmd api:read-only-queries)))
+(define (rmt:open-qry-close-locally log-port multi-sync-mutex cmd run-id params #!key (ro-queries '())(remretries 5))
+  (let* ((qry-is-write   (not (member cmd ro-queries)))
 	 (db-file-path   (db:dbfile-path)) ;;  0))
 	 (dbstruct-local (db:setup #t))  ;; make-dbr:dbstruct path:  dbdir local: #t)))
 	 (read-only      (not (file-write-access? db-file-path)))
 	 (start          (current-milliseconds))
 	 (resdat         (if (not (and read-only qry-is-write))
@@ -104,11 +104,11 @@
     (if (not success)
 	(if (> remretries 0)
 	    (begin
 	      (debug:print-error 0 log-port "local query failed. Trying again.")
 	      (thread-sleep! (/ (random 5000) 1000)) ;; some random delay 
-	      (rmt:open-qry-close-locally log-port multi-sync-mutex cmd run-id params remretries: (- remretries 1)))
+	      (rmt:open-qry-close-locally log-port multi-sync-mutex cmd run-id params ro-queries: ro-queries remretries: (- remretries 1)))
 	    (begin
 	      (debug:print-error 0 log-port "too many retries in rmt:open-qry-close-locally, giving up")
 	      #f))
 	(begin
 	  ;; (rmt:update-db-stats run-id cmd params duration)
@@ -134,22 +134,22 @@
 	      (remote-ro-mode-checked-set! runremote #t)
 	      ro-mode)
 	    ro-mode))))
 
 (define (extras-readonly-mode rmt-mutex log-port cmd params)
-  (mutex-unlock! rmt-mutex)
+  ;;(mutex-unlock! rmt-mutex)
   (debug:print-info 12 log-port "rmt:send-receive, case 3")
   (debug:print 0 log-port "WARNING: write transaction requested on a readonly area.  cmd="cmd" params="params)
   #f)
 
 (define (extras-transport-failed *default-log-port* *rmt-mutex* attemptnum runremote cmd rid params)
   (debug:print 0 *default-log-port* "WARNING: communication failed. Trying again, try num: " attemptnum)
-  (mutex-lock! *rmt-mutex*)
+  ;;(mutex-lock! *rmt-mutex*)
   (remote-conndat-set!    runremote #f)
   (http-transport:close-connections area-dat: runremote)
   (remote-server-url-set! runremote #f)
-  (mutex-unlock! *rmt-mutex*)
+  ;;(mutex-unlock! *rmt-mutex*)
   (debug:print-info 12 *default-log-port* "rmt:send-receive, case  9.1")
   (rmt:send-receive cmd rid params attemptnum: (+ attemptnum 1)))
   
 (define (extras-transport-succeded *default-log-port* *rmt-mutex* attemptnum runremote res params rid cmd)
   (if (and (vector? res)
@@ -170,14 +170,14 @@
 						 ;; overloaded and we
 						 ;; want to ease off
 						 ;; the queries
       (let ((wait-delay (+ attemptnum (* attemptnum 10))))
 	(debug:print 0 *default-log-port* "WARNING: server is overloaded. Delaying " wait-delay " seconds and trying call again.")
-	(mutex-lock! *rmt-mutex*)
+	;;(mutex-lock! *rmt-mutex*)
 	(http-transport:close-connections area-dat: runremote)
 	(set! *runremote* #f) ;; force starting over
-	(mutex-unlock! *rmt-mutex*)
+	;;(mutex-unlock! *rmt-mutex*)
 	(thread-sleep! wait-delay)
 	(rmt:send-receive cmd rid params attemptnum: (+ attemptnum 1)))
       res)) ;; All good, return res
 
 ;;======================================================================