@@ -7,7 +7,7 @@

 (defclass event-pump ()

   ((%tick-pause :initform 0.01)

    (%running :accessor running :initform nil)

-   (%finish-cb :reader finish-cb :writer fwoar.event-loop:register-finish-cb :initform nil)

+   (%finish-cb :accessor fwoar.event-loop:finish-cb :initform nil)

    (%ws-client :accessor ws-client :initarg :ws-client :initform nil)

    (%waiting-pings :accessor waiting-pings :initform 0)

    (%modules :accessor modules :initform (make-hash-table))

@@ -30,11 +30,11 @@

   (setf (waiting-pings event-pump) 0))

 (defmethod fwoar.event-loop:prepare-loop ((event-pump event-pump))

-  (declare (optimize (debug 3)))

-  (let ((client (funcall (client-factory event-pump) event-pump)))

-    #+nil (websocket-driver:start-connection client)))

+  (funcall (client-factory event-pump)

+           event-pump))

 (defmethod fwoar.event-loop:cleanup ((event-pump event-pump))

+  (format t "~&cleaning up...~&")

   (setf (running event-pump) nil)

   (do-hash-table (_ v (modules event-pump))

     (declare (ignore _))

@@ -78,7 +78,7 @@

              (modules event-pump))))

 (defun stop-slacker (event-pump)

-  (funcall (finish-cb event-pump)))

+  (funcall (fwoar.event-loop:finish-cb event-pump)))

 (defun throttle-continue (num)

   (let ((continue-count 0)

@@ -3,7 +3,7 @@

 (defpackage :quote-server

   (:use :cl :ningle :araneus :serapeum :alexandria :fw.lu)

-   (:export #:start))

+  (:export #:start))

 (cl:in-package :hhgbot-2)

@@ -108,13 +108,13 @@

 (define-command "latina" (event-pump message channel word &rest a)

   (declare (ignore a))

   (let* ((results (words-coprocess::get-word-results word))

-	 (json-objs (split-sequence #\newline results :remove-empty-subseqs t))

-	 (parsed (mapcar 'yason:parse json-objs)))

+         (json-objs (split-sequence #\newline results :remove-empty-subseqs t))

+         (parsed (mapcar 'yason:parse json-objs)))

     (queue-message event-pump channel

-		   (format nil "~{> ~a~2%~}"

-			   (remove-if-not #'identity

-					  (mapcan (op (gethash "meanings" _))

-						  parsed))))))

+                   (format nil "~{> ~a~2%~}"

+                           (remove-if-not #'identity

+                                          (mapcan (op (gethash "meanings" _))

+                                                  parsed))))))

 (define-message-command "random-quote" (event-pump message channel &rest args)

   args

@@ -131,26 +131,26 @@

 (define-message-command "arc" (event-pump message channel &rest args)

   (let ((r (with-output-to-string (s)

-	     (multiple-value-bind (results idx)

-		 (slacker.montezuma-store:search-index *client* "message" (string-join args " "))

-	       (montezuma:each results

-			       (lambda (h)

-				 (format s "> ~a: ~a~%"

-					 (local-time:format-timestring

-					  nil

-					  (local-time:unix-to-timestamp

-					   (floor 

-					    (parse-number

-					     (montezuma:document-value (montezuma:get-document idx (montezuma:doc h))

-								       "ts")))

-					   )

-					  :format local-time:+rfc3339-format+)

-					 

-					 (montezuma:document-value (montezuma:get-document idx (montezuma:doc h))

-								   "text"))))))))

+             (multiple-value-bind (results idx)

+                 (slacker.montezuma-store:search-index *client* "message" (string-join args " "))

+               (montezuma:each results

+                               (lambda (h)

+                                 (format s "> ~a: ~a~%"

+                                         (local-time:format-timestring

+                                          nil

+                                          (local-time:unix-to-timestamp

+                                           (floor 

+                                            (parse-number

+                                             (montezuma:document-value (montezuma:get-document idx (montezuma:doc h))

+                                                                       "ts")))

+                                           )

+                                          :format local-time:+rfc3339-format+)

+                                         

+                                         (montezuma:document-value (montezuma:get-document idx (montezuma:doc h))

+                                                                   "text"))))))))

     (if (= 0 (length r))

         (format nil "No results found for: `~a`" (string-join args " "))

-	r)))

+        r)))

 (defun extract-channel-info (channels)

   (funcall (data-lens:pick

@@ -175,7 +175,7 @@

                                  (data-lens:juxt (op (gethash "name" _))

                                                  (op (gethash "id" _))))

                                 (gethash "channels" r))))

-#+nil    (fw.su:log-json channels)

+    #+nil    (fw.su:log-json channels)

     (assoc name channels :test 'equal)))

 (defmacro with-output-to-json-string ((s &rest args &key indent) &body body)

@@ -193,7 +193,7 @@ Return a string with the generated JSON output."

 (defmethod slacker:handle-message :before (type (event-pump hhgbot-event-pump) ts channel message)

   (declare (ignore type ts channel))

-#+nil

+  #+nil

   (index-message message)

   (values))

@@ -202,22 +202,22 @@ Return a string with the generated JSON output."

                                              &rest args)

   (format *xxx* "~&~a: ~{~a~^ ~}~%" target args)

   (dbind* (&optional target-name target-id) (find-channel target)

-          (if target-name

-              (progn

-                (with (message (string-join args #\space))

-                  (when-let* ((start-link (position #\< message))

-                              (stop-link (position #\> message :start start-link))

-                              (_ (> stop-link (+ 4 start-link))))

-                    (setf message (concat (subseq message 0 start-link)

-                                          (subseq message (1+ start-link) stop-link)

-                                          (subseq message (1+ stop-link)))))

-                  (queue-message event-pump target-id

-                                 message))

-                (queue-message event-pump target-id

-                               (format nil "Notifying channel ~a" target-name)

-                               :thread (ensure-thread message)))

-              (queue-message event-pump target-id (format nil "Can't find channel `~a`" target)

-                             :thread (ensure-thread message)))))

+    (if target-name

+        (progn

+          (with (message (string-join args #\space))

+            (when-let* ((start-link (position #\< message))

+                        (stop-link (position #\> message :start start-link))

+                        (_ (> stop-link (+ 4 start-link))))

+              (setf message (concat (subseq message 0 start-link)

+                                    (subseq message (1+ start-link) stop-link)

+                                    (subseq message (1+ stop-link)))))

+            (queue-message event-pump target-id

+                           message))

+          (queue-message event-pump target-id

+                         (format nil "Notifying channel ~a" target-name)

+                         :thread (ensure-thread message)))

+        (queue-message event-pump target-id (format nil "Can't find channel `~a`" target)

+                       :thread (ensure-thread message)))))

 (defparameter *reaction-store* (make-hash-table :test 'equalp :synchronized t))

@@ -257,7 +257,7 @@ Return a string with the generated JSON output."

   (initialize-quotes)

   (quote-server:start)

   (setf (values *client* slacker::*api-token*)

-	(start-in-repl)))

+        (start-in-repl)))

 (in-package :quote-server)

@@ -15,22 +15,25 @@

 (defmethod slacker:start-module ((event-pump event-pump) (exe js-executor))

   (declare (ignorable event-pump))

+  

   (values exe

-          (bt:make-thread

-           (lambda ()

-             (loop

-               (multiple-value-bind (message message-p) (chanl:recv (work-queue exe))

-                 (when message-p

-                   (destructuring-bind (promise script) message

-                     (handler-case

-                         (blackbird-base:finish promise

-                                                (cl-js:run-js script))

-                       (serious-condition (c) (blackbird:signal-error promise c)))))

-		             (sleep 0.4))))

-	         :name "js-executor")))

+          (setf (thread exe)

+                (bt:make-thread

+                 (lambda ()

+                   (loop

+                     (multiple-value-bind (message message-p) (chanl:recv (work-queue exe))

+                       (when message-p

+                         (destructuring-bind (promise script) message

+                           (handler-case

+                               (blackbird-base:finish promise

+                                                      (cl-js:run-js script))

+                             (serious-condition (c) (blackbird:signal-error promise c)))))

+		                   (sleep 0.4))))

+	               :name "js-executor"))))

 (defmethod slacker:stop-module ((event-pump event-pump) (exe js-executor))

   (declare (ignorable event-pump))

   (with-accessors ((thread thread)) exe

+    (format t "~&executor: ~s~&" thread)

     (when thread

       (bt:destroy-thread thread))))

@@ -103,7 +103,7 @@

                         (apply #'attach-module

                                event-pump module args)))

-  (bt:make-thread (op (fwoar.event-loop:run-loop event-pump))))

+  (fwoar.event-loop:run-loop event-pump))

 (defun start-client (implementation &key (queue-pair (make-instance 'queue-pair)) modules)

   (let* ((event-pump (make-instance implementation

@@ -190,8 +190,11 @@

   (let* ((event-pump (start-client implementation

                                    :queue-pair queue-pair

                                    :modules '((hhgbot-augmented-assistant::js-executor)))))

-    (bt:make-thread (lambda () (loop until (running event-pump)

-                                     finally (event-loop event-pump)))

+    (bt:make-thread (lambda ()

+                      (loop until (running event-pump)

+                            finally

+                               (unwind-protect (event-loop event-pump)

+                                 (stop-slacker event-pump))))

                     :name "Event Loop") 

     event-pump))