last rename

README.md

@@ -1,4 +1,4 @@
-# lido
+# eddy
 
 Jetty11+ server library (client support might eventually be added later).
 
@@ -16,7 +16,7 @@ Jetty11+ server library (client support might eventually be added later).
 ## Documentation
 
 ## Installation
-<!-- lido is [available on Clojars](https://clojars.org/s-exp/lido). -->
+<!-- eddy is [available on Clojars](https://clojars.org/s-exp/eddy). -->
 
 ## License
 

build.clj

@@ -4,7 +4,7 @@
 
 (set! *warn-on-reflection* true)
 
-(def lib 'com.s-exp/lido)
+(def lib 'com.s-exp/eddy)
 (def version (format "1.0.%s" (b/git-count-revs nil)))
 (def class-dir "target/classes")
 (def basis (b/create-basis {:project "deps.edn"}))

deps.edn

@@ -2,6 +2,7 @@
         org.eclipse.jetty/jetty-server {:mvn/version "11.0.6"}
         org.eclipse.jetty.http2/http2-server {:mvn/version "11.0.6"}
         org.eclipse.jetty/jetty-alpn-server {:mvn/version "11.0.6"}
+        org.eclipse.jetty.websocket/websocket-jetty-server {:mvn/version "11.0.6"}
         exoscale/interceptor {:mvn/version "0.1.9"}
         cc.qbits/auspex {:mvn/version "1.0.0-alpha7"}
         org.clojure/tools.logging {:mvn/version "1.1.0"}}

src/s_exp/lido/http/interceptor/ring1.clj → src/s_exp/eddy/http/interceptor/ring1.clj

@@ -1,20 +1,22 @@
-(ns s-exp.lido.http.interceptor.ring1
+(ns s-exp.eddy.http.interceptor.ring1
   "adapted/taken from ring.util.servlet"
   (:require
-   [s-exp.lido.http.server.request :as request]
-   [s-exp.lido.http.server.response :as response]
+   [s-exp.eddy.http.server.request :as request]
+   [s-exp.eddy.http.server.response :as response]
    [exoscale.interceptor :as ix]
-   [s-exp.lido.http.interceptor.ring1 :as ring1]
+   [s-exp.eddy.http.interceptor.ring1 :as ring1]
    [qbits.auspex :as ax])
   (:import (org.eclipse.jetty.server Request Response)
+           (org.eclipse.jetty.websocket.server JettyWebSocketServerContainer
+                                               JettyWebSocketCreator)
            (jakarta.servlet AsyncContext)))
 
 ;;; interceptors
 
 (def read-headers
   {:name ::read-request
    :enter
-   (fn [{:as ctx :s-exp.lido.http.server/keys [^Request request]}]
+   (fn [{:as ctx :s-exp.eddy.http.server/keys [^Request request]}]
      (assoc ctx
             :ring1/request
             {:server-port (request/server-port request)
@@ -33,13 +35,13 @@
 
 (def read-body
   {:name ::read-body-sync
-   :enter (fn [{:as ctx :s-exp.lido.http.server/keys [^Request request]}]
+   :enter (fn [{:as ctx :s-exp.eddy.http.server/keys [^Request request]}]
             (assoc-in ctx [:ring1/request :body] (.getInputStream request)))})
 
 (def write-headers
   {:name ::write-response
    :enter (fn [{:as ctx
-                :s-exp.lido.http.server/keys [^Response response]}]
+                :s-exp.eddy.http.server/keys [^Response response]}]
             (let [{:keys [status headers]} (:ring1/response ctx)]
 
               (when (nil? response)
@@ -59,14 +61,14 @@
 (def write-body
   {:name ::write-body
    :enter (fn [{:as ctx
-                :s-exp.lido.http.server/keys [^Response response]}]
+                :s-exp.eddy.http.server/keys [^Response response]}]
             (response/set-body! response (-> ctx :ring1/response :body))
             ctx)})
 
 (def write-body-async
   {:name ::write-body-async
    :enter (fn [{:as ctx
-                :s-exp.lido.http.server/keys [^Response response]}]
+                :s-exp.eddy.http.server/keys [^Response response]}]
             (ax/then (response/set-body-async! response (-> ctx :ring1/response :body))
                      (fn [_] ctx)))})
 
@@ -76,6 +78,17 @@
                 (handler request))
               (ix/out [:ring1/response]))})
 
+(def handle-upgrade-request
+  {:name ::ws
+   :enter (fn [{:as ctx ::s-exp.eddy.http.server/keys [request resposne]}]
+            (if-let [ws (-> ctx :ring1/response :websocket)]
+              (let [container (JettyWebSocketServerContainer/getContainer (.getServletContext (:s-exp.eddy.http.server/request ctx)))
+                    (JettyWebSocketCreator.)]
+
+                )
+              ctx)
+            )})
+
 (def handle-request-async
   {:name ::handle-request
    :enter (-> (fn [{:as _ctx :ring1/keys [handler request]}]
@@ -85,17 +98,17 @@
 
 (def init-request
   {:leave (fn [{:as ctx
-                :s-exp.lido.http.server/keys [^Request request]}]
+                :s-exp.eddy.http.server/keys [^Request request]}]
             (request/complete! request))
-   :error (fn [{:s-exp.lido.http.server/keys [^Request request]}
+   :error (fn [{:s-exp.eddy.http.server/keys [^Request request]}
                e]
             (print e)
             (request/complete! request)
             (throw e))})
 
 (def init-request-async
   {:enter (fn [{:as ctx
-                :s-exp.lido.http.server/keys [^Request request
+                :s-exp.eddy.http.server/keys [^Request request
                                               async-timeout]}]
             (let [async-ctx (request/start-async request)]
               (when async-timeout

src/s_exp/lido/http/server.clj → src/s_exp/eddy/http/server.clj

@@ -1,9 +1,9 @@
-(ns s-exp.lido.http.server
+(ns s-exp.eddy.http.server
   (:require [exoscale.interceptor :as interceptor]
             [exoscale.interceptor.auspex]
-            [s-exp.lido.http.interceptor.ring1 :as ring1]
-            [s-exp.lido.http.server.request :as request]
-            [s-exp.lido.http.server.response :as response]
+            [s-exp.eddy.http.interceptor.ring1 :as ring1]
+            [s-exp.eddy.http.server.request :as request]
+            [s-exp.eddy.http.server.response :as response]
             [clojure.tools.logging :as log])
 
   (:import
@@ -32,30 +32,30 @@
 
 (def default-opts
   (merge
-   #:s-exp.lido.http.server{:join? true}
-   #:s-exp.lido.http.server.interceptor{:chain ring1/chain
+   #:s-exp.eddy.http.server{:join? true}
+   #:s-exp.eddy.http.server.interceptor{:chain ring1/chain
                                          :ctx {}}
-   #:s-exp.lido.http.server.threadpool{:daemon? false
+   #:s-exp.eddy.http.server.threadpool{:daemon? false
                                         :max-threads 50
                                         :min-threads 8
                                         :max-queued-requests Integer/MAX_VALUE
                                         :idle-timeout 60000}
-   #:s-exp.lido.http.server.http-config{:secure-scheme "https"
+   #:s-exp.eddy.http.server.http-config{:secure-scheme "https"
                                          :output-buffer-size 32768
                                          :request-header-size 8192
                                          :response-header-size 8192
                                          :send-server-version? false
                                          :send-date-header? false
                                          :header-cache-size 512}
-   #:s-exp.lido.http.server.http-connector{:port 8080
+   #:s-exp.eddy.http.server.http-connector{:port 8080
                                             :max-idle-time 200000}
-   #:s-exp.lido.http.server.ssl-connector{:max-idle-time 200000}
-   #:s-exp.lido.ssl-context-factory{}))
+   #:s-exp.eddy.http.server.ssl-connector{:max-idle-time 200000}
+   #:s-exp.eddy.ssl-context-factory{}))
 
 (defn initial-context
   [ctx request response]
   (into ctx
-        #:s-exp.lido.http.server{:request request
+        #:s-exp.eddy.http.server{:request request
                                   :response response}))
 
 (defn create-handler
@@ -69,7 +69,7 @@
 
 (defn handler
   [{:as _opts
-    :s-exp.lido.http.server.interceptor/keys [chain ctx]}]
+    :s-exp.eddy.http.server.interceptor/keys [chain ctx]}]
   (create-handler
    (fn [_
         ^Request request
@@ -87,7 +87,7 @@
 
 (defn- create-threadpool
   ^ThreadPool
-  [{:s-exp.lido.http.server.threadpool/keys [max-threads min-threads
+  [{:s-exp.eddy.http.server.threadpool/keys [max-threads min-threads
                                               idle-timeout daemon?
                                               max-queued-requests]}]
   (let [queue-max-capacity (max max-queued-requests 8)
@@ -106,7 +106,7 @@
 
 (defn- http-config
   ^HttpConfiguration
-  [{:s-exp.lido.http.server.http-config/keys
+  [{:s-exp.eddy.http.server.http-config/keys
     [output-buffer-size request-header-size response-header-size
      send-server-version? send-date-header?
      header-cache-size]}]
@@ -120,7 +120,7 @@
 
 (defn- ssl-context-factory
   ^SslContextFactory$Server
-  [{:s-exp.lido.ssl-context-factory/keys
+  [{:s-exp.eddy.ssl-context-factory/keys
     [keystore keystore-type key-password client-auth  truststore trust-password
      exclude-ciphers replace-exclude-ciphers? exclude-protocols
      replace-exclude-protocols? ssl-context]}]
@@ -166,7 +166,7 @@
 (defn- ^ServerConnector ssl-connector
   [^Server server
    {:as opts
-    :s-exp.lido.http.server.ssl-connector/keys [host port keystore-scan-interval
+    :s-exp.eddy.http.server.ssl-connector/keys [host port keystore-scan-interval
                                                 max-idle-time http2?]}]
   (let [http-cfg (http-config opts)
         http-factory (HttpConnectionFactory.
@@ -191,7 +191,7 @@
 
 (defn- http-connector
   ^ServerConnector
-  [server {:s-exp.lido.http.server.http-connector/keys [host port max-idle-time http2?]
+  [server {:s-exp.eddy.http.server.http-connector/keys [host port max-idle-time http2?]
            :as opts}]
   (let [http-cfg (http-config opts)
         connection-factories (cond-> [(HttpConnectionFactory. http-cfg)]
@@ -206,17 +206,17 @@
   ^Server
   [{:as opts}]
   (let [server (Server. (create-threadpool opts))]
-    (when (:s-exp.lido.http.server.http-connector/port opts)
+    (when (:s-exp.eddy.http.server.http-connector/port opts)
       (.addConnector server (http-connector server opts)))
-    (when (:s-exp.lido.http.server.ssl-connector/port opts)
+    (when (:s-exp.eddy.http.server.ssl-connector/port opts)
       (.addConnector server (ssl-connector server opts)))
     server))
 
 (defn start!
   ^Server
   [opts]
   (let [{:as opts
-         :s-exp.lido.http.server/keys [configurator join? handler]
+         :s-exp.eddy.http.server/keys [configurator join? handler]
          :or {handler handler}} (merge default-opts opts)
         server (create-server opts)]
     (.setHandler server (handler opts))

src/s_exp/lido/http/server/request.clj → src/s_exp/eddy/http/server/request.clj

@@ -1,5 +1,5 @@
-(ns s-exp.lido.http.server.request
-  (:require [s-exp.lido.utils :as u])
+(ns s-exp.eddy.http.server.request
+  (:require [s-exp.eddy.utils :as u])
   (:import (jakarta.servlet.http HttpServletRequest)
            (org.eclipse.jetty.server Request)
            (jakarta.servlet AsyncContext)))

src/s_exp/lido/http/server/response.clj → src/s_exp/eddy/http/server/response.clj

@@ -1,4 +1,4 @@
-(ns s-exp.lido.http.server.response
+(ns s-exp.eddy.http.server.response
   (:require [clojure.java.io :as io]
             [qbits.auspex :as ax])
   (:import (java.util.concurrent CompletableFuture)

src/s_exp/lido/utils.clj → src/s_exp/eddy/utils.clj

@@ -1,4 +1,4 @@
-(ns s-exp.lido.utils
+(ns s-exp.eddy.utils
   (:import
    (java.util Iterator Enumeration)
    (clojure.lang IReduceInit)))

test/s_exp/lido/test/server_test.clj → test/s_exp/eddy/test/server_test.clj

@@ -1,10 +1,10 @@
-(ns s-exp.lido.test.server-test
+(ns s-exp.eddy.test.server-test
   (:require [clojure.test :refer [deftest is]]
-            [s-exp.lido.http.server :as srv]
-            [s-exp.lido.http.server.response :as rsp]
-            [s-exp.lido.http.server.request :as req]
+            [s-exp.eddy.http.server :as srv]
+            [s-exp.eddy.http.server.response :as rsp]
+            [s-exp.eddy.http.server.request :as req]
             [clj-http.client :as http]
-            [s-exp.lido.http.interceptor.ring1 :as ring1]
+            [s-exp.eddy.http.interceptor.ring1 :as ring1]
             [qbits.auspex :as ax]))
 
 (def ^:dynamic *server* nil)
@@ -18,68 +18,68 @@
          (srv/stop! *server*)))))
 
 (deftest test-simple-get-req
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server.interceptor/ctx
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server.interceptor/ctx
                 {:ring1/handler (fn [request] {})}}
     (is (-> (http/get "http://localhost:8080") :status (= 200)) ))
 
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server.interceptor/ctx
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server.interceptor/ctx
                 {:ring1/handler (fn [request] {:status 200})}}
     (is (-> (http/get "http://localhost:8080") :status (= 200))))
 
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server.interceptor/ctx
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server.interceptor/ctx
                 {:ring1/handler (fn [request] {:status 200 :body "test"})}}
     (is (-> (http/get "http://localhost:8080") :status (= 200))))
 
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server.interceptor/ctx
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server.interceptor/ctx
                 {:ring1/handler (fn [request] {:status 201})}}
     (is (-> (http/get "http://localhost:8080") :status (= 201)))))
 
 (deftest test-simple-post-req
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server.interceptor/ctx
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server.interceptor/ctx
                 {:ring1/handler (fn [request] {})}}
     (is (-> (http/post "http://localhost:8080") :status (= 200)) ))
 
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server.interceptor/ctx
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server.interceptor/ctx
                 {:ring1/handler (fn [request] {:body (:body request)})}}
     (is (-> (http/post "http://localhost:8080"
                        {:body "something"})
             :body (= "something"))))
 
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server.interceptor/ctx
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server.interceptor/ctx
                 {:ring1/handler (fn [request] {:body (:body request)})}}
     (let [large-body (apply str (range 100000))]
       (is (-> (http/post "http://localhost:8080"
                          {:body large-body})
               :body (= large-body))))))
 
 (deftest async-test
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server.interceptor/chain ring1/async-chain
-                :s-exp.lido.http.server.interceptor/ctx
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server.interceptor/chain ring1/async-chain
+                :s-exp.eddy.http.server.interceptor/ctx
                 {:ring1/handler (fn [request] (ax/success-future {:status 200}))}}
     (is (-> (http/get "http://localhost:8080")
             :status (= 200))))
 
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server.interceptor/chain ring1/async-chain
-                :s-exp.lido.http.server.interceptor/ctx
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server.interceptor/chain ring1/async-chain
+                :s-exp.eddy.http.server.interceptor/ctx
                 {:ring1/handler (fn [request]
                                   (ax/success-future {:status 201 :body "test"}))}}
     (is (-> (http/get "http://localhost:8080")
             :status (= 201)))
     (is (-> (http/get "http://localhost:8080")
             :body (= "test"))))
 
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server.interceptor/chain ring1/async-chain
-                :s-exp.lido.http.server.interceptor/ctx
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server.interceptor/chain ring1/async-chain
+                :s-exp.eddy.http.server.interceptor/ctx
                 {:ring1/handler (fn [request]
                                   (ax/success-future {:status 201
                                                       :body (ax/success-future "test async body")}))}}
@@ -89,8 +89,8 @@
             :body (= "test async body")))))
 
 (deftest fast-test
-  (with-server {:s-exp.lido.http.server/join? false
-                :s-exp.lido.http.server/handler
+  (with-server {:s-exp.eddy.http.server/join? false
+                :s-exp.eddy.http.server/handler
                 (fn [opts]
                   (srv/create-handler
                    (fn [_ s-request s-response]