anchor.diff:                                           :backlog 5
                                            :reuse-address t
                                            #++ :no-delay)
  -           (iolib:set-io-handler event-base
  -                                 control-fd
  -                                 :read (lambda (fd e ex)
  -                                          (declare (ignorable fd e ex))
  -                                          (log:debug "Got lambda to execute on server thread ~a" (eventfd.read control-fd))
  -                                          (loop for m = (dequeue control-mailbox)
  -                                                while m
  -                                                do (funcall m))))
  -           (iolib:set-io-handler event-base
  -                                 (iolib:socket-os-fd socket)
  -                                 :read (let ((true-handler (make-listener-handler
  -                                                            server
  -                                                            socket)))
  -                                         (lambda (&rest rest)
  -                                            (log:debug "There is something to read on fd ~A" (first rest))
  -                                            (apply true-handler rest))))
  -           (handler-case
  -               (event-dispatch event-base)
  -             ;; ... handle errors
  -             ))
  -      (loop :for v :in (server-list-clients server)
  -            :do
  -               (log:debug "cleanup up dropping client ~s" v)
  -               (client-enqueue-read v (list v :dropped))
  -               (client-disconnect v :abort t))
  -      (close event-base)
  -      (close-eventfd control-fd))))
  +           (let ((true-handler (make-listener-handler
  +                                server
  +                                socket)))
  +             (iolib:set-io-handler event-base
  +                                   control-fd
  +                                   :read (lambda (fd e ex)
  +                                            (declare (ignorable fd e ex))
  +                                            (log:debug "Got lambda to execute on server thread ~a" (eventfd.read control-fd))
  +                                            (loop for m = (dequeue control-mailbox)
  +                                                  while m
  +                                                  do (funcall m))))
  +             (iolib:set-io-handler event-base
  +                                   (iolib:socket-os-fd socket)
  +                                   :read
  +                                   (lambda (&rest rest)
  +                                      (log:debug "There is something to read on fd ~A" (first rest))
  +                                      (apply true-handler rest)))
  +             (handler-case
  +                 (event-dispatch event-base)
  +               ;; ... handle errors
  +               ))
  +           (loop :for v :in (server-list-clients server)
  +                 :do
  +                    (log:debug "cleanup up dropping client ~s" v)
  +                    (client-enqueue-read v (list v :dropped))
  +                    (client-disconnect v :abort t))
  +           (close event-base)
  +           (close-eventfd control-fd)))))
   
   (defun setup-execute-in-server-lambda (server)
     (let* ((control-mailbox (make-queue :name (concatenate 'string (server-name server) " server-control")))
  
positive.code:   "Calls RUN-SERVER with given SERVER in separate thread.
  Return SERVER"
    (bt:make-thread
     (lambda ()      
        (run-server server))
     :name (server-name server))
    server)
  
  
  (defun stop-server (server)
    (log:info "Killing resources~%")
    (kill-all-server-resource-listeners server)
    (log:info "Stopping Server Thread~%")
    (funcall (execute-in-server-lambda server) (lambda ()
                                                  (sb-thread:abort-thread))))
  
negative.code: (defun make-listener-handler (server socket)
    (lambda (fd event exception)
       (declare (ignore fd event exception))
       (if (shutting-down-p server)
           ;; stop accepting new connections first
           (iolib:remove-fd-handlers (server-event-base server) (iolib:socket-os-fd socket))
           (let* ((client-socket (accept-connection socket :wait t))
                  (client (when client-socket
                            (make-instance (server-client-class server)
                                           :server server
                                           :%host (remote-host client-socket)
                                           :host (address-to-string
                                                  (remote-host client-socket))
                                           :port (remote-port client-socket)
                                           :server-hook (slot-value server 'execute-in-server-lambda)
                                           :socket client-socket))))
             (when client
               (log:debug "got client connection from ~s ~s~%" (client-host client)
                          (client-port client))
               (log:debug "client count = ~s/~s~%" (server-client-count server) *max-clients*)
               (cond
                 ((and *max-clients* (> (server-client-count server) *max-clients*))
                  ;; too many clients, send a server busy response and close connection
                  (log:info "Too many clients ~s:~s, sending busy response" (server-client-count server) *max-clients*)
                  (client-disconnect client :read t)
                  (client-enqueue-write client *server-busy-message*)
                  (client-enqueue-write client :close))
                 (t
                  ;; otherwise handle normally
                  (setf (gethash client (server-clients server)) client)
                  (add-reader-to-client client))))))))
  
  (defun run-server% (server)
    (let ((event-base (server-event-base server))
  