Howto enable Fulcro Websockets - websocket

I have a basic question about how to get started with Fulcro and Websockets.
i) I started with the Fulcro lein template. ii) Then added the websocket client and server bits. iii) In my server, I also added a com.fulcrologic.fulcro.networking.websocket-protocols.WSListener to detect when a WS client is connecting.
Between the WSListener, and the browser's network console, I can see that the client is never making a WS connection.
How does Fulcro make the initial WS connection?
After that, how can I make server pushes to client?
client.cljs
(ns foo.client
(:require [fulcro.client :as fc]
[foo.ui.root :as root]
[fulcro.client.network :as net]
[fulcro.client.data-fetch :as df]
[com.fulcrologic.fulcro.networking.websockets :as fws]
[com.fulcrologic.fulcro.application :as app]))
;; Neither this nor the below ":websocket (fws/fulcro-websocket-remote {})" works
;; (defonce app (app/fulcro-app {:remotes {:remote (fws/fulcro-websocket-remote {})}}))
(defonce SPA (atom nil))
(defn mount [] (reset! SPA (fc/mount #SPA root/Root "app")))
(defn start [] (mount))
(def secured-request-middleware
;; The CSRF token is embedded via server_components/html.clj
(->
(net/wrap-csrf-token (or js/fulcro_network_csrf_token "TOKEN-NOT-IN-HTML!"))
(net/wrap-fulcro-request)))
(defn ^:export init []
(reset! SPA (fc/make-fulcro-client
{:client-did-mount (fn [foo]
(df/load foo :all-users root/User))
;; This ensures your client can talk to a CSRF-protected server.
;; See middleware.clj to see how the token is embedded into the HTML
:networking {:remote (net/fulcro-http-remote
{:url "/api"
:request-middleware secured-request-middleware})
:websocket (fws/fulcro-websocket-remote {})}}))
(start))
middleware.cljs
(defrecord FooWSListener []
WSListener
(client-added [this ws-net cid]
(println (str "Listener for dealing with client added events." [ws-net cid])))
(client-dropped [this ws-net cid]
(println (str "listener for dealing with client dropped events." [ws-net cid]))))
(def foo-ws-listener (->FooWSListener))
(def websockets' (atom nil))
(defn query-parser [env query] )
(defstate middleware
:start
(let [websockets (fws/start! (fws/make-websockets
query-parser
{:http-server-adapter (get-sch-adapter)
:parser-accepts-env? true
;; See Sente for CSRF instructions
:sente-options {:csrf-token-fn nil}}))
defaults-config (:ring.middleware/defaults-config config)
legal-origins (get config :legal-origins #{"localhost"})]
(fwsp/add-listener websockets foo-ws-listener)
(reset! websockets' websockets)
(-> not-found-handler
(wrap-api "/api")
(fws/wrap-api websockets)
server/wrap-transit-params
server/wrap-transit-response
(wrap-html-routes)
(wrap-defaults defaults-config)
wrap-gzip)))

Since fulcro-websockets 3.1.0 the websocket connection is made on the first data transfer via websocket remote.
If you want to force the connection, you can do that by sending any mutation over the remote:
(:require [com.fulcrologic.fulcro.mutations :refer [defmutation]
[com.fulcrologic.fulcro.components :as comp])
(defmutation connect-socket [_]
(websocket [_] true))
(comment
;; trigger it via repl or a button handler
(comp/transact! foo.client/SPA `[(connect-socket {})]
Once you make a connection, you can make a push from server like this:
(:require [com.fulcrologic.fulcro.networking.websocket-protocols :refer [push]])
(let [client-uid (-> #(:connected-uids websockets')
:any
first)]
(push websockets' client-uid :foo-topic {:foo "bar"}))
To receive that on the client, you're going to need a :push-handler defined on the websocket remote:
(defn push-handler [{:keys [topic msg] :as data}]
(log/info "push-handler received: " data))
;; optionally you can listen for websocket state changes
(defn state-callback [before after]
(log/info "state-callback: " {:before before
:after after}))
(defn ^:export init []
(reset! SPA (fc/make-fulcro-client
{:client-did-mount (fn [foo]
(df/load foo :all-users root/User))
:remotes {:remote (net/fulcro-http-remote
{:url "/api"
:request-middleware secured-request-middleware})
:websocket (fws/fulcro-websocket-remote
{:push-handler push-handler
:state-callback state-callback})}}))
(start))
BTW since you're using template provided mount, you can use it to handle websockets' on the server:
(defstate websockets'
:start
(fws/start! (fws/make-websockets
query-parser
{:http-server-adapter (get-sch-adapter)
:parser-accepts-env? true})))
This way you can avoid this line: (reset! websockets' websockets)

Related

Non-stop requests over sente web-socket channel for what should be a single request

The goal is to allow someone to update the status of an online exam in real time. (IE. Pressing Activate Charlie's exam, changes Charlies screen to allow him to start taking his exam. The relationship between the proctor is one proctor to many exams.
Currently we're getting the exam activated using sente successfully, but once we click the (activate exam) button, it continues to send requests over the route "/chsk" over and over again. (To sente's credit, it is very fast.) It sends many (10+) of these requests successfully before hitting the following error. We thought the problem would be in the middleware, but after adjusting wrap-formats to handle websocket requests (and requests sent over the "/chsk" route, we're still getting the error.
I don't think the problem really lies with the middleware, because the info comes through just fine the first time and activates the exam as expected. I don't know why sente is sending more than a single request at all. sente is working for our purposes, but we need to stop all these extra requests somehow or my machine/internet gets way bogged down.
How can we make sure a request is sent only once from the backend?
(THE PROBLEM)
I was able to freeze it as soon as I activated the exam to show that the web-socket did indeed do what we wanted it to do.
Immediately after endless requests are made and the browser crashes soon after.
Error in the REPL
(CLIENT SIDE)
(ns flats.web-sockets
(:require [goog.string :as gstring]
[flats.shared :as shared]
[reagent.core :as r]
[re-frame.core :as rfc]
[taoensso.encore :as encore :refer-macros (have)]
[taoensso.sente :as sente]
[taoensso.timbre :as log :refer-macros (tracef)]))
(def ?csrf-token
(when-let [el (.getElementById js/document "token")]
(.getAttribute el "value")))
(def -chsk (r/atom nil))
(def -ch-chsk (r/atom nil))
(def -chsk-send! (r/atom nil))
(def -chsk-state (r/atom nil))
(defn sente-setup
"Takes uid (exam-id, registration-id, user-id?) to use as unique client-id"
[uid]
(let [{:keys [chsk ch-recv send-fn state]}
(sente/make-channel-socket-client! "/chsk" ; Note the same path as before
?csrf-token
{:type :auto ; e/o #{:auto :ajax :ws}
:client-id uid})]
(reset! -chsk chsk)
(reset! -ch-chsk ch-recv) ; ChannelSocket's receive channel
(reset! -chsk-send! send-fn) ; ChannelSocket's send API fn
(reset! -chsk-state state) ; Watchable, read-only atom
))
(defmulti -event-msg-handler
"Multimethod to handle Sente `event-msg`s"
:id ; Dispatch on event-id
)
(defn event-msg-handler
"Wraps `-event-msg-handler` with logging, error catching, etc."
[{:as ev-msg :keys [_id _?data _event]}]
#_(log/info (str "\nin event-msg-handler: "ev-msg))
(-event-msg-handler ev-msg))
(defmethod -event-msg-handler
:default ; Default/fallback case (no other matching handler)
[{:as _ev-msg :keys [event]}]
(tracef "Unhandled event: %s" event))
(defmethod -event-msg-handler :chsk/state
[{:as _ev-msg :keys [?data]}]
#_(log/info "In chsk/state "_ev-msg)
(let [[_old-state-map new-state-map] (have vector? ?data)]
(if (:first-open? new-state-map)
(tracef "Channel socket successfully established!: %s" new-state-map)
(tracef "Channel socket state change: %s" new-state-map))))
(defmethod -event-msg-handler :chsk/recv
[{:as _ev-msg
:keys [_?data]
[event-id {:keys [exam-status]}]
:?data}]
(log/info (str ":chsk/recv payload: " _ev-msg))
(when (= event-id :exam/status)
(rfc/dispatch [:set-current-exam-status exam-status])))
(defmethod -event-msg-handler :chsk/handshake
[{:as _ev-msg :keys [?data]}]
(let [[_?uid _?csrf-token _?handshake-data] ?data]
(tracef "Handshake: %s" ?data)))
;;;; Sente event router (our `event-msg-handler` loop)
(defonce router_ (atom nil))
(defn stop-router! [] (when-let [stop-f #router_] (stop-f)))
(defn start-router! []
(stop-router!)
(reset! router_
(sente/start-client-chsk-router!
#-ch-chsk event-msg-handler)))
(SERVER SIDE)
(ns flats.web-sockets
(:require [taoensso.timbre :as log]
[taoensso.sente :as sente]
[clojure.core.async :as async :refer [<!!]]
[taoensso.sente.server-adapters.immutant :refer (get-sch-adapter)])
(:import [java.util UUID]))
(def user-id (atom nil))
(let [chsk-server (sente/make-channel-socket-server!
(get-sch-adapter)
{:packer :edn
:user-id-fn (fn [request]
(reset! user-id (:client-id request))
(UUID/fromString (:client-id request))
#_(:client-id request)
)})
{:keys [ch-recv send-fn connected-uids
ajax-post-fn ajax-get-or-ws-handshake-fn]} chsk-server]
(def ring-ajax-post ajax-post-fn)
(def ring-ajax-get-or-ws-handshake ajax-get-or-ws-handshake-fn)
(def ch-chsk ch-recv) ; ChannelSocket's receive channel
(def chsk-send! send-fn) ; ChannelSocket's send API fn
(def connected-uids connected-uids) ; Watchable, read-only atom
)
;;;; Server>user async push
(defn broadcast!
[registration-id exam-status]
(chsk-send! registration-id
[:exam/status {:exam-status exam-status}]
5000))
(ACTIVATING THE EXAM)
(defn create-exam-action
"Creates a new `exam_action` with the given `exam-id` and the `action-type`"
[{{:keys [exam-id action-type]} :path-params}]
(let [exam-id (UUID/fromString exam-id)
registration-id (dbx/READ exam-id [:registration-id])]
(exams/create-exam-action exam-id action-type)
(ws/broadcast! registration-id action-type)
(http-response/ok action-type)))
(ROUTES)
["/chsk" {:get ws/ring-ajax-get-or-ws-handshake
:post ws/ring-ajax-post}]
*Note: We start the Client side router once an exam is registered, and use the exam's id as the user-id for the front end channel.
Turns out that start-router! and sente-setup functions were being called more than once. So we added a reframe flag so be set once sente had connected, and then chsk-send! sent the requests from the BE only once. A similar idea would be to make the function calls a singleton so if a session had already been started for the exam it shouldn't call the start router again.

Invalid event "~#chsk/handshake" when using sente packers.transit/get-transit-packer in clojure

I am getting an error when using sente that results in failure while sending information from client to server or vice versa. The problem seems to be that the handshake fails with an error
cljs$core$ExceptionInfo
message: "Invalid event"
data: {:given "~:chsk/handshake", :errors {:wrong-type {…}}}
The successive ws/ping also fail with the same error but with extra information,
sente.cljc:142 Uncaught #error {:message "Invalid event", :data {:given "~#'", :errors {:wrong-type
{…}[:expected :vector]
[:actual {:type #object[String], :value "~#'"}]
What might be the problem, my code seems okay and follows the default example in sente.
Expected behaviour:
Sente would connect and i would be able to call send-fn and send messages between the server and client, successfully.
Edit: Addition of code as suggested in the comments:
(require '[taoensso.sente.server-adapters.aleph :refer (get-sch-adapter)])
;; Create Websocket connection in server
(let [packer (sente-transit/get-transit-packer)
chsk-server (sente/make-channel-socket-server! (get-sch-adapter) {:packer packer
:csrf-token-fn nil})
{:keys [ch-recv send-fn connected-uids ajax-post-fn ajax-get-or-ws-handshake-fn]} chsk-server]
(def ring-ajax-post ajax-post-fn)
(def ring-ajax-get-or-ws-handshake ajax-get-or-ws-handshake-fn)
(def ch-chsk ch-recv)
(def chsk-send! send-fn)
(def connected-uids connected-uids))
;; Start the web server
(defn start-web-server! [& [port]]
(stop-web-server!)
(let [port (or port default-port)
ring-handler (var main-ring-handler)
[port stop-fn]
(let [server (aleph/start-server ring-handler {:port port})
p (promise)]
(future #p)
[(aleph.netty/port server)
(fn [] (.close ^Closeable server) (deliver p nil))])
uri (format "http://localhost:%s/" port)]
(infof "Web server is running at `%s`" uri)
(reset! web-server_ {:port port :stop-fn stop-fn})
(try
(if (and (Desktop/isDesktopSupported)
(.isSupported (Desktop/getDesktop) Desktop$Action/BROWSE))
(.browse (Desktop/getDesktop) (URI. uri))
(.exec (Runtime/getRuntime) (str "xdg-open" uri)))
(Thread/sleep 7500)
(catch HeadlessException _))))
On the client side:
(let [packer (sente-transit/get-transit-packer)
{:keys [chsk ch-recv send-fn state]}
(sente/make-channel-socket-client! "/chsk"
{:type :auto
:packer packer})]
(def chsk chsk)
(def ch-chsk ch-recv)
(def chsk-send! send-fn)
(def chsk-state state))
;; start the router
(defn start-router! []
(stop-router!)
(reset! router_ (sente/start-client-chsk-router! ch-chsk event-msg-handler)))
EDIT, Addition
I have noted that the error only exists when i use the packer, (packers.transit/get-transit-packer) and not :edn
Ran into this issue today coincidentally, so after this issue I was scratching my head a bit, could it be the library which hasn't seen much activity/is stable?
Nope. I simply forgot to include the [com.cognitect/transit-cljs "0.8.256"] cljs dependency!
The example did warn:
https://github.com/ptaoussanis/sente/blob/master/example-project/src/example/client.cljs#L47
Not exactly an answer, but we gotta see your code for that.
The error "Invalid event" is generated here:
(defn validate-event
"Returns nil if given argument is a valid [ev-id ?ev-data] form. Otherwise
returns a map of validation errors like `{:wrong-type {:expected _ :actual _}}`."
[x]
(cond
(not (vector? x)) {:wrong-type (expected :vector x)}
(not (#{1 2} (count x))) {:wrong-length (expected #{1 2} x)}
:else
(let [[ev-id _] x]
(cond
(not (keyword? ev-id)) {:wrong-id-type (expected :keyword ev-id)}
(not (namespace ev-id)) {:unnamespaced-id (expected :namespaced-keyword ev-id)}
:else nil))))
```

Clojurescript Websockets with Sente 403 Error

I'm attempting to setup a web socket connection from two different ports on my localhost. I'm using Sente and Immutant. I have the following, but it returns a 403 forbidden when attempting to connect
Server.clj
(defn handler
"Comment"
[]
"<h1>Hello World</h1>")
(let [{:keys [ch-recv send-fn connected-uids
ajax-post-fn ajax-get-or-ws-handshake-fn]}
(sente/make-channel-socket! (get-sch-adapter) {})]
(def ring-ajax-post ajax-post-fn)
(def ring-ajax-get-or-ws-handshake ajax-get-or-ws-handshake-fn)
(def ch-chsk ch-recv) ; ChannelSocket's receive channel
(def chsk-send! send-fn) ; ChannelSocket's send API fn
(def connected-uids connected-uids) ; Watchable, read-only atom
)
(defroutes app
"The router."
(GET "/" [] (handler))
(GET "/chsk" req (ring-ajax-get-or-ws-handshake req))
(POST "/chsk" req (ring-ajax-post req))
(route/not-found
"<h1>Page not found</h1>"))
(def my-app
(-> app
;; Add necessary Ring middleware:
ring.middleware.keyword-params/wrap-keyword-params
ring.middleware.params/wrap-params))
(def wrapped
(wrap-cors my-app :access-control-allow-origin [#".*"]
:access-control-allow-methods [:get :put :post :delete]))
(defn -main
"Start the server"
[& args]
(immutant/run wrapped {:host "localhost" :port 8080 :path "/"}))
This throws no errors, and the "/" route properly displays.
Client.cljs
(let [{:keys [chsk ch-recv send-fn state]}
(sente/make-channel-socket! "/chsk" ; Note the same path as before
"sdasds" ; dummy
{:type :auto ; e/o #{:auto :ajax :ws}
:host "localhost:8080/"
}
)]
(def chsk chsk)
(def ch-chsk ch-recv) ; ChannelSocket's receive channel
(def chsk-send! send-fn) ; ChannelSocket's send API fn
(def chsk-state state) ; Watchable, read-only atom
)
This throws 403 errors as it tries to connect. I'm not sure why it's doing so, I've been looking at it for a while and have come up short.
I believe this is the issue with CSRF anti-forgery:
Sente docs:
This is important. Sente has support, but you'll need to use middleware like ring-anti-forgery to generate and check CSRF codes. The ring-ajax-post handler should be covered (i.e. protected).
In Sente official example they show how to setup it properly.

Why is username not saved in noir session in Clojure project?

This is how I save it during login:
(defn set-loggedin [username]
(sesh/put! :username username))
(defn login-handler [username password]
(let [user (datab/login username password)]
(if (empty? user)
(view/login-form "Wrong password.")
(do
(set-loggedin username)
(resp/redirect "/movies")))))
(defroutes app-routes
...
(POST "/" [username password] (login-handler username password))
(POST "/movie/save" [movieID name] (film-new movieID name))
...)
(def app
(noir-middleware/app-handler
[app-routes]
:ring-defaults (assoc-in site-defaults [:security :anti-forgery] false)))
When I show the username on the form after the login, it shows it, but when I try to save the movie (movie table has a column username) and get the username it is nil.
(defn film-new [movieID name]
(datab/filmnew movieID name (sesh/get :username))
(resp/redirect "/movies")
)
Am i wrapping the session wrong? I don't get it. I have also tried to wrap it like this
def app (sesh/wrap-noir-session*
(noir-middleware/app-handler [app-routes]
:ring-defaults (assoc-in site-defaults [:security :anti-forgery]
false))))
EDIT: libnoir is now officially deprecated. Start here.
This is a minimal example to show that libnoir's stateful session works out of the box:
(ns ln.core
(:require
[compojure.core :refer [defroutes GET]]
[noir.session :as session]
[noir.util.middleware :as middleware]
[ring.adapter.jetty :refer [run-jetty]]))
(defroutes app-routes
(GET "/foo" []
(session/update-in! [:foo] not)
"Now go to /bar")
(GET "/bar" []
"foo was" (str (session/get :foo))))
(def app
(middleware/app-handler
[app-routes]))
(defonce server (atom nil))
(defn stop-server []
(when-let [s #server]
(.stop s)))
(defn dev []
(stop-server)
(reset! server (run-jetty app {:port 8888
:join? false})))
;;;; Scratch
(comment
(dev)
)
If you could provide a minimal reproduction to show that your code is NOT working as expected, we could help you further. Having said that, libnoir looks a bit abandoned to me. You might be better of starting with vanilla Ring.

Compojure trouble displaying an image

I've been struggling with this for over two days now and don't seem to find a solution.
So all I am trying to do is to display an image in the browser, but when I am calling the endpoint this is what happens:
Cannot JSON encode object of class: class java.io.File
Endpoint
(context "/servers" []
:datomic true
(GET "/:id/graph/:panel-type" {db :db user :user}
:summary "Return a server graph image"
:path-params [id :- Long
panel-type :- String]
(let [file-path (str panel-type ".png")
result (-> (response/response (clojure.java.io/file file-path))
(response/content-type "image/png")))]
(ok result)))) ;; ring.util.http-response
I am new to compojure API, but something makes me think there is a problem with middleware implementation - custom formats?
Middleware
(defn wrap-formats [handler]
(let [wrapped (wrap-restful-format
handler
{:formats [:json-kw :transit-json :transit-msgpack]})]
(fn [request]
;; disable wrap-formats for websockets
;; since they're not compatible with this middleware
((if (:websocket? request) handler wrapped) request))))
Stacktrace
com.fasterxml.jackson.core.JsonGenerationException: Cannot JSON encode object of class: class java.io.File: cpu.png
at cheshire.generate$generate.invokeStatic(generate.clj:152)
at cheshire.generate$generate.invoke(generate.clj:116)
at cheshire.generate$generate.invokeStatic(generate.clj:122)
at cheshire.generate$generate.invoke(generate.clj:116)
at cheshire.core$generate_string.invokeStatic(core.clj:74)
at cheshire.core$generate_string.invoke(core.clj:49)
at ring.middleware.format_response$make_json_encoder$fn__20198.invoke(format_response.clj:221)
at ring.middleware.format_response$wrap_format_response$fn__20186.invoke(format_response.clj:204)
at ring.middleware.keyword_params$wrap_keyword_params$fn__4302.invoke(keyword_params.clj:36)
at ring.middleware.nested_params$wrap_nested_params$fn__20350.invoke(nested_params.clj:89)
at ring.middleware.params$wrap_params$fn__4376.invoke(params.clj:67)
at compojure.api.middleware$wrap_options$fn__23551.invoke(middleware.clj:74)
at compojure.api.routes.Route.invoke(routes.clj:74)
at clojure.lang.Var.invoke(Var.java:381)
at compojure.core$routing$fn__4157.invoke(core.clj:185)
at clojure.core$some.invokeStatic(core.clj:2674)
at clojure.core$some.invoke(core.clj:2665)
at compojure.core$routing.invokeStatic(core.clj:185)
at compojure.core$routing.doInvoke(core.clj:182)
at clojure.lang.RestFn.applyTo(RestFn.java:139)
at clojure.core$apply.invokeStatic(core.clj:659)
at clojure.core$apply.invoke(core.clj:652)
at compojure.core$routes$fn__4161.invoke(core.clj:192)
at clojure.lang.Var.invoke(Var.java:381)
at ring.middleware.reload$wrap_reload$fn__46696.invoke(reload.clj:39)
at selmer.middleware$wrap_error_page$fn__46709.invoke(middleware.clj:9)
at prone.middleware$wrap_exceptions$fn__46879.invoke(middleware.clj:126)
at buddy.auth.middleware$wrap_authentication$fn__44919.invoke(middleware.clj:42)
at buddy.auth.middleware$wrap_authorization$fn__44927.invoke(middleware.clj:94)
at ring.middleware.cors$handle_cors.invokeStatic(cors.clj:146)
at ring.middleware.cors$handle_cors.invoke(cors.clj:135)
at ring.middleware.cors$wrap_cors$fn__45217.invoke(cors.clj:160)
at ring.middleware.flash$wrap_flash$fn__45283.invoke(flash.clj:39)
at ring.middleware.session$wrap_session$fn__45465.invoke(session.clj:108)
at ring.middleware.keyword_params$wrap_keyword_params$fn__4302.invoke(keyword_params.clj:36)
at ring.middleware.nested_params$wrap_nested_params$fn__20350.invoke(nested_params.clj:89)
at ring.middleware.multipart_params$wrap_multipart_params$fn__45551.invoke(multipart_params.clj:172)
at ring.middleware.params$wrap_params$fn__4376.invoke(params.clj:67)
at ring.middleware.cookies$wrap_cookies$fn__45416.invoke(cookies.clj:175)
at ring.middleware.absolute_redirects$wrap_absolute_redirects$fn__45638.invoke(absolute_redirects.clj:47)
at ring.middleware.resource$wrap_resource$fn__45567.invoke(resource.clj:37)
at ring.middleware.content_type$wrap_content_type$fn__25387.invoke(content_type.clj:34)
at ring.middleware.default_charset$wrap_default_charset$fn__45610.invoke(default_charset.clj:31)
at ring.middleware.not_modified$wrap_not_modified$fn__25417.invoke(not_modified.clj:53)
at ring.middleware.x_headers$wrap_x_header$fn__45246.invoke(x_headers.clj:22)
at ring.middleware.x_headers$wrap_x_header$fn__45246.invoke(x_headers.clj:22)
at ring.middleware.x_headers$wrap_x_header$fn__45246.invoke(x_headers.clj:22)
at voltage.middleware$wrap_bearer_token$fn__46930.invoke(middleware.clj:72)
at ring.middleware.webjars$wrap_webjars$fn__45738.invoke(webjars.clj:40)
at voltage.middleware$wrap_internal_error$fn__46919.invoke(middleware.clj:37)
at immutant.web.internal.undertow$create_http_handler$reify__57634.handleRequest(undertow.clj:239)
at org.projectodd.wunderboss.web.undertow.async.websocket.UndertowWebsocket$2.handleRequest(UndertowWebsocket.java:107)
at io.undertow.server.session.SessionAttachmentHandler.handleRequest(SessionAttachmentHandler.java:68)
at io.undertow.server.Connectors.executeRootHandler(Connectors.java:202)
at io.undertow.server.HttpServerExchange$1.run(HttpServerExchange.java:802)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
at java.lang.Thread.run(Thread.java:745)
Any clue on the above is highly appreciated.
The problem is that you're calling both ring.util.response/response and ring.util.http-response/ok:
(ok (ring.util.response/response "foo"))
=> {:status 200, :headers {}, :body {:status 200, :headers {}, :body "foo"}}
Using either of them separately works:
(ns compojure.api.examples.handler
(:require [clojure.java.io :as io]
[compojure.api.sweet :refer :all]
[ring.middleware.format :refer [wrap-restful-format]]
[ring.util.http-response :refer :all]
[ring.util.response :as response]
[compojure.api.examples.domain :refer :all]
[schema.core :as s]))
(defn wrap-formats [handler]
(let [wrapped (wrap-restful-format
handler
{:formats [:json-kw :transit-json :transit-msgpack]})]
(fn [request]
;; disable wrap-formats for websockets
;; since they're not compatible with this middleware
((if (:websocket? request) handler wrapped) request))))
(def app
(wrap-formats
(api
(GET "/lisplogo" []
(-> (response/response (io/file "lisplogo_256.png"))
(response/content-type "image/png")))
(GET "/lisplogo2" []
(assoc-in (ok (io/file "lisplogo_256.png"))
[:headers "Content-Type"]
"image/png")))))
If you want to display image, you better return HTML page with <img> linked to your dir with static assets (usually resources/).
If you want to download file, here is an example of Compojure-api handler:
(ns example.app
(:require [clojure.java.io :as io]
[ring.util.response :as r]))
(defn file-download [name]
(let [filename (str "resources/" name)
bin (io/file filename)]
(-> (r/response (io/input-stream bin))
(r/header "Content-Type" "application/octet-stream")
(r/header "Content-Disposition" "attachment")
(r/header "Content-Length" (.length bin))
(r/status 200))))
Adapt and use this function in place where your let goes in endpoint, hope it helps.

Resources