A threadsafe pool of network connections to a Redis server. Use the connect function to create one.

Information for connnecting to a Redis server.

It is recommended to not use the ConnInfo data constructor directly. Instead use defaultConnectInfo and update it with record syntax. For example to connect to a password protected Redis server running on localhost and listening to the default port:

myConnectInfo :: ConnectInfo
myConnectInfo = defaultConnectInfo {connectAuth = Just "secret"}

Or better yet, use parseConnectInfo to parse a URL.

Default information for connecting:

 connectAddr           = ConnectAddrHostPort "localhost" 6379 -- Redis default port
 connectAuth           = Nothing         -- No password
 connectUsername       = Nothing         -- No user
 connectDatabase       = 0               -- SELECT database 0
 connectMaxConnections = 50              -- Up to 50 connections
 connectNumStripes     = Just 1          -- A single stripe
 connectMaxIdleTime    = 30              -- Keep open for 30 seconds
 connectTimeout        = Nothing         -- Don't add timeout logic
 connectTLSParams      = Nothing         -- Do not use TLS
 connectHooks          = defaultHooks    -- Do nothing
 connectPoolLabel      = ""              -- no label

Parse a ConnectInfo from a URL according to the Rules in Redis client

Standalone Redis:

redis :// [[username :] password@] host [:port][/database]

>>> parseConnectInfo "redis://username:password@host:42/2"
Right (ConnInfo {connectAddr = ConnectAddrHostPort "host" 42, connectAuth = Just "password", connectUsername = Just "username", connectDatabase = 2, connectMaxConnections = 50, connectNumStripes = Just 1, connectMaxIdleTime = 30s, connectTimeout = Nothing, connectTLSParams = Nothing, connectHooks = Hooks {...}, connectPoolLabel = ""})

>>> parseConnectInfo "redis://password@host:42/2"
Right (ConnInfo {connectAddr = ConnectAddrHostPort "host" 42, connectAuth = Just "password", connectUsername = Nothing, connectDatabase = 2, connectMaxConnections = 50, connectNumStripes = Just 1, connectMaxIdleTime = 30s, connectTimeout = Nothing, connectTLSParams = Nothing, connectHooks = Hooks {...}, connectPoolLabel = ""})

TLS-enabled Redis:

rediss :// [[username :] password@] host [: port][/database]

Unix socket Redis:

redis-socket :// [[username :] password@]path [? [&database=database]

>>> parseConnectInfo "redis-socket://password@/tmp/redis.sock?database=2"
Right (ConnInfo {connectAddr = ConnectAddrUnixSocket "/tmp/redis.sock", connectAuth = Just "password", connectUsername = Nothing, connectDatabase = 2, connectMaxConnections = 50, connectNumStripes = Just 1, connectMaxIdleTime = 30s, connectTimeout = Nothing, connectTLSParams = Nothing, connectHooks = Hooks {...}, connectPoolLabel = ""})

>>> parseConnectInfo "redis://username:password@host:42/db"
Left "Invalid port: db"

The scheme is validated, to prevent mixing up configurations:

>>> parseConnectInfo "postgres://"
Left "Wrong scheme postgres:"

Beyond that, all values are optional. Omitted values are taken from defaultConnectInfo:

>>> parseConnectInfo "rediss://"
Right (ConnInfo {connectAddr = ConnectAddrHostPort "localhost" 6379, connectAuth = Nothing, connectUsername = Nothing, connectDatabase = 0, connectMaxConnections = 50, connectNumStripes = Just 1, connectMaxIdleTime = 30s, connectTimeout = Nothing, connectTLSParams = Just (ClientParams ...), connectHooks = Hooks {...}, connectPoolLabel = ""})

Destroy all idle resources in the pool, works for all types of the connection.

Constructs a Connection pool to a Redis server designated by the given ConnectInfo.

The function always succeeds, because the first connection is not actually established until the first call to the server.

Constructs a Connection pool to a Redis server designated by the given ConnectInfo, then tests if the server is actually there.

Throws an ConnectError exception if the connection to the Redis server can't be established.

Memory bracket around connect and disconnect.

Memory bracket around checkedConnect and disconnect

Constructs a ShardMap of connections to clustered nodes. The argument is a ConnectInfo for any node in the cluster

Some Redis commands are currently not supported in cluster mode - CONFIG, AUTH - SCAN - MOVE, SELECT - RESET

Constructs a Connection pool to a Redis cluster designated by the given ConnectInfo, then tests if the server is actually there.

Throws an ClusterConnectError exception if the connection to the Redis server can't be established.

Context for normal command execution, outside of transactions. Use runRedis to run actions of this type.

In this context, each result is wrapped in an Either to account for the possibility of Redis returning an Error reply.

Interact with a Redis datastore specified by the given Connection.

Each call of runRedis takes a network connection from the Connection pool and runs the given Redis action. Calls to runRedis may thus block while all connections from the pool are in use.

Interact with a Redis datastore specified by the given Connection, but return early if acquiring from the connection pool would block.

Like runRedis, but if all connections in the Connection pool are used, it immediately returns Nothing. This can be useful for logging purposes.

Deconstruct Redis constructor.

unRedis and reRedis can be used to define instances for arbitrary typeclasses.

WARNING! These functions are considered internal and no guarantee is given at this point that they will not break in future.

Reconstruct Redis constructor.

This class captures the following behaviour: In a context m, a command will return its result wrapped in a "container" of type f.

Please refer to the Command Type Signatures section of this page for more information.

A collection of hook functions used by a connection.

A hook for sending commands to the server and receiving replies from the server.

This wraps the command-level request path used by most Redis commands.

A hook for sending pub/sub messages to the server.

A hook for invoking callbacks with pub/sub messages.

A hook for sending raw bytes to the server.

This sits below request rendering and can be used to observe the exact wire payload sent on the socket.

A hook for receiving replies from the server.

The default hooks.

Every hook is the identity function, so installing defaultHooks has no effect on behavior.

sendRequest can be used to implement commands from experimental versions of Redis. An example of how to implement a command is given below.

-- |Redis DEBUG OBJECT command
debugObject :: ByteString -> Redis (Either Reply ByteString)
debugObject key = sendRequest ["DEBUG", "OBJECT", key]

Low-level representation of replies from the Redis server.

Compute the hashslot associated with a key

>>> keyToSlot "123"
HashSlot 5970
>>> keyToSlot "{123"
HashSlot 2872
>>> keyToSlot "{123}"
HashSlot 5970
>>> keyToSlot "{}123"
HashSlot 7640
>>> keyToSlot "{123}1{abc}"
HashSlot 5970
>>> keyToSlot "\00\01"
HashSlot 4129