Megatest

	 (query-sig   (message-digest-string (md5-primitive) (conc qtype immediate params)))
	 (zdat        (db:obj->string (vector client-sig qtype immediate query-sig params (current-seconds)))) ;; (with-output-to-string (lambda ()(serialize params))))
	 (res  #f)
	 (send-receive (lambda ()
			 (debug:print-info 11 "sending message")
			 (send-message push-socket zdat)
			 (debug:print-info 11 "message sent")
			 (let loop ()
			   ;; get the sender info
			   ;; this should match (server:get-client-signature)
			   ;; we will need to process "all" messages here some day
			   (receive-message* sub-socket)
			   ;; now get the actual message
			   (let ((myres (db:string->obj (receive-message* sub-socket))))
			     (if (equal? query-sig (vector-ref myres 1))
				 (set! res (vector-ref myres 2))
				 (loop))))))
	 (timeout (lambda ()
		    (let loop ((n numretries))
		      (thread-sleep! 20)
		      (if (not res)
			  (if (> numretries 0)
			      (begin
				(debug:print 0 "WARNING: no reply to query " params ", trying resend")
				(debug:print-info 11 "re-sending message")
				(send-message push-socket zdat)
				(debug:print-info 11 "message re-sent")
				(loop (- n 1)))
			      ;; (apply cdb:client-call zmq-sockets qtype immediate (- numretries 1) params))
			      (begin
				(debug:print 0 "ERROR: cdb:client-call timed out " params ", exiting.")
				(exit 5))))))))
    (debug:print-info 11 "Starting threads")
    (let ((th1 (make-thread send-receive "send receive"))
	  (th2 (make-thread timeout      "timeout")))
      (thread-start! th1)
      (thread-start! th2)
      (thread-join!  th1)
      (debug:print-info 11 "cdb:client-call returning res=" res)

	'(test-set-rundir-by-test-id "UPDATE tests SET rundir=? WHERE id=?")
	'(test-set-rundir         "UPDATE tests SET rundir=? WHERE run_id=? AND testname=? AND item_path=?;")
	'(delete-tests-in-state   "DELETE FROM tests WHERE state=? AND run_id=?;")
	'(tests:test-set-toplog   "UPDATE tests SET final_logf=? WHERE run_id=? AND testname=? AND item_path='';")
    ))

;; do not run these as part of the transaction
(define db:special-queries   '(rollup-tests-pass-fail
			       db:roll-up-pass-fail-counts
                               login
                               immediate
			       flush
			       sync
			       set-verbosity
			       killserver))

;; not used, intended to indicate to run in calling process
(define db:run-local-queries '()) ;; rollup-tests-pass-fail))

;; The queue is a list of vectors where the zeroth slot indicates the type of query to

       (let outerloop ((special-qry #f)
		       (stmts       data))
	 (debug:print-info 11 "special-qry=" special-qry ", stmts=" stmts)
	 (if special-qry

	     ;; handle a query that cannot be part of the grouped queries
	     (let* ((stmt-key       (cdb:packet-get-qtype special-qry))
		    (qry-sig        (cdb:packet-get-query-sig special-qry))
		    (return-address (cdb:packet-get-client-sig special-qry))
		    (qry            (hash-table-ref/default queries stmt-key #f))
		    (params         (cdb:packet-get-params special-qry)))
	       (debug:print-info 11 "Special queries/requests stmt-key=" stmt-key ", return-address=" return-address ", qry=" qry ", params=" params)
	       (cond
		;; Special queries
		((string? qry)
		 (apply sqlite3:execute db qry params)
		 (server:reply pubsock return-address qry-sig #t #t))
		;; ((and (not (null? params))
		;;       (procedure? (car params)))
		;;  (let ((proc      (car params))
		;;        (remparams (cdr params)))
		;;    ;; we are being handed a procedure so call it
		;;    (debug:print-info 11 "Running (apply " proc " " db " " remparams ")")
		;;    (server:reply pubsock return-address (apply proc db remparams))))
		
		(else 
		 (case stmt-key
		   ((immediate)
		    (let ((proc      (car params))
			  (remparams (cdr params)))
		      ;; we are being handed a procedure so call it
		      (debug:print-info 11 "Running (apply " proc " " remparams ")")
		      (server:reply pubsock return-address qry-sig #t (apply proc remparams))))
		   ((login)
		    (if (< (length params) 3) ;; should get toppath, version and signature
			'(#f "login failed due to missing params") ;; missing params
			(let ((calling-path (car   params))
			      (calling-vers (cadr  params))
			      (client-key   (caddr params)))
			  (if (and (equal? calling-path *toppath*)
				   (equal? megatest-version calling-vers))
			      (begin
				(hash-table-set! *logged-in-clients* client-key (current-seconds))
				(server:reply  pubsock return-address qry-sig #t '(#t "successful login")))      ;; path matches - pass! Should vet the caller at this time ...
			      (list #f (conc "Login failed due to mismatch paths: " calling-path ", " *toppath*))))))
		   ((flush sync)
		    (server:reply pubsock return-address qry-sig #t (length data)))
		   ((set-verbosity)
		    (set! *verbosity* (car params))
		    (server:reply pubsock return-address qry-sig #t '(#t *verbosity*)))
		   ((killserver)
		    (debug:print 0 "WARNING: Server going down in 15 seconds by user request!")
		    (open-run-close tasks:server-deregister tasks:open-db 
				    (cadr *server-info*)
				    pullport: (caddr *server-info*))
		    (thread-start! (make-thread (lambda ()(thread-sleep! 15)(exit))))
		    (server:reply pubsock return-address qry-sig #t '(#t "exit process started")))
		   (else
		    (debug:print 0 "ERROR: Unrecognised queued call " qry " " params)
		    (server:reply pubsock return-address qry-sig #f #t)))))
	       (if (not (null? stmts))
		   (outerloop #f stmts)))

	     ;; handle normal queries
	     (let ((rem (sqlite3:with-transaction 
			 db
			 (lambda ()
			   (debug:print-info 11 "flushing " stmts " to db")
			   (if (null? stmts)
			       stmts
			       (let innerloop ((hed (car stmts))
					       (tal (cdr stmts)))
				 (let ((params         (cdb:packet-get-params hed))
				       (return-address (cdb:packet-get-client-sig hed))
				       (qry-sig        (cdb:packet-get-query-sig hed))
				       (stmt-key       (cdb:packet-get-qtype hed)))
				   (if (or (not (hash-table-ref/default queries stmt-key #f))
					   (member stmt-key db:special-queries))
				       (begin
					 (debug:print-info 11 "Handling special statement " stmt-key)
					 (cons hed tal))
				       (begin
					 (debug:print-info 11 "Executing " stmt-key " for " params)
					 (apply sqlite3:execute (hash-table-ref queries stmt-key) params)
					 (server:reply pubsock return-address qry-sig #t #t)
					 (if (not (null? tal))
					     (innerloop (car tal)(cdr tal))
					     '()))
				       ))))))))
	       (if (not (null? rem))
		   (outerloop (car rem)(cdr rem))))))
       (for-each (lambda (stmt-key)