Clojurians Log v2

I'm studying this and should contribute soon. Given your router

...
(conn/with-routes
                 #{["/" :get index-handler]
                     ...})

#{["/" :get index-handler]
    ["/ws" :get (websocket/websocket-interceptor ::ws ws-map)]
    ....}

(def ws-map
   {:on-open (fn [channel ring-request] (websocket/start-ws-connection channel nil))
   :on-text (fn [channel proc text] ...)
    :on-close (fn [channel proc reason] ...)})

I would be very happy to receive your feedback on whether it worked or not 😄

Thank you, I will try it this week and let you know. Is there an easy way to tag the channels with a session id?

ok I worked! a few questions though: • To reply to a client shouldn't I just use the channel in the :on-text ? with (io.pedestal.service.websocket/send-text! channel "some text") ? • Also should I be keeping proc or channel in the my atom of all opened connections? • Also it seems from the code (forgive me my clojure is a little rusty) that you are keeping channels in your atom even when they are closed, won't the atom just grow with the number of connections and interactions with the server?

Also I have no clue how to go about setting up sessions properly 😕

answering: > Is there an easy way to tag the channels with a session id? > Also it seems from the code (forgive me my clojure is a little rusty) that you are keeping channels in your atom even when they are closed, won't the atom just grow with the number of connections and interactions with the server?

(defonce *ws-sessions
  (atom {}))

(defn on-open
  [channel ring-request]
  (let [;; get the "session id" as-if you were in a normal handler.
        session-id (-> ring-request
                     :headers
                     (get "Cookies")
                     cookie->session-id)
        proc (websocket/start-ws-connection channel nil)]
    (swap! *ws-sessions assoc
      session-id {:proc    proc
                  :channel channel})
    proc))

(defn on-close
  [channel proc reason]
  (swap! *ws-sessions
    (fn [ws-sessions]
      (let [;; it might exists a smarter way to cleanup
            session-id (some (fn [[id v]]
                               (when (identical? channel (:channel v))
                                 id))
                         ws-sessions)]
        (when-not session-id
          (log/warn "cant find closing session" channel))
        (dissoc ws-sessions session-id)))))

(defn notify-all!
  []
  (doseq [{:keys [channel]} (vals @*ws-sessions)]
    ;; both are equivalent. All clients will receive both messages
    (websocket/send-text! channel "Hello")
    (async/>!! channel "World")))

Depending on your application, you may not need a "global registry". But operations like "broadcast" won't be possible to implement.

(defn on-open
  [channel ring-request]
  (websocket/start-ws-connection channel nil))
;; a simple implementation that do not require atom or anything global
(defn on-text
  [channel proc text]
  (websocket/send-text! channel (string/upper-case text)))

@hlship If you can, take a look at my examples. I'm also studying and I'm not sure about everything I've said.