Clojurians Log v2

IIRC you have to make an actual copy of the InputStream in order to use it without consuming it. We add simple version header to response like this

(def get-version (memoize get-version*))

(defn create-version-header-middleware*
  "Create middleware fn that adds application version to response headers"
  [handler request]
  (let [response (handler request)]
    (rresponse/header response "X-Version" (get-version))))

Right I was thinking about a copy as well. This should work and I might end up doing this. But I was wondering if there was a way to avoid the copy, maybe computing the digest at the same time as the coercion happens.

You could define your own coercion for :body as it is configurable for reitit. This is the default coercion for body

:transformers {:body {:default default-transformer-provider
                         :formats {"application/json" json-transformer-provider}}

;; Route options
    {:conflicts (constantly nil) ;; allow the catch-all path for SPA
     :data {:muuntaja muuntaja/instance
            :middleware [wrap-internal-error
                         swagger/swagger-feature
                         middleware.muuntaja/format-negotiate-middleware
                         middleware.muuntaja/format-response-middleware
                         middleware.muuntaja/format-request-middleware
                         middleware.parameters/parameters-middleware
                         coercion/coerce-request-middleware]
            :coercion (reitit.coercion.malli/create
                       {;; set of keys to include in error messages
                        :error-keys #{:value :humanized #_:type :errors  #_:transformed}
                        ;; validate request & response
                        :validate true
                        ;; top-level short-circuit to disable request & response coercion
                        :enabled true
                        ;; strip-extra-keys (effects only predefined transformers)
                        :strip-extra-keys false
                        ;; add/set default values
                        :default-values true
                        ;; malli options
                        :options nil})}
     :exception pretty/exception}

But I think that the copying is quite simple solution albeit it might consume some memory.

Coercion doesn't read the request body, Muuntaja will read the body. Maybe you can add one mw to setup your InputStream before Muuntaja so that you have the digest available when the stream is read, then second mw to check the result after Muuntaja has read the body.

Add a middleware that consumes the body to a byte array, and assoc it twice into the request, once as body and another was whatever you need for the digest calculation

Something like this

(defn setup-digest-input-stream [handler]
  (fn [req]
    (let [dis (DigestInputStream. (:body req))]
      (handler (assoc req :body dis ::dis dis)))))

(defn check-digest [handler]
  (fn [req]
    (handler (assoc req :digest (.getMessageDigest (::dis req))))))

:middlware [setup-digest-input-stream
            middleware.muuntaja/format-request-middleware
            check-digest]

the digest should be available to the second mw, as Muuntaja has read the stream

looks like DigestInputStream also takes the MessageDigest instance as a parameter etc, but the idea is the same

It looks like it should work. I am getting some bytes out of (.digest (.getMessageDigest dis)) I’ll need to check that this is what I expect.

Aside: should I .close my DigestInputStream, or the original body ? and if yes, which middleware should be responsible for this?

Muuntaja should close the IS it reads and I think DIS closes the original is IS also when it is closed

The second part checks out at least: DIS inherits FilterInputStream https://docs.oracle.com/javase/8/docs/api/index.html?java/io/FilterInputStream.html It would also make sense for Muuntaja to close the :body (otherwise who would (?)). Thanks 🙂

Depends a lot on libraries you use but I think if this is an incoming request and you're not actually streaming the body, then you can call .reset on the :body and consume it again

I get a Jetty HttpInputOverHTTP and it doesn’t seem to be possible. DigestInputStream looks like it works and does not depend on being able to consume the stream again.