fixup! fixup! fixup! fixup! fixup! fixup! fixup! websockets init

src/s_exp/mina.clj

@@ -1,6 +1,7 @@
 (ns s-exp.mina
   (:require [s-exp.mina.http.routing]
             [s-exp.mina.options :as options]
+            [s-exp.mina.websocket]
             [s-exp.mina.websocket.routing])
   (:import (io.helidon.webserver WebServer WebServerConfig WebServerConfig$Builder)))
 
@@ -55,11 +56,11 @@
 ;; (require 's-exp.mina.websocket)
 ;; (stop! s)
 ;; (do
-;;   (stop! s)
+;;   (when (resolve 's) (eval `(stop! s)))
 ;;   (def s (start!
 ;;           {:host "0.0.0.0" :port 8080
 ;;            :websocket-endpoints {"/foo"
-;;                                  {:subprotocols ["chat"]
+;;                                  {;; :subprotocols ["chat"]
 ;;                                   :error (fn [session e]
 ;;                                            (prn :err e))
 ;;                                   :ping (fn [session data]
@@ -87,18 +88,19 @@
 ;;                                              (s-exp.mina.websocket/send! session data true))}}
 ;;            :write-queue-length 10240
 ;;            :connection-options {:socket-send-buffer-size 1024}})))
+
 ;; (require '[gniazdo.core :as ws])
 
+;; (when (resolve 'socket) (eval `(ws/close socket)))
 ;; (def socket
 ;;   (ws/connect
 ;;    "ws://localhost:8080/foo"
 ;;    :on-receive #(prn 'received %)
-;;    :subprotocols ["chat"]))
-
+;;    ;; :headers {"foo" "bar"}
+;;    ;; :subprotocols ["chat, foo"]
+;;    ))
 ;; (ws/send-msg socket "hello")
 
-;; (ws/send-msg socket (.getBytes "hello"))
-
 ;; (ws/close socket)
 
 ;; https://api.github.com/repos/mpenet/mina/commits/main?per_page=1

src/s_exp/mina/http/header.clj

@@ -0,0 +1,146 @@
+(ns s-exp.mina.http.header
+  (:import (clojure.lang
+            IEditableCollection
+            IFn
+            IKVReduce
+            IPersistentMap
+            MapEntry
+            MapEquivalence
+            Util)
+           (io.helidon.http
+            Headers
+            Header
+            HeaderName
+            HeaderNames
+            HeaderValues)
+           (java.util Map)))
+
+(defn header-name ^HeaderName
+  [s]
+  (HeaderNames/createFromLowercase s))
+
+(defn header->value*
+  ([^Headers header header-name]
+   (header->value* header header-name nil))
+  ([^Headers header
+    ^HeaderName header-name not-found]
+   (-> header
+       (.value header-name)
+       (.orElse not-found))))
+
+(defn header->value
+  ([^Headers h k]
+   (header->value h k nil))
+  ([^Headers h k not-found]
+   (header->value* h
+                   (header-name k)
+                   not-found)))
+
+(defn kv->header [^HeaderName header-name ^String v]
+  (HeaderValues/create header-name v))
+
+(defn ring-headers*
+  [^Headers headers]
+  (-> (reduce (fn [m ^Header h]
+                (assoc! m
+                        (.lowerCase (.headerName h))
+                        (.value h)))
+              (transient {})
+              headers)
+      persistent!))
+
+(defprotocol RingHeaders
+  (^clojure.lang.APersistentMap ring-headers [_]))
+
+;; inspired by ring-undertow
+(deftype HeaderMapProxy [^Headers headers
+                         ^:volatile-mutable persistent-copy]
+  Map
+  (size [_]
+    (.size headers))
+
+  (get [_ k]
+    (header->value headers k))
+
+  MapEquivalence
+
+  IFn
+  (invoke [_ k]
+    (header->value headers k))
+
+  (invoke [_this k not-found]
+    (header->value headers k not-found))
+
+  IPersistentMap
+  (valAt [_ k]
+    (header->value headers k))
+
+  (valAt [_ k not-found]
+    (header->value headers k not-found))
+
+  (entryAt [_ k]
+    (let [hn (header-name k)]
+      (when-let [v (header->value* headers hn)]
+        (MapEntry. (.lowerCase hn) v))))
+
+  (containsKey [_ k]
+    (.contains headers (header-name k)))
+
+  (assoc [this k v]
+    (-> (ring-headers this)
+        (.assoc k v)))
+
+  (assocEx [this k v]
+    (if (.containsKey this k)
+      (throw (Util/runtimeException "Key already present"))
+      (.assoc this k v)))
+
+  (cons [this o]
+    (-> (ring-headers this)
+        (.cons o)))
+
+  (without [this k]
+    (-> (ring-headers this)
+        (.without k)))
+
+  (empty [_]
+    {})
+
+  (count [_]
+    (.size headers))
+
+  (seq [this]
+    (.seq (ring-headers this)))
+
+  (equiv [this o]
+    (= o (ring-headers this)))
+
+  (iterator [_]
+    (->> headers
+         (eduction (map (fn [^Header header]
+                          (MapEntry. (.lowerCase (.headerName header))
+                                     (.value header)))))
+         .iterator))
+
+  IKVReduce
+  (kvreduce [this f init]
+    (.kvreduce ^IKVReduce
+     (ring-headers this)
+               f
+               init))
+
+  IEditableCollection
+  (asTransient [this]
+    (transient (ring-headers this)))
+
+  RingHeaders
+  (ring-headers
+    [_]
+    (or persistent-copy
+        (set! persistent-copy (ring-headers* headers))))
+
+  Object
+  (toString [_]
+    (.toString headers)))
+
+