Clojure WebSocket Client

Question

I have set up a WebSocket server using http-kit that should accept web socket connections. It is the basic example shown in the http-kit documentation.

The quest

Answer 1

aleph has support for websockets on both server and client. It can take some time to get used to the asynchronous style and aleph's core abstractions, but it's a very good tool once you get the hang of it.

Answer 2

http-kit's client does not support WebSocket yet(I can't think of a good API for it). Aleph is a good option for this kind of use case. Another option is http.async.client, I've used it in http-kit's server's websocket unit test: here

Answer 3

I built a basic websocket client and server, it uses java sockets and wraps websocket frames. It's unique in that the server can accept both regular socket connections as well as websockets, simultaneously.

http://github.com/viperscape/gulfstream

Example client code:

(def clienthandler
  (with-conn server
    (send! server "i'm here!")
    (with-data server data (prn "client received" data))
    (prn "client is now disconnected")))

(def ws-conn-details {:host "ws://echo.websocket.org/chat",:handler clienthandler})

(def client-conn (start-client ws-conn-details))

Answer 4

Gniazdo is a WebSocket client for Clojure. It wraps the Jetty's implementation of the protocol.

Answer 5

For those joining us in 2015: being new to this, I just spent a while trying out all the different options available, and it was pretty difficult to find a library that provides an easy way to set up a simple Clojure WebSocket client. (To be fair, it seems like it's not very common for a WebSocket client to be running in a non-browser/JavaScript context, which is why there seems to be so much emphasis on ClojureScript WebSocket clients.)

Although it is not well-documented, http.async.client ended up being the path of least resistance for me. I was able to successfully read streaming data from a WebSocket server and print it to the console by doing this:

(ns example.core
  (:require [http.async.client :as async]))

(def url "ws://localhost:1337")

(defn on-open [ws]
  (println "Connected to WebSocket."))

(defn on-close [ws code reason]
  (println "Connection to WebSocket closed.\n"
           (format "(Code %s, reason: %s)" code reason)))

(defn on-error [ws e]
  (println "ERROR:" e))

(defn handle-message [ws msg]
  (prn "got message:" msg))

(defn -main []
  (println "Connecting...")
  (-> (async/create-client)
      (async/websocket url
                       :open  on-open
                       :close on-close
                       :error on-error
                       :text  handle-message
                       :byte  handle-message))
  ;; Avoid exiting until the process is interrupted.
  (while true))

The infinite loop at the end is just to keep the process from ending. Until I press Ctrl-C, messages received from the socket are printed to STDOUT.

Answer 6

According to this announcement, http-kit has support for web sockets. If you're not bound to the asynchronous facilities that http-kit client offer, you could also use clj-http. They have a very similar interface, it seems (I have use but clj-http yet).

---

(ns playground.experiments.ws
  (:use aleph.http lamina.core))

(defn ws-client [] (websocket-client {:url "ws://echo.websocket.org:80"}))

(defn echo [message]
  (let [channel (wait-for-result (ws-client) 500)]
    (enqueue channel message)
      (let [echo (wait-for-result (read-channel channel) 500)]
        (close channel)
        echo)))

(echo "Echo me!")