taoensso.carmine.protocol — com.taoensso/carmine 2.20.0-RC1

Core facilities for communicating with Redis servers using the Redis request/response protocol, Ref. http://redis.io/topics/protocol.

*context* clj

Current dynamic Context

*nested-stash-consumed?_* clj

*nested-stashed-reqs* clj

*parser* clj

ifn (with optional meta) or nil

-with-replies clj

(-with-replies body-fn as-pipeline?)

Implementation detail

execute-requests clj

(execute-requests get-replies? as-pipeline?)

(execute-requests conn requests get-replies? as-pipeline?)

Implementation detail. Sends given/dynamic requests to given/dynamic Redis server and optionally blocks to receive the relevant queued (pipelined) parsed replies.

get-parsed-reply clj

(get-parsed-reply in ?parser)

Implementation detail

get-unparsed-reply clj

(get-unparsed-reply in req-opts)

Implementation detail. BLOCKS to receive a single reply from Redis server and returns the result as [<type> <reply>]. Redis will reply to commands with different kinds of replies, identified by their first byte, Ref. http://redis.io/topics/protocol:

• + for simple strings -> <string>
• : for integers -> <long>
• - for error strings -> <ex-info>
• $ for bulk strings -> <clj>/<raw-bytes> ; Marked as serialized -> <bytes>/<raw-bytes> ; Marked as binary -> <string>/<raw-bytes> ; Unmarked -> nil
• * for arrays -> <vector> -> nil

IByteStr clj protocol

byte-str clj

(byte-str x)

Coerces arbitrary Clojure val to Redis bytestring

no-context-ex clj

parse clj macro

(parse f & body)

Wraps body so that replies to any wrapped Redis commands will be parsed with (f reply). Replaces any current parser; removes parser when f is nil. See also parser-comp.

parse-nippy clj macro

(parse-nippy thaw-opts & body)

parse-raw clj macro

(parse-raw & body)

parser-comp clj

(parser-comp f g)

Composes parsers when f or g are nnil, preserving metadata

possible-nippy-bytes? clj

(possible-nippy-bytes? x)

raw clj

(raw x)

Forces byte[] argument to be sent to Redis as raw, unencoded bytes.

return clj

Takes values and returns them as part of next reply from Redis server. Unlike echo, does not actually send any data to Redis.

return-parsed-replies clj

(return-parsed-replies preplies as-pipeline?)

Implementation detail

suppressed-reply-kw clj

with-context clj macro

(with-context conn & body)

Implementation detail

with-replies clj macro

(with-replies & body)

(with-replies :as-pipeline & body)

Alpha - subject to change. Evaluates body, immediately returning the server's response to any contained Redis commands (i.e. before enclosing context ends).

As an implementation detail, stashes and then returns any replies already queued with Redis server: i.e. should be compatible with pipelining.

Note on parsers: if you're writing a Redis command (e.g. a fn that is intended to execute w/in an implicit connection context) and you're using with-replies as an implementation detail (i.e. you're interpreting replies internally), you probably want (parse nil (with-replies ...)) to keep external parsers from leaking into your internal logic.