@@ -17,12 +17,45 @@
 ;;     along with Megatest.  If not, see <http://www.gnu.org/licenses/>.
 ;;
 ;;======================================================================
 
 ;; (use trace)
+(use typed-records)
+
+;; globals - modules that include this need these here
+(define *verbosity-cache* (make-hash-table))
+(define *verbosity* 0)
+(define *default-log-port* (current-error-port))
+(define *logging* #f)
+(define *functions* (make-hash-table)) ;; symbol => fn
+(define *toppath* #f)
+(define *transport-type* 'http)
+
+(define (exec-fn fn . params)
+  (if (hash-table-exists? *functions* fn)
+      (apply (hash-table-ref *functions* fn) params)
+      #f))
+
+(define (set-fn fn-name fn)
+  (hash-table-set! *functions* fn-name fn))
 
 (include "altdb.scm")
+
+
+(defstruct remote
+  (hh-dat            (exec-fn 'common:get-homehost)) ;; homehost record ( addr . hhflag )
+  (server-url        (if *toppath* (exec-fn 'server:check-if-running *toppath*))) ;; (server:check-if-running *toppath*) #f))
+  (last-server-check 0)  ;; last time we checked to see if the server was alive
+  (conndat           #f)
+  (transport         *transport-type*)
+  (server-timeout    (exec-fn 'server:expiration-timeout))
+  (force-server      #f)
+  (ro-mode           #f)  
+  (ro-mode-checked   #f) ;; flag that indicates we have checked for ro-mode
+  (ulex:conn         #f) ;; ulex db conn is not exactly a db connector, more like a network connector 
+  )
+
 
 ;; Some of these routines use:
 ;;
 ;;     http://www.cs.toronto.edu/~gfb/scheme/simple-macros.html
 ;;
@@ -80,11 +113,11 @@
 
 ;; this was cached based on results from profiling but it turned out the profiling
 ;; somehow went wrong - perhaps too many processes writing to it. Leaving the caching
 ;; in for now but can probably take it out later.
 ;;
-(define (debug:calc-verbosity vstr)
+(define (debug:calc-verbosity vstr verbose quiet) ;; verbose and quiet are #f or enabled
   (or (hash-table-ref/default *verbosity-cache* vstr #f)
       (let ((res (cond
                   ((number? vstr) vstr)
                   ((not (string?  vstr))   1)
                   ;; ((string-match  "^\\s*$" vstr) 1)
@@ -91,12 +124,12 @@
                   (vstr           (let ((debugvals  (filter number? (map string->number (string-split vstr ",")))))
                                     (cond
                                      ((> (length debugvals) 1) debugvals)
                                      ((> (length debugvals) 0)(car debugvals))
                                      (else 1))))
-                  ((args:get-arg "-v")   2)
-                  ((args:get-arg "-q")    0)
+                  (verbose                2) ;; ((args:get-arg "-v")   2)
+                  (quiet                  0) ;; ((args:get-arg "-q")    0)
                   (else                   1))))
         (hash-table-set! *verbosity-cache* vstr res)
         res)))
 
 ;; check verbosity, #t is ok
@@ -121,29 +154,29 @@
     (not (null? (lset-intersection! eq? *verbosity* n))))
    ((and (number? *verbosity*)
 	 (list? n))
     (member *verbosity* n))))
 
-(define (debug:setup)
-  (let ((debugstr (or (args:get-arg "-debug")
-		      (getenv "MT_DEBUG_MODE"))))
-    (set! *verbosity* (debug:calc-verbosity debugstr))
+(define (debug:setup dmode verbose quiet)
+  (let ((debugstr (or dmode                           ;; (args:get-arg "-debug")
+		      (get-environment-variable "MT_DEBUG_MODE"))))
+    (set! *verbosity* (debug:calc-verbosity debugstr verbose quiet))
     (debug:check-verbosity *verbosity* debugstr)
     ;; if we were handed a bad verbosity rule then we will override it with 1 and continue
     (if (not *verbosity*)(set! *verbosity* 1))
-    (if (or (args:get-arg "-debug")
-	    (not (getenv "MT_DEBUG_MODE")))
+    (if (or dmode                                            ;; (args:get-arg "-debug")
+	    (not (get-environment-variable "MT_DEBUG_MODE")))
 	(setenv "MT_DEBUG_MODE" (if (list? *verbosity*)
 				    (string-intersperse (map conc *verbosity*) ",")
 				    (conc *verbosity*))))))
   
 (define (debug:print n e . params)
   (if (debug:debug-mode n)
       (with-output-to-port (or e (current-error-port))
 	(lambda ()
 	  (if *logging*
-	      (db:log-event (apply conc params))
+	      (exec-fn 'db:log-event (apply conc params))
 	      (apply print params)
 	      )))))
 
 ;; Brandon's debug printer shortcut (indulge me :)
 (define *BB-process-starttime* (current-milliseconds))
@@ -218,11 +251,11 @@
   ;; normal print
   (if (debug:debug-mode n)
       (with-output-to-port (if (port? e) e (current-error-port))
 	(lambda ()
 	  (if *logging*
-	      (db:log-event (apply conc params))
+	      (exec-fn 'db:log-event (apply conc params))
 	      ;; (apply print "pid:" (current-process-id) " " params)
 	      (apply print "ERROR: " params)
 	      ))))
   ;; pass important messages to stderr
   (if (and (eq? n 0)(not (eq? e (current-error-port)))) 
@@ -235,11 +268,11 @@
   (if (debug:debug-mode n)
       (with-output-to-port (if (port? e) e (current-error-port))
 	(lambda ()
 	  (if *logging*
 	      (let ((res (format#format #f "INFO: (~a) ~a" n (apply conc params))))
-		(db:log-event res))
+		(exec-fn 'db:log-event res))
 	      ;; (apply print "pid:" (current-process-id) " " "INFO: (" n ") " params) ;; res)
 	      (apply print "INFO: (" n ") " params) ;; res)
 	      )))))