Add websocket-keepalive middleware

Author: weavejester

src/ring/middleware/websocket_keepalive.clj

@@ -1 +1,47 @@
-(ns ring.middleware.websocket-keepalive)
+(ns ring.middleware.websocket-keepalive
+  (:require [ring.websocket :as ws]
+            [ring.websocket.protocols :as wsp])
+  (:import [java.util.concurrent
+            Executors Future ScheduledExecutorService TimeUnit]))
+
+(def default-schedule-executor
+  (delay (Executors/newSingleThreadScheduledExecutor)))
+
+(defn websocket-keepalive-response [response options]
+  (if (ws/websocket-response? response)
+    (let [listener (::ws/listener response)
+          executor (:executor options @default-schedule-executor)
+          period   (:period options 30000)
+          task     (promise)]
+      (assoc response ::ws/listener
+             (reify wsp/Listener
+               (on-open [_ socket]
+                 (deliver task (.scheduleAtFixedRate
+                                ^ScheduledExecutorService executor
+                                #(ws/ping socket)
+                                period period TimeUnit/MILLISECONDS))
+                 (wsp/on-open listener socket))
+               (on-message [_ socket message]
+                 (wsp/on-message listener socket message))
+               (on-pong [_ socket data]
+                 (wsp/on-pong listener socket data))
+               (on-error [_ socket throwable]
+                 (wsp/on-error listener socket throwable))
+               (on-close [_ socket code reason]
+                 (.cancel ^Future @task false)
+                 (wsp/on-close listener socket code reason))
+               wsp/PingListener
+               (on-ping [_ socket data]
+                 (if (satisfies? wsp/PingListener listener)
+                   (wsp/on-ping listener socket data)
+                   (wsp/-ping socket data))))))
+    response))
+
+(defn wrap-websocket-keepalive [handler options]
+  (fn
+    ([request]
+     (websocket-keepalive-response (handler request) options))
+    ([request respond raise]
+     (handler request
+              #(respond (websocket-keepalive-response % options))
+              raise))))

test/ring/middleware/websocket_keepalive_test.clj

@@ -1,6 +1,28 @@
 (ns ring.middleware.websocket-keepalive-test
   (:require [clojure.test :refer [deftest is]]
-            [ring.middleware.websocket-keepalive :as keepalive]))
+            [ring.websocket :as ws]
+            [ring.websocket.protocols :as wsp]
+            [ring.middleware.websocket-keepalive :as ka]))
 
-(deftest a-test
-  (is (= 0 1)))
+(deftest test-websocket-keepalive-request
+  (let [ping-count (atom 0)
+        socket     (reify wsp/Socket
+                     (-open? [_] true)
+                     (-send [_ _])
+                     (-ping [_ _] (swap! ping-count inc))
+                     (-pong [_ _])
+                     (-close [_ _ _]))
+        response   {::ws/listener
+                    (reify wsp/Listener
+                      (on-open [_ _])
+                      (on-message [_ _ _])
+                      (on-pong [_ _ _])
+                      (on-error [_ _ _])
+                      (on-close [_ _ _ _]))}
+        response'  (ka/websocket-keepalive-response response {:period 10})
+        listener   (::ws/listener response')]
+    (wsp/on-open listener socket)
+    (Thread/sleep 51)
+    (wsp/on-close listener socket 1000 "")
+    (Thread/sleep 30)
+    (is (= @ping-count 5))))