Delete lack.handler because it's a scope of Clack, not Lack.

lack.asd

@@ -19,14 +19,11 @@
   :author "Eitaro Fukamachi"
   :license "LLGPL"
   :depends-on (:lack-component
-               :lack-util
-               :bordeaux-threads
-               :alexandria)
+               :lack-util)
   :components ((:module "src"
                 :components
-                ((:file "lack" :depends-on ("builder" "handler"))
-                 (:file "builder")
-                 (:file "handler"))))
+                ((:file "lack" :depends-on ("builder"))
+                 (:file "builder"))))
   :description "A minimal Clack"
   :long-description
   #.(with-open-file (stream (merge-pathnames

src/handler.lisp

@@ -1,56 +0,0 @@
-(in-package :cl-user)
-(defpackage lack.handler
-  (:use :cl)
-  (:import-from :lack.util
-                :find-package-or-load)
-  (:import-from :bordeaux-threads
-                :threadp
-                :make-thread
-                :thread-alive-p
-                :destroy-thread)
-  (:export :run
-           :stop))
-(in-package :lack.handler)
-
-(defstruct handler
-  server
-  acceptor)
-
-(defun find-handler (server)
-  (flet ((find-with-prefix (prefix)
-           (find-package-or-load (concatenate 'string
-                                              prefix
-                                              (symbol-name server)))))
-    (or (find-with-prefix #.(string '#:lack.handler.))
-        ;; falling back to Clack handler
-        (find-with-prefix #.(string '#:clack.handler.))
-        (error "~S is unknown handler."
-               server))))
-
-(defun run (app server &rest args &key use-thread &allow-other-keys)
-  (let ((handler-package (find-handler server)))
-    (flet ((run-server ()
-             (apply (intern #.(string '#:run) handler-package)
-                    app
-                    :allow-other-keys t
-                    args)))
-      (make-handler
-       :server server
-       :acceptor (if use-thread
-                     (bt:make-thread #'run-server
-                                     :name (format nil "lack-handler-~(~A~)" server)
-                                     :initial-bindings
-                                     `((*standard-output* . ,*standard-output*)
-                                       (*error-output* . ,*error-output*)))
-                     (run-server))))))
-
-(defun stop (handler)
-  (let ((acceptor (handler-acceptor handler)))
-    (if (bt:threadp acceptor)
-        (progn
-          (when (bt:thread-alive-p acceptor)
-            (bt:destroy-thread acceptor))
-          (sleep 0.5))
-        (let ((package (find-handler (handler-server handler))))
-          (funcall (intern #.(string '#:stop) package) acceptor)))
-    t))

src/lack.lisp

@@ -3,57 +3,5 @@
   (:use :cl)
   (:import-from :lack.builder
                 :builder)
-  (:import-from :lack.handler
-                :run
-                :stop)
-  (:import-from :alexandria
-                :delete-from-plist)
-  (:export :lackup
-           :stop
-           :builder))
+  (:export :builder))
 (in-package :lack)
-
-(defun eval-file (file)
-  "Safer way to read and eval a file content. This function returns the last value."
-  (check-type file (or pathname string))
-  (with-open-file (in file)
-    (let ((*package* *package*)
-          (*readtable* *readtable*)
-          (*load-pathname* nil)
-          (*load-truename* nil))
-      (loop with results
-            with eof = '#:eof
-            for form = (read in nil eof)
-            until (eq form eof)
-            do (setf results (multiple-value-list (eval form)))
-            finally
-               (return (apply #'values results))))))
-
-(defun lackup (app &rest args
-               &key (server :hunchentoot)
-                 (port 5000)
-                 (debug t)
-                 silent
-                 (use-thread #+thread-support t #-thread-support nil)
-                 (use-default-middlewares t)
-               &allow-other-keys)
-  (flet ((print-start-message ()
-           (unless silent
-             (format t "~&~:(~A~) server is started.~%Listening on localhost:~A.~%" server port)))
-         (buildapp (app)
-           (let ((app (etypecase app
-                        ((or pathname string)
-                         (eval-file app))
-                        (function app))))
-             (if use-default-middlewares
-                 (builder :backtrace app)
-                 app))))
-    (unless use-thread
-      (print-start-message))
-    (prog1
-        (apply #'lack.handler:run (buildapp app) server
-               :port port
-               :debug debug
-               :use-thread use-thread
-               (delete-from-plist args :server :port :debug :silent :use-thread))
-      (print-start-message))))