Database.Redis.Sentinel

Database.Redis like interface with connection through Redis Sentinel.

More details here: https://redis.io/topics/sentinel.

Example:

conn <- connect SentinelConnectionInfo (("localhost", PortNumber 26379) :| []) "mymaster" defaultConnectInfo

runRedis conn $ do
  set "hello" "world"

When connection is opened, the Sentinels will be queried to get current master. Subsequent runRedis calls will talk to that master.

If runRedis call fails, the next call will choose a new master to talk to.

This implementation is based on Gist by Emanuel Borsboom at https://gist.github.com/borsboom/681d37d273d5c4168723

Connection

data SentinelConnectInfo

Configuration of Sentinel hosts.

Constructors

SentinelConnectInfo

Fields

• connectSentinels :: NonEmpty (HostName, PortID)

  List of sentinels.

• connectMasterName :: ByteString

  Name of master to connect to.

• connectBaseInfo :: ConnectInfo

  This is used to configure auth and other parameters for Redis connection, but connectHost and connectPort are ignored.

Instances

Show SentinelConnectInfo

Defined in Database.Redis.Sentinel

Methods

showsPrec :: Int -> SentinelConnectInfo -> ShowS

show :: SentinelConnectInfo -> String

showList :: [SentinelConnectInfo] -> ShowS

data SentinelConnection

connect :: SentinelConnectInfo -> IO SentinelConnection

runRedis with Sentinel support

runRedis :: SentinelConnection -> Redis (Either Reply a) -> IO (Either Reply a)

Interact with a Redis datastore. See runRedis for details.

data RedisSentinelException

Exception thrown by Database.Redis.Sentinel.

Constructors

NoSentinels (NonEmpty (HostName, PortID))

Thrown if no sentinel can be reached.

Instances

Show RedisSentinelException

Defined in Database.Redis.Sentinel

Methods

showsPrec :: Int -> RedisSentinelException -> ShowS

show :: RedisSentinelException -> String

showList :: [RedisSentinelException] -> ShowS

Exception RedisSentinelException

Defined in Database.Redis.Sentinel

Methods

toException :: RedisSentinelException -> SomeException

fromException :: SomeException -> Maybe RedisSentinelException

displayException :: RedisSentinelException -> String

Re-export Database.Redis

data HashSlot

Instances

Enum HashSlot

Defined in Database.Redis.Cluster.HashSlot

Methods

succ :: HashSlot -> HashSlot

pred :: HashSlot -> HashSlot

toEnum :: Int -> HashSlot

fromEnum :: HashSlot -> Int

enumFrom :: HashSlot -> [HashSlot]

enumFromThen :: HashSlot -> HashSlot -> [HashSlot]

enumFromTo :: HashSlot -> HashSlot -> [HashSlot]

enumFromThenTo :: HashSlot -> HashSlot -> HashSlot -> [HashSlot]

Eq HashSlot

Defined in Database.Redis.Cluster.HashSlot

Methods

(==) :: HashSlot -> HashSlot -> Bool

(/=) :: HashSlot -> HashSlot -> Bool

Integral HashSlot

Defined in Database.Redis.Cluster.HashSlot

Methods

quot :: HashSlot -> HashSlot -> HashSlot

rem :: HashSlot -> HashSlot -> HashSlot

div :: HashSlot -> HashSlot -> HashSlot

mod :: HashSlot -> HashSlot -> HashSlot

quotRem :: HashSlot -> HashSlot -> (HashSlot, HashSlot)

divMod :: HashSlot -> HashSlot -> (HashSlot, HashSlot)

toInteger :: HashSlot -> Integer

Num HashSlot

Defined in Database.Redis.Cluster.HashSlot

Methods

(+) :: HashSlot -> HashSlot -> HashSlot

(-) :: HashSlot -> HashSlot -> HashSlot

(*) :: HashSlot -> HashSlot -> HashSlot

negate :: HashSlot -> HashSlot

abs :: HashSlot -> HashSlot

signum :: HashSlot -> HashSlot

fromInteger :: Integer -> HashSlot

Ord HashSlot

Defined in Database.Redis.Cluster.HashSlot

Methods

compare :: HashSlot -> HashSlot -> Ordering

(<) :: HashSlot -> HashSlot -> Bool

(<=) :: HashSlot -> HashSlot -> Bool

(>) :: HashSlot -> HashSlot -> Bool

(>=) :: HashSlot -> HashSlot -> Bool

max :: HashSlot -> HashSlot -> HashSlot

min :: HashSlot -> HashSlot -> HashSlot

Real HashSlot

Defined in Database.Redis.Cluster.HashSlot

Methods

toRational :: HashSlot -> Rational

Show HashSlot

Defined in Database.Redis.Cluster.HashSlot

Methods

showsPrec :: Int -> HashSlot -> ShowS

show :: HashSlot -> String

showList :: [HashSlot] -> ShowS

keyToSlot :: ByteString -> HashSlot

Compute the hashslot associated with a key

data PortID

Constructors

PortNumber PortNumber

UnixSocket String

Instances

Eq PortID

Defined in Database.Redis.ConnectionContext

Methods

(==) :: PortID -> PortID -> Bool

(/=) :: PortID -> PortID -> Bool

Show PortID

Defined in Database.Redis.ConnectionContext

Methods

showsPrec :: Int -> PortID -> ShowS

show :: PortID -> String

showList :: [PortID] -> ShowS

data ConnectionLostException

Constructors

ConnectionLost

Instances

Show ConnectionLostException

Defined in Database.Redis.ConnectionContext

Methods

showsPrec :: Int -> ConnectionLostException -> ShowS

show :: ConnectionLostException -> String

showList :: [ConnectionLostException] -> ShowS

Exception ConnectionLostException

Defined in Database.Redis.ConnectionContext

Methods

toException :: ConnectionLostException -> SomeException

fromException :: SomeException -> Maybe ConnectionLostException

displayException :: ConnectionLostException -> String

newtype ConnectTimeout

Constructors

ConnectTimeout ConnectPhase

Instances

Show ConnectTimeout

Defined in Database.Redis.ConnectionContext

Methods

showsPrec :: Int -> ConnectTimeout -> ShowS

show :: ConnectTimeout -> String

showList :: [ConnectTimeout] -> ShowS

Exception ConnectTimeout

Defined in Database.Redis.ConnectionContext

Methods

toException :: ConnectTimeout -> SomeException

fromException :: SomeException -> Maybe ConnectTimeout

displayException :: ConnectTimeout -> String

data Reply

Low-level representation of replies from the Redis server.

Constructors

SingleLine ByteString

Error ByteString

Integer Integer

Bulk (Maybe ByteString)

MultiBulk (Maybe [Reply])

Instances

Eq Reply

Defined in Database.Redis.Protocol

Methods

(==) :: Reply -> Reply -> Bool

(/=) :: Reply -> Reply -> Bool

Show Reply

Defined in Database.Redis.Protocol

Methods

showsPrec :: Int -> Reply -> ShowS

show :: Reply -> String

showList :: [Reply] -> ShowS

Generic Reply

Defined in Database.Redis.Protocol

Associated Types

type Rep Reply :: Type -> Type

Methods

from :: Reply -> Rep Reply x

to :: Rep Reply x -> Reply

NFData Reply

Defined in Database.Redis.Protocol

Methods

rnf :: Reply -> ()

RedisResult Reply

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply Reply

RedisCtx Redis (Either Reply)

Defined in Database.Redis.Core

Methods

returnDecode :: RedisResult a => Reply -> Redis (Either Reply a)

type Rep Reply

Defined in Database.Redis.Protocol

type Rep Reply = D1 ('MetaData "Reply" "Database.Redis.Protocol" "hedis-0.14.2-6awqAJzDqBjD7lj5RyLFIN" 'False) ((C1 ('MetaCons "SingleLine" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ByteString)) :+: C1 ('MetaCons "Error" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ByteString))) :+: (C1 ('MetaCons "Integer" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Integer)) :+: (C1 ('MetaCons "Bulk" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ByteString))) :+: C1 ('MetaCons "MultiBulk" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe [Reply]))))))

data RedisType

Constructors

None

String

Hash

List

Set

ZSet

Instances

Eq RedisType

Defined in Database.Redis.Types

Methods

(==) :: RedisType -> RedisType -> Bool

(/=) :: RedisType -> RedisType -> Bool

Show RedisType

Defined in Database.Redis.Types

Methods

showsPrec :: Int -> RedisType -> ShowS

show :: RedisType -> String

showList :: [RedisType] -> ShowS

RedisResult RedisType

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply RedisType

data Status

Constructors

Ok

Pong

Status ByteString

Instances

Eq Status

Defined in Database.Redis.Types

Methods

(==) :: Status -> Status -> Bool

(/=) :: Status -> Status -> Bool

Show Status

Defined in Database.Redis.Types

Methods

showsPrec :: Int -> Status -> ShowS

show :: Status -> String

showList :: [Status] -> ShowS

Generic Status

Defined in Database.Redis.Types

Associated Types

type Rep Status :: Type -> Type

Methods

from :: Status -> Rep Status x

to :: Rep Status x -> Status

NFData Status

Defined in Database.Redis.Types

Methods

rnf :: Status -> ()

RedisResult Status

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply Status

type Rep Status

Defined in Database.Redis.Types

type Rep Status = D1 ('MetaData "Status" "Database.Redis.Types" "hedis-0.14.2-6awqAJzDqBjD7lj5RyLFIN" 'False) (C1 ('MetaCons "Ok" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Pong" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Status" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ByteString))))

class RedisResult a where

Methods

decode :: Reply -> Either Reply a

Instances

RedisResult Bool

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply Bool

RedisResult Double

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply Double

RedisResult Integer

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply Integer

RedisResult ByteString

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply ByteString

RedisResult Reply

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply Reply

RedisResult RedisType

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply RedisType

RedisResult Status

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply Status

RedisResult ClusterSlotsResponseEntry

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply ClusterSlotsResponseEntry

RedisResult ClusterSlotsNode

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply ClusterSlotsNode

RedisResult ClusterSlotsResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply ClusterSlotsResponse

RedisResult ClusterNodesResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply ClusterNodesResponse

RedisResult XInfoStreamResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XInfoStreamResponse

RedisResult XInfoGroupsResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XInfoGroupsResponse

RedisResult XInfoConsumersResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XInfoConsumersResponse

RedisResult XPendingDetailRecord

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XPendingDetailRecord

RedisResult XPendingSummaryResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XPendingSummaryResponse

RedisResult XReadResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XReadResponse

RedisResult StreamsRecord

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply StreamsRecord

RedisResult Cursor

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply Cursor

RedisResult Slowlog

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply Slowlog

(RedisResult k, RedisResult v) => RedisResult [(k, v)]

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply [(k, v)]

RedisResult a => RedisResult [a]

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply [a]

RedisResult a => RedisResult (Maybe a)

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply (Maybe a)

(RedisResult a, RedisResult b) => RedisResult (a, b)

Defined in Database.Redis.Types

Methods

decode :: Reply -> Either Reply (a, b)

data Redis a

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.

Instances

Monad Redis

Defined in Database.Redis.Core.Internal

Methods

(>>=) :: Redis a -> (a -> Redis b) -> Redis b

(>>) :: Redis a -> Redis b -> Redis b

return :: a -> Redis a

Functor Redis

Defined in Database.Redis.Core.Internal

Methods

fmap :: (a -> b) -> Redis a -> Redis b

(<$) :: a -> Redis b -> Redis a

MonadFail Redis

Defined in Database.Redis.Core.Internal

Methods

fail :: String -> Redis a

Applicative Redis

Defined in Database.Redis.Core.Internal

Methods

pure :: a -> Redis a

(<*>) :: Redis (a -> b) -> Redis a -> Redis b

liftA2 :: (a -> b -> c) -> Redis a -> Redis b -> Redis c

(*>) :: Redis a -> Redis b -> Redis b

(<*) :: Redis a -> Redis b -> Redis a

MonadIO Redis

Defined in Database.Redis.Core.Internal

Methods

liftIO :: IO a -> Redis a

MonadRedis Redis

Defined in Database.Redis.Core

Methods

liftRedis :: Redis a -> Redis a

RedisCtx Redis (Either Reply)

Defined in Database.Redis.Core

Methods

returnDecode :: RedisResult a => Reply -> Redis (Either Reply a)

class Monad m => MonadRedis m where

Methods

liftRedis :: Redis a -> m a

Instances

MonadRedis Redis

Defined in Database.Redis.Core

Methods

liftRedis :: Redis a -> Redis a

MonadRedis RedisTx

Defined in Database.Redis.Transactions

Methods

liftRedis :: Redis a -> RedisTx a

class MonadRedis m => RedisCtx m f | m -> f where

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.

Methods

returnDecode :: RedisResult a => Reply -> m (f a)

Instances

RedisCtx RedisTx Queued

Defined in Database.Redis.Transactions

Methods

returnDecode :: RedisResult a => Reply -> RedisTx (Queued a)

RedisCtx Redis (Either Reply)

Defined in Database.Redis.Core

Methods

returnDecode :: RedisResult a => Reply -> Redis (Either Reply a)

unRedis :: Redis a -> ReaderT RedisEnv IO a

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.

reRedis :: ReaderT RedisEnv IO a -> Redis a

Reconstruct Redis constructor.

sendRequest :: (RedisCtx m f, RedisResult a) => [ByteString] -> m (f a)

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]

data TxResult a

Result of a multiExec transaction.

Constructors

TxSuccess a

Transaction completed successfully. The wrapped value corresponds to the Queued value returned from the multiExec argument action.

TxAborted

Transaction aborted due to an earlier watch command.

TxError String

At least one of the commands returned an Error reply.

Instances

Eq a => Eq (TxResult a)

Defined in Database.Redis.Transactions

Methods

(==) :: TxResult a -> TxResult a -> Bool

(/=) :: TxResult a -> TxResult a -> Bool

Show a => Show (TxResult a)

Defined in Database.Redis.Transactions

Methods

showsPrec :: Int -> TxResult a -> ShowS

show :: TxResult a -> String

showList :: [TxResult a] -> ShowS

Generic (TxResult a)

Defined in Database.Redis.Transactions

Associated Types

type Rep (TxResult a) :: Type -> Type

Methods

from :: TxResult a -> Rep (TxResult a) x

to :: Rep (TxResult a) x -> TxResult a

NFData a => NFData (TxResult a)

Defined in Database.Redis.Transactions

Methods

rnf :: TxResult a -> ()

type Rep (TxResult a)

Defined in Database.Redis.Transactions

type Rep (TxResult a) = D1 ('MetaData "TxResult" "Database.Redis.Transactions" "hedis-0.14.2-6awqAJzDqBjD7lj5RyLFIN" 'False) (C1 ('MetaCons "TxSuccess" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: (C1 ('MetaCons "TxAborted" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TxError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))))

data Queued a

A Queued value represents the result of a command inside a transaction. It is a proxy object for the actual result, which will only be available after returning from a multiExec transaction.

Queued values are composable by utilizing the Functor, Applicative or Monad interfaces.

Instances

Monad Queued

Defined in Database.Redis.Transactions

Methods

(>>=) :: Queued a -> (a -> Queued b) -> Queued b

(>>) :: Queued a -> Queued b -> Queued b

return :: a -> Queued a

Functor Queued

Defined in Database.Redis.Transactions

Methods

fmap :: (a -> b) -> Queued a -> Queued b

(<$) :: a -> Queued b -> Queued a

Applicative Queued

Defined in Database.Redis.Transactions

Methods

pure :: a -> Queued a

(<*>) :: Queued (a -> b) -> Queued a -> Queued b

liftA2 :: (a -> b -> c) -> Queued a -> Queued b -> Queued c

(*>) :: Queued a -> Queued b -> Queued b

(<*) :: Queued a -> Queued b -> Queued a

RedisCtx RedisTx Queued

Defined in Database.Redis.Transactions

Methods

returnDecode :: RedisResult a => Reply -> RedisTx (Queued a)

data RedisTx a

Command-context inside of MULTI/EXEC transactions. Use multiExec to run actions of this type.

In the RedisTx context, all commands return a Queued value. It is a proxy object for the actual result, which will only be available after finishing the transaction.

Instances

Monad RedisTx

Defined in Database.Redis.Transactions

Methods

(>>=) :: RedisTx a -> (a -> RedisTx b) -> RedisTx b

(>>) :: RedisTx a -> RedisTx b -> RedisTx b

return :: a -> RedisTx a

Functor RedisTx

Defined in Database.Redis.Transactions

Methods

fmap :: (a -> b) -> RedisTx a -> RedisTx b

(<$) :: a -> RedisTx b -> RedisTx a

Applicative RedisTx

Defined in Database.Redis.Transactions

Methods

pure :: a -> RedisTx a

(<*>) :: RedisTx (a -> b) -> RedisTx a -> RedisTx b

liftA2 :: (a -> b -> c) -> RedisTx a -> RedisTx b -> RedisTx c

(*>) :: RedisTx a -> RedisTx b -> RedisTx b

(<*) :: RedisTx a -> RedisTx b -> RedisTx a

MonadIO RedisTx

Defined in Database.Redis.Transactions

Methods

liftIO :: IO a -> RedisTx a

MonadRedis RedisTx

Defined in Database.Redis.Transactions

Methods

liftRedis :: Redis a -> RedisTx a

RedisCtx RedisTx Queued

Defined in Database.Redis.Transactions

Methods

returnDecode :: RedisResult a => Reply -> RedisTx (Queued a)

watch

Arguments

:: [ByteString]

key

-> Redis (Either Reply Status)

Watch the given keys to determine execution of the MULTI/EXEC block (http://redis.io/commands/watch).

unwatch :: Redis (Either Reply Status)

Forget about all watched keys (http://redis.io/commands/unwatch).

multiExec :: RedisTx (Queued a) -> Redis (TxResult a)

Run commands inside a transaction. For documentation on the semantics of Redis transaction see http://redis.io/topics/transactions.

Inside the transaction block, command functions return their result wrapped in a Queued. The Queued result is a proxy object for the actual command's result, which will only be available after EXECing the transaction.

Example usage (note how Queued 's Applicative instance is used to combine the two individual results):

 runRedis conn $ do
     set "hello" "hello"
     set "world" "world"
     helloworld <- multiExec $ do
         hello <- get "hello"
         world <- get "world"
         return $ (,) <$> hello <*> world
     liftIO (print helloworld)
 

data ClusterSlotsResponseEntry

Constructors

ClusterSlotsResponseEntry

Fields

• clusterSlotsResponseEntryStartSlot :: Int
• clusterSlotsResponseEntryEndSlot :: Int
• clusterSlotsResponseEntryMaster :: ClusterSlotsNode
• clusterSlotsResponseEntryReplicas :: [ClusterSlotsNode]

Instances

Show ClusterSlotsResponseEntry

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> ClusterSlotsResponseEntry -> ShowS

show :: ClusterSlotsResponseEntry -> String

showList :: [ClusterSlotsResponseEntry] -> ShowS

RedisResult ClusterSlotsResponseEntry

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply ClusterSlotsResponseEntry

data ClusterSlotsNode

Constructors

ClusterSlotsNode

Fields

• clusterSlotsNodeIP :: ByteString
• clusterSlotsNodePort :: Int
• clusterSlotsNodeID :: ByteString

Instances

Show ClusterSlotsNode

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> ClusterSlotsNode -> ShowS

show :: ClusterSlotsNode -> String

showList :: [ClusterSlotsNode] -> ShowS

RedisResult ClusterSlotsNode

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply ClusterSlotsNode

data ClusterSlotsResponse

Constructors

ClusterSlotsResponse

Fields

• clusterSlotsResponseEntries :: [ClusterSlotsResponseEntry]

Instances

Show ClusterSlotsResponse

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> ClusterSlotsResponse -> ShowS

show :: ClusterSlotsResponse -> String

showList :: [ClusterSlotsResponse] -> ShowS

RedisResult ClusterSlotsResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply ClusterSlotsResponse

data ClusterNodesResponseSlotSpec

Constructors

ClusterNodesResponseSingleSlot Integer

ClusterNodesResponseSlotRange Integer Integer

ClusterNodesResponseSlotImporting Integer ByteString

ClusterNodesResponseSlotMigrating Integer ByteString

Instances

Eq ClusterNodesResponseSlotSpec

Defined in Database.Redis.ManualCommands

Methods

(==) :: ClusterNodesResponseSlotSpec -> ClusterNodesResponseSlotSpec -> Bool

(/=) :: ClusterNodesResponseSlotSpec -> ClusterNodesResponseSlotSpec -> Bool

Show ClusterNodesResponseSlotSpec

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> ClusterNodesResponseSlotSpec -> ShowS

show :: ClusterNodesResponseSlotSpec -> String

showList :: [ClusterNodesResponseSlotSpec] -> ShowS

data ClusterNodesResponseEntry

Constructors

ClusterNodesResponseEntry

Fields

• clusterNodesResponseNodeId :: ByteString
• clusterNodesResponseNodeIp :: ByteString
• clusterNodesResponseNodePort :: Integer
• clusterNodesResponseNodeFlags :: [ByteString]
• clusterNodesResponseMasterId :: Maybe ByteString
• clusterNodesResponsePingSent :: Integer
• clusterNodesResponsePongReceived :: Integer
• clusterNodesResponseConfigEpoch :: Integer
• clusterNodesResponseLinkState :: ByteString
• clusterNodesResponseSlots :: [ClusterNodesResponseSlotSpec]

Instances

Eq ClusterNodesResponseEntry

Defined in Database.Redis.ManualCommands

Methods

(==) :: ClusterNodesResponseEntry -> ClusterNodesResponseEntry -> Bool

(/=) :: ClusterNodesResponseEntry -> ClusterNodesResponseEntry -> Bool

Show ClusterNodesResponseEntry

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> ClusterNodesResponseEntry -> ShowS

show :: ClusterNodesResponseEntry -> String

showList :: [ClusterNodesResponseEntry] -> ShowS

data ClusterNodesResponse

Constructors

ClusterNodesResponse

Fields

• clusterNodesResponseEntries :: [ClusterNodesResponseEntry]

Instances

Eq ClusterNodesResponse

Defined in Database.Redis.ManualCommands

Methods

(==) :: ClusterNodesResponse -> ClusterNodesResponse -> Bool

(/=) :: ClusterNodesResponse -> ClusterNodesResponse -> Bool

Show ClusterNodesResponse

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> ClusterNodesResponse -> ShowS

show :: ClusterNodesResponse -> String

showList :: [ClusterNodesResponse] -> ShowS

RedisResult ClusterNodesResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply ClusterNodesResponse

data XInfoStreamResponse

Constructors

XInfoStreamResponse

Fields

• xinfoStreamLength :: Integer
• xinfoStreamRadixTreeKeys :: Integer
• xinfoStreamRadixTreeNodes :: Integer
• xinfoStreamNumGroups :: Integer
• xinfoStreamLastEntryId :: ByteString
• xinfoStreamFirstEntry :: StreamsRecord
• xinfoStreamLastEntry :: StreamsRecord

Instances

Eq XInfoStreamResponse

Defined in Database.Redis.ManualCommands

Methods

(==) :: XInfoStreamResponse -> XInfoStreamResponse -> Bool

(/=) :: XInfoStreamResponse -> XInfoStreamResponse -> Bool

Show XInfoStreamResponse

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> XInfoStreamResponse -> ShowS

show :: XInfoStreamResponse -> String

showList :: [XInfoStreamResponse] -> ShowS

RedisResult XInfoStreamResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XInfoStreamResponse

data XInfoGroupsResponse

Constructors

XInfoGroupsResponse

Fields

• xinfoGroupsGroupName :: ByteString
• xinfoGroupsNumConsumers :: Integer
• xinfoGroupsNumPendingMessages :: Integer
• xinfoGroupsLastDeliveredMessageId :: ByteString

Instances

Eq XInfoGroupsResponse

Defined in Database.Redis.ManualCommands

Methods

(==) :: XInfoGroupsResponse -> XInfoGroupsResponse -> Bool

(/=) :: XInfoGroupsResponse -> XInfoGroupsResponse -> Bool

Show XInfoGroupsResponse

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> XInfoGroupsResponse -> ShowS

show :: XInfoGroupsResponse -> String

showList :: [XInfoGroupsResponse] -> ShowS

RedisResult XInfoGroupsResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XInfoGroupsResponse

data XInfoConsumersResponse

Constructors

XInfoConsumersResponse

Fields

• xinfoConsumerName :: ByteString
• xinfoConsumerNumPendingMessages :: Integer
• xinfoConsumerIdleTime :: Integer

Instances

Eq XInfoConsumersResponse

Defined in Database.Redis.ManualCommands

Methods

(==) :: XInfoConsumersResponse -> XInfoConsumersResponse -> Bool

(/=) :: XInfoConsumersResponse -> XInfoConsumersResponse -> Bool

Show XInfoConsumersResponse

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> XInfoConsumersResponse -> ShowS

show :: XInfoConsumersResponse -> String

showList :: [XInfoConsumersResponse] -> ShowS

RedisResult XInfoConsumersResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XInfoConsumersResponse

data XClaimOpts

Constructors

XClaimOpts

Fields

• xclaimIdle :: Maybe Integer
• xclaimTime :: Maybe Integer
• xclaimRetryCount :: Maybe Integer
• xclaimForce :: Bool

Instances

Eq XClaimOpts

Defined in Database.Redis.ManualCommands

Methods

(==) :: XClaimOpts -> XClaimOpts -> Bool

(/=) :: XClaimOpts -> XClaimOpts -> Bool

Show XClaimOpts

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> XClaimOpts -> ShowS

show :: XClaimOpts -> String

showList :: [XClaimOpts] -> ShowS

data XPendingDetailRecord

Constructors

XPendingDetailRecord

Fields

• messageId :: ByteString
• consumer :: ByteString
• millisSinceLastDelivered :: Integer
• numTimesDelivered :: Integer

Instances

Eq XPendingDetailRecord

Defined in Database.Redis.ManualCommands

Methods

(==) :: XPendingDetailRecord -> XPendingDetailRecord -> Bool

(/=) :: XPendingDetailRecord -> XPendingDetailRecord -> Bool

Show XPendingDetailRecord

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> XPendingDetailRecord -> ShowS

show :: XPendingDetailRecord -> String

showList :: [XPendingDetailRecord] -> ShowS

RedisResult XPendingDetailRecord

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XPendingDetailRecord

data XPendingSummaryResponse

Constructors

XPendingSummaryResponse

Fields

• numPendingMessages :: Integer
• smallestPendingMessageId :: ByteString
• largestPendingMessageId :: ByteString
• numPendingMessagesByconsumer :: [(ByteString, Integer)]

Instances

Eq XPendingSummaryResponse

Defined in Database.Redis.ManualCommands

Methods

(==) :: XPendingSummaryResponse -> XPendingSummaryResponse -> Bool

(/=) :: XPendingSummaryResponse -> XPendingSummaryResponse -> Bool

Show XPendingSummaryResponse

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> XPendingSummaryResponse -> ShowS

show :: XPendingSummaryResponse -> String

showList :: [XPendingSummaryResponse] -> ShowS

RedisResult XPendingSummaryResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XPendingSummaryResponse

data XReadResponse

Constructors

XReadResponse

Fields

• stream :: ByteString
• records :: [StreamsRecord]

Instances

Eq XReadResponse

Defined in Database.Redis.ManualCommands

Methods

(==) :: XReadResponse -> XReadResponse -> Bool

(/=) :: XReadResponse -> XReadResponse -> Bool

Show XReadResponse

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> XReadResponse -> ShowS

show :: XReadResponse -> String

showList :: [XReadResponse] -> ShowS

RedisResult XReadResponse

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply XReadResponse

data XReadOpts

Constructors

XReadOpts

Fields

• block :: Maybe Integer
• recordCount :: Maybe Integer

Instances

Eq XReadOpts

Defined in Database.Redis.ManualCommands

Methods

(==) :: XReadOpts -> XReadOpts -> Bool

(/=) :: XReadOpts -> XReadOpts -> Bool

Show XReadOpts

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> XReadOpts -> ShowS

show :: XReadOpts -> String

showList :: [XReadOpts] -> ShowS

data StreamsRecord

Constructors

StreamsRecord

Fields

• recordId :: ByteString
• keyValues :: [(ByteString, ByteString)]

Instances

Eq StreamsRecord

Defined in Database.Redis.ManualCommands

Methods

(==) :: StreamsRecord -> StreamsRecord -> Bool

(/=) :: StreamsRecord -> StreamsRecord -> Bool

Show StreamsRecord

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> StreamsRecord -> ShowS

show :: StreamsRecord -> String

showList :: [StreamsRecord] -> ShowS

RedisResult StreamsRecord

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply StreamsRecord

data TrimOpts

Constructors

NoArgs

Maxlen Integer

ApproxMaxlen Integer

data RangeLex a

Constructors

Incl a

Excl a

Minr

Maxr

data ScanOpts

Constructors

ScanOpts

Fields

• scanMatch :: Maybe ByteString
• scanCount :: Maybe Integer

Instances

Eq ScanOpts

Defined in Database.Redis.ManualCommands

Methods

(==) :: ScanOpts -> ScanOpts -> Bool

(/=) :: ScanOpts -> ScanOpts -> Bool

Show ScanOpts

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> ScanOpts -> ShowS

show :: ScanOpts -> String

showList :: [ScanOpts] -> ShowS

data Cursor

Instances

Eq Cursor

Defined in Database.Redis.ManualCommands

Methods

(==) :: Cursor -> Cursor -> Bool

(/=) :: Cursor -> Cursor -> Bool

Show Cursor

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> Cursor -> ShowS

show :: Cursor -> String

showList :: [Cursor] -> ShowS

RedisResult Cursor

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply Cursor

data ReplyMode

Instances

Eq ReplyMode

Defined in Database.Redis.ManualCommands

Methods

(==) :: ReplyMode -> ReplyMode -> Bool

(/=) :: ReplyMode -> ReplyMode -> Bool

Show ReplyMode

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> ReplyMode -> ShowS

show :: ReplyMode -> String

showList :: [ReplyMode] -> ShowS

data ZaddOpts

Constructors

ZaddOpts

Fields

• zaddCondition :: Maybe Condition
• zaddChange :: Bool
• zaddIncrement :: Bool

Instances

Eq ZaddOpts

Defined in Database.Redis.ManualCommands

Methods

(==) :: ZaddOpts -> ZaddOpts -> Bool

(/=) :: ZaddOpts -> ZaddOpts -> Bool

Show ZaddOpts

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> ZaddOpts -> ShowS

show :: ZaddOpts -> String

showList :: [ZaddOpts] -> ShowS

data DebugMode

Instances

Eq DebugMode

Defined in Database.Redis.ManualCommands

Methods

(==) :: DebugMode -> DebugMode -> Bool

(/=) :: DebugMode -> DebugMode -> Bool

Show DebugMode

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> DebugMode -> ShowS

show :: DebugMode -> String

showList :: [DebugMode] -> ShowS

data SetOpts

Constructors

SetOpts

Fields

• setSeconds :: Maybe Integer
• setMilliseconds :: Maybe Integer
• setCondition :: Maybe Condition

Instances

Eq SetOpts

Defined in Database.Redis.ManualCommands

Methods

(==) :: SetOpts -> SetOpts -> Bool

(/=) :: SetOpts -> SetOpts -> Bool

Show SetOpts

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> SetOpts -> ShowS

show :: SetOpts -> String

showList :: [SetOpts] -> ShowS

data Condition

Constructors

Nx

Xx

Instances

Eq Condition

Defined in Database.Redis.ManualCommands

Methods

(==) :: Condition -> Condition -> Bool

(/=) :: Condition -> Condition -> Bool

Show Condition

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> Condition -> ShowS

show :: Condition -> String

showList :: [Condition] -> ShowS

data MigrateOpts

Options for the migrate command.

Constructors

MigrateOpts

Fields

• migrateCopy :: Bool
• migrateReplace :: Bool

Instances

Eq MigrateOpts

Defined in Database.Redis.ManualCommands

Methods

(==) :: MigrateOpts -> MigrateOpts -> Bool

(/=) :: MigrateOpts -> MigrateOpts -> Bool

Show MigrateOpts

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> MigrateOpts -> ShowS

show :: MigrateOpts -> String

showList :: [MigrateOpts] -> ShowS

data Aggregate

Constructors

Sum

Min

Max

Instances

Eq Aggregate

Defined in Database.Redis.ManualCommands

Methods

(==) :: Aggregate -> Aggregate -> Bool

(/=) :: Aggregate -> Aggregate -> Bool

Show Aggregate

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> Aggregate -> ShowS

show :: Aggregate -> String

showList :: [Aggregate] -> ShowS

data SortOrder

Constructors

Asc

Desc

Instances

Eq SortOrder

Defined in Database.Redis.ManualCommands

Methods

(==) :: SortOrder -> SortOrder -> Bool

(/=) :: SortOrder -> SortOrder -> Bool

Show SortOrder

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> SortOrder -> ShowS

show :: SortOrder -> String

showList :: [SortOrder] -> ShowS

data SortOpts

Options for the sort command.

Constructors

SortOpts

Fields

• sortBy :: Maybe ByteString
• sortLimit :: (Integer, Integer)
• sortGet :: [ByteString]
• sortOrder :: SortOrder
• sortAlpha :: Bool

Instances

Eq SortOpts

Defined in Database.Redis.ManualCommands

Methods

(==) :: SortOpts -> SortOpts -> Bool

(/=) :: SortOpts -> SortOpts -> Bool

Show SortOpts

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> SortOpts -> ShowS

show :: SortOpts -> String

showList :: [SortOpts] -> ShowS

data Slowlog

A single entry from the slowlog.

Constructors

Slowlog

Fields

• slowlogId :: Integer

  A unique progressive identifier for every slow log entry.

• slowlogTimestamp :: Integer

  The unix timestamp at which the logged command was processed.

• slowlogMicros :: Integer

  The amount of time needed for its execution, in microseconds.

• slowlogCmd :: [ByteString]

  The command and it's arguments.

• slowlogClientIpAndPort :: Maybe ByteString
• slowlogClientName :: Maybe ByteString

Instances

Eq Slowlog

Defined in Database.Redis.ManualCommands

Methods

(==) :: Slowlog -> Slowlog -> Bool

(/=) :: Slowlog -> Slowlog -> Bool

Show Slowlog

Defined in Database.Redis.ManualCommands

Methods

showsPrec :: Int -> Slowlog -> ShowS

show :: Slowlog -> String

showList :: [Slowlog] -> ShowS

RedisResult Slowlog

Defined in Database.Redis.ManualCommands

Methods

decode :: Reply -> Either Reply Slowlog

objectRefcount

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

objectIdletime

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

objectEncoding

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f ByteString)

linsertBefore

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

pivot

-> ByteString

value

-> m (f Integer)

linsertAfter

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

pivot

-> ByteString

value

-> m (f Integer)

getType

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f RedisType)

slowlogGet

Arguments

:: RedisCtx m f

=> Integer

cnt

-> m (f [Slowlog])

slowlogLen :: RedisCtx m f => m (f Integer)

slowlogReset :: RedisCtx m f => m (f Status)

zrange

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

start

-> Integer

stop

-> m (f [ByteString])

zrangeWithscores

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

start

-> Integer

stop

-> m (f [(ByteString, Double)])

zrevrange

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

start

-> Integer

stop

-> m (f [ByteString])

zrevrangeWithscores

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

start

-> Integer

stop

-> m (f [(ByteString, Double)])

zrangebyscore

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

min

-> Double

max

-> m (f [ByteString])

zrangebyscoreWithscores

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

min

-> Double

max

-> m (f [(ByteString, Double)])

zrangebyscoreLimit

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

min

-> Double

max

-> Integer

offset

-> Integer

count

-> m (f [ByteString])

zrangebyscoreWithscoresLimit

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

min

-> Double

max

-> Integer

offset

-> Integer

count

-> m (f [(ByteString, Double)])

zrevrangebyscore

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

max

-> Double

min

-> m (f [ByteString])

zrevrangebyscoreWithscores

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

max

-> Double

min

-> m (f [(ByteString, Double)])

zrevrangebyscoreLimit

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

max

-> Double

min

-> Integer

offset

-> Integer

count

-> m (f [ByteString])

zrevrangebyscoreWithscoresLimit

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

max

-> Double

min

-> Integer

offset

-> Integer

count

-> m (f [(ByteString, Double)])

defaultSortOpts :: SortOpts

Redis default SortOpts. Equivalent to omitting all optional parameters.

SortOpts
    { sortBy    = Nothing -- omit the BY option
    , sortLimit = (0,-1)  -- return entire collection
    , sortGet   = []      -- omit the GET option
    , sortOrder = Asc     -- sort in ascending order
    , sortAlpha = False   -- sort numerically, not lexicographically
    }

sortStore

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

destination

-> SortOpts

-> m (f Integer)

sort

Arguments

:: RedisCtx m f

=> ByteString

key

-> SortOpts

-> m (f [ByteString])

zunionstore

Arguments

:: RedisCtx m f

=> ByteString

destination

-> [ByteString]

keys

-> Aggregate

-> m (f Integer)

zunionstoreWeights

Arguments

:: RedisCtx m f

=> ByteString

destination

-> [(ByteString, Double)]

weighted keys

-> Aggregate

-> m (f Integer)

zinterstore

Arguments

:: RedisCtx m f

=> ByteString

destination

-> [ByteString]

keys

-> Aggregate

-> m (f Integer)

zinterstoreWeights

Arguments

:: RedisCtx m f

=> ByteString

destination

-> [(ByteString, Double)]

weighted keys

-> Aggregate

-> m (f Integer)

eval

Arguments

:: (RedisCtx m f, RedisResult a)

=> ByteString

script

-> [ByteString]

keys

-> [ByteString]

args

-> m (f a)

evalsha

Arguments

:: (RedisCtx m f, RedisResult a)

=> ByteString

base16-encoded sha1 hash of the script

-> [ByteString]

keys

-> [ByteString]

args

-> m (f a)

Works like eval, but sends the SHA1 hash of the script instead of the script itself. Fails if the server does not recognise the hash, in which case, eval should be used instead.

bitcount

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

bitcountRange

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

start

-> Integer

end

-> m (f Integer)

bitopAnd

Arguments

:: RedisCtx m f

=> ByteString

destkey

-> [ByteString]

srckeys

-> m (f Integer)

bitopOr

Arguments

:: RedisCtx m f

=> ByteString

destkey

-> [ByteString]

srckeys

-> m (f Integer)

bitopXor

Arguments

:: RedisCtx m f

=> ByteString

destkey

-> [ByteString]

srckeys

-> m (f Integer)

bitopNot

Arguments

:: RedisCtx m f

=> ByteString

destkey

-> ByteString

srckey

-> m (f Integer)

migrate

Arguments

:: RedisCtx m f

=> ByteString

host

-> ByteString

port

-> ByteString

key

-> Integer

destinationDb

-> Integer

timeout

-> m (f Status)

defaultMigrateOpts :: MigrateOpts

Redis default MigrateOpts. Equivalent to omitting all optional parameters.

MigrateOpts
    { migrateCopy    = False -- remove the key from the local instance
    , migrateReplace = False -- don't replace existing key on the remote instance
    }

migrateMultiple

Arguments

:: RedisCtx m f

=> ByteString

host

-> ByteString

port

-> Integer

destinationDb

-> Integer

timeout

-> MigrateOpts

-> [ByteString]

keys

-> m (f Status)

restore

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

timeToLive

-> ByteString

serializedValue

-> m (f Status)

restoreReplace

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

timeToLive

-> ByteString

serializedValue

-> m (f Status)

set

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

value

-> m (f Status)

setOpts

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

value

-> SetOpts

-> m (f Status)

scriptDebug :: RedisCtx m f => DebugMode -> m (f Bool)

zadd

Arguments

:: RedisCtx m f

=> ByteString

key

-> [(Double, ByteString)]

scoreMember

-> m (f Integer)

defaultZaddOpts :: ZaddOpts

Redis default ZaddOpts. Equivalent to omitting all optional parameters.

ZaddOpts
    { zaddCondition = Nothing -- omit NX and XX options
    , zaddChange    = False   -- don't modify the return value from the number of new elements added, to the total number of elements changed
    , zaddIncrement = False   -- don't add like ZINCRBY
    }

zaddOpts

Arguments

:: RedisCtx m f

=> ByteString

key

-> [(Double, ByteString)]

scoreMember

-> ZaddOpts

options

-> m (f Integer)

clientReply :: RedisCtx m f => ReplyMode -> m (f Bool)

srandmember

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f (Maybe ByteString))

srandmemberN

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

count

-> m (f [ByteString])

spop

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f (Maybe ByteString))

spopN

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

count

-> m (f [ByteString])

info :: RedisCtx m f => m (f ByteString)

infoSection

Arguments

:: RedisCtx m f

=> ByteString

section

-> m (f ByteString)

exists

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Bool)

cursor0 :: Cursor

scan

Arguments

:: RedisCtx m f

=> Cursor

-> m (f (Cursor, [ByteString]))

next cursor and values

defaultScanOpts :: ScanOpts

Redis default ScanOpts. Equivalent to omitting all optional parameters.

ScanOpts
    { scanMatch = Nothing -- don't match any pattern
    , scanCount = Nothing -- don't set any requirements on number elements returned (works like value COUNT 10)
    }

scanOpts

Arguments

:: RedisCtx m f

=> Cursor

-> ScanOpts

-> m (f (Cursor, [ByteString]))

next cursor and values

sscan

Arguments

:: RedisCtx m f

=> ByteString

key

-> Cursor

-> m (f (Cursor, [ByteString]))

next cursor and values

sscanOpts

Arguments

:: RedisCtx m f

=> ByteString

key

-> Cursor

-> ScanOpts

-> m (f (Cursor, [ByteString]))

next cursor and values

hscan

Arguments

:: RedisCtx m f

=> ByteString

key

-> Cursor

-> m (f (Cursor, [(ByteString, ByteString)]))

next cursor and values

hscanOpts

Arguments

:: RedisCtx m f

=> ByteString

key

-> Cursor

-> ScanOpts

-> m (f (Cursor, [(ByteString, ByteString)]))

next cursor and values

zscan

Arguments

:: RedisCtx m f

=> ByteString

key

-> Cursor

-> m (f (Cursor, [(ByteString, Double)]))

next cursor and values

zscanOpts

Arguments

:: RedisCtx m f

=> ByteString

key

-> Cursor

-> ScanOpts

-> m (f (Cursor, [(ByteString, Double)]))

next cursor and values

zrangebylex

Arguments

:: RedisCtx m f

=> ByteString

key

-> RangeLex ByteString

min

-> RangeLex ByteString

max

-> m (f [ByteString])

zrangebylexLimit

Arguments

:: RedisCtx m f

=> ByteString

key

-> RangeLex ByteString

min

-> RangeLex ByteString

max

-> Integer

offset

-> Integer

count

-> m (f [ByteString])

xaddOpts

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

id

-> [(ByteString, ByteString)]

(field, value)

-> TrimOpts

-> m (f ByteString)

xadd

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

id

-> [(ByteString, ByteString)]

(field, value)

-> m (f ByteString)

defaultXreadOpts :: XReadOpts

Redis default XReadOpts. Equivalent to omitting all optional parameters.

XReadOpts
    { block = Nothing -- Don't block waiting for more records
    , recordCount    = Nothing   -- no record count
    }

xreadOpts

Arguments

:: RedisCtx m f

=> [(ByteString, ByteString)]

(stream, id) pairs

-> XReadOpts

Options

-> m (f (Maybe [XReadResponse]))

xread

Arguments

:: RedisCtx m f

=> [(ByteString, ByteString)]

(stream, id) pairs

-> m (f (Maybe [XReadResponse]))

xreadGroupOpts

Arguments

:: RedisCtx m f

=> ByteString

group name

-> ByteString

consumer name

-> [(ByteString, ByteString)]

(stream, id) pairs

-> XReadOpts

Options

-> m (f (Maybe [XReadResponse]))

xreadGroup

Arguments

:: RedisCtx m f

=> ByteString

group name

-> ByteString

consumer name

-> [(ByteString, ByteString)]

(stream, id) pairs

-> m (f (Maybe [XReadResponse]))

xgroupCreate

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

group name

-> ByteString

start ID

-> m (f Status)

xgroupSetId

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

group

-> ByteString

id

-> m (f Status)

xgroupDelConsumer

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

group

-> ByteString

consumer

-> m (f Integer)

xgroupDestroy

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

group

-> m (f Bool)

xack

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

group name

-> [ByteString]

message IDs

-> m (f Integer)

xrange

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

start

-> ByteString

end

-> Maybe Integer

COUNT

-> m (f [StreamsRecord])

xrevRange

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

end

-> ByteString

start

-> Maybe Integer

COUNT

-> m (f [StreamsRecord])

xlen

Arguments

:: RedisCtx m f

=> ByteString

stream

-> m (f Integer)

xpendingSummary

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

group

-> Maybe ByteString

consumer

-> m (f XPendingSummaryResponse)

xpendingDetail

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

group

-> ByteString

startId

-> ByteString

endId

-> Integer

count

-> Maybe ByteString

consumer

-> m (f [XPendingDetailRecord])

defaultXClaimOpts :: XClaimOpts

xclaim

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

group

-> ByteString

consumer

-> Integer

min idle time

-> XClaimOpts

optional arguments

-> [ByteString]

message IDs

-> m (f [StreamsRecord])

xclaimJustIds

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

group

-> ByteString

consumer

-> Integer

min idle time

-> XClaimOpts

optional arguments

-> [ByteString]

message IDs

-> m (f [ByteString])

xinfoConsumers

Arguments

:: RedisCtx m f

=> ByteString

stream

-> ByteString

group

-> m (f [XInfoConsumersResponse])

xinfoGroups

Arguments

:: RedisCtx m f

=> ByteString

stream

-> m (f [XInfoGroupsResponse])

xinfoStream

Arguments

:: RedisCtx m f

=> ByteString

stream

-> m (f XInfoStreamResponse)

xdel

Arguments

:: RedisCtx m f

=> ByteString

stream

-> [ByteString]

message IDs

-> m (f Integer)

xtrim

Arguments

:: RedisCtx m f

=> ByteString

stream

-> TrimOpts

-> m (f Integer)

inf :: RealFloat a => a

auth

Arguments

:: RedisCtx m f

=> ByteString

password

-> m (f Status)

select

Arguments

:: RedisCtx m f

=> Integer

index

-> m (f Status)

ping :: RedisCtx m f => m (f Status)

clusterNodes :: RedisCtx m f => m (f ClusterNodesResponse)

clusterSlots :: RedisCtx m f => m (f ClusterSlotsResponse)

clusterSetSlotImporting :: RedisCtx m f => Integer -> ByteString -> m (f Status)

clusterSetSlotMigrating :: RedisCtx m f => Integer -> ByteString -> m (f Status)

clusterSetSlotStable :: RedisCtx m f => Integer -> m (f Status)

clusterSetSlotNode :: RedisCtx m f => Integer -> ByteString -> m (f Status)

clusterGetKeysInSlot :: RedisCtx m f => Integer -> Integer -> m (f [ByteString])

command :: RedisCtx m f => m (f [CommandInfo])

ttl

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

setnx

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

value

-> m (f Bool)

pttl

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

commandCount :: RedisCtx m f => m (f Integer)

clientSetname

Arguments

:: RedisCtx m f

=> ByteString

connectionName

-> m (f ByteString)

zrank

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

member

-> m (f (Maybe Integer))

zremrangebyscore

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

min

-> Double

max

-> m (f Integer)

hkeys

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f [ByteString])

slaveof

Arguments

:: RedisCtx m f

=> ByteString

host

-> ByteString

port

-> m (f Status)

rpushx

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

value

-> m (f Integer)

debugObject

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f ByteString)

bgsave :: RedisCtx m f => m (f Status)

hlen

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

rpoplpush

Arguments

:: RedisCtx m f

=> ByteString

source

-> ByteString

destination

-> m (f (Maybe ByteString))

brpop

Arguments

:: RedisCtx m f

=> [ByteString]

key

-> Integer

timeout

-> m (f (Maybe (ByteString, ByteString)))

bgrewriteaof :: RedisCtx m f => m (f Status)

zincrby

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

increment

-> ByteString

member

-> m (f Double)

hgetall

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f [(ByteString, ByteString)])

hmset

Arguments

:: RedisCtx m f

=> ByteString

key

-> [(ByteString, ByteString)]

fieldValue

-> m (f Status)

sinter

Arguments

:: RedisCtx m f

=> [ByteString]

key

-> m (f [ByteString])

pfadd

Arguments

:: RedisCtx m f

=> ByteString

key

-> [ByteString]

value

-> m (f Integer)

zremrangebyrank

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

start

-> Integer

stop

-> m (f Integer)

flushdb :: RedisCtx m f => m (f Status)

sadd

Arguments

:: RedisCtx m f

=> ByteString

key

-> [ByteString]

member

-> m (f Integer)

lindex

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

index

-> m (f (Maybe ByteString))

lpush

Arguments

:: RedisCtx m f

=> ByteString

key

-> [ByteString]

value

-> m (f Integer)

hstrlen

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

field

-> m (f Integer)

smove

Arguments

:: RedisCtx m f

=> ByteString

source

-> ByteString

destination

-> ByteString

member

-> m (f Bool)

zscore

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

member

-> m (f (Maybe Double))

configResetstat :: RedisCtx m f => m (f Status)

pfcount

Arguments

:: RedisCtx m f

=> [ByteString]

key

-> m (f Integer)

hdel

Arguments

:: RedisCtx m f

=> ByteString

key

-> [ByteString]

field

-> m (f Integer)

incrbyfloat

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

increment

-> m (f Double)

setbit

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

offset

-> ByteString

value

-> m (f Integer)

flushall :: RedisCtx m f => m (f Status)

incrby

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

increment

-> m (f Integer)

time :: RedisCtx m f => m (f (Integer, Integer))

smembers

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f [ByteString])

zlexcount

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

min

-> ByteString

max

-> m (f Integer)

sunion

Arguments

:: RedisCtx m f

=> [ByteString]

key

-> m (f [ByteString])

sinterstore

Arguments

:: RedisCtx m f

=> ByteString

destination

-> [ByteString]

key

-> m (f Integer)

hvals

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f [ByteString])

configSet

Arguments

:: RedisCtx m f

=> ByteString

parameter

-> ByteString

value

-> m (f Status)

scriptFlush :: RedisCtx m f => m (f Status)

dbsize :: RedisCtx m f => m (f Integer)

wait

Arguments

:: RedisCtx m f

=> Integer

numslaves

-> Integer

timeout

-> m (f Integer)

lpop

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f (Maybe ByteString))

clientPause

Arguments

:: RedisCtx m f

=> Integer

timeout

-> m (f Status)

expire

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

seconds

-> m (f Bool)

mget

Arguments

:: RedisCtx m f

=> [ByteString]

key

-> m (f [Maybe ByteString])

bitpos

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

bit

-> Integer

start

-> Integer

end

-> m (f Integer)

lastsave :: RedisCtx m f => m (f Integer)

pexpire

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

milliseconds

-> m (f Bool)

clientList :: RedisCtx m f => m (f [ByteString])

renamenx

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

newkey

-> m (f Bool)

pfmerge

Arguments

:: RedisCtx m f

=> ByteString

destkey

-> [ByteString]

sourcekey

-> m (f ByteString)

lrem

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

count

-> ByteString

value

-> m (f Integer)

sdiff

Arguments

:: RedisCtx m f

=> [ByteString]

key

-> m (f [ByteString])

get

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f (Maybe ByteString))

getrange

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

start

-> Integer

end

-> m (f ByteString)

sdiffstore

Arguments

:: RedisCtx m f

=> ByteString

destination

-> [ByteString]

key

-> m (f Integer)

zcount

Arguments

:: RedisCtx m f

=> ByteString

key

-> Double

min

-> Double

max

-> m (f Integer)

scriptLoad

Arguments

:: RedisCtx m f

=> ByteString

script

-> m (f ByteString)

getset

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

value

-> m (f (Maybe ByteString))

dump

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f ByteString)

keys

Arguments

:: RedisCtx m f

=> ByteString

pattern

-> m (f [ByteString])

configGet

Arguments

:: RedisCtx m f

=> ByteString

parameter

-> m (f [(ByteString, ByteString)])

rpush

Arguments

:: RedisCtx m f

=> ByteString

key

-> [ByteString]

value

-> m (f Integer)

randomkey :: RedisCtx m f => m (f (Maybe ByteString))

hsetnx

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

field

-> ByteString

value

-> m (f Bool)

mset

Arguments

:: RedisCtx m f

=> [(ByteString, ByteString)]

keyValue

-> m (f Status)

setex

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

seconds

-> ByteString

value

-> m (f Status)

psetex

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

milliseconds

-> ByteString

value

-> m (f Status)

scard

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

scriptExists

Arguments

:: RedisCtx m f

=> [ByteString]

script

-> m (f [Bool])

sunionstore

Arguments

:: RedisCtx m f

=> ByteString

destination

-> [ByteString]

key

-> m (f Integer)

persist

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Bool)

strlen

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

lpushx

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

value

-> m (f Integer)

hset

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

field

-> ByteString

value

-> m (f Integer)

brpoplpush

Arguments

:: RedisCtx m f

=> ByteString

source

-> ByteString

destination

-> Integer

timeout

-> m (f (Maybe ByteString))

zrevrank

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

member

-> m (f (Maybe Integer))

scriptKill :: RedisCtx m f => m (f Status)

setrange

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

offset

-> ByteString

value

-> m (f Integer)

del

Arguments

:: RedisCtx m f

=> [ByteString]

key

-> m (f Integer)

hincrbyfloat

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

field

-> Double

increment

-> m (f Double)

hincrby

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

field

-> Integer

increment

-> m (f Integer)

zremrangebylex

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

min

-> ByteString

max

-> m (f Integer)

rpop

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f (Maybe ByteString))

rename

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

newkey

-> m (f Status)

zrem

Arguments

:: RedisCtx m f

=> ByteString

key

-> [ByteString]

member

-> m (f Integer)

hexists

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

field

-> m (f Bool)

clientGetname :: RedisCtx m f => m (f Status)

configRewrite :: RedisCtx m f => m (f Status)

decr

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

hmget

Arguments

:: RedisCtx m f

=> ByteString

key

-> [ByteString]

field

-> m (f [Maybe ByteString])

lrange

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

start

-> Integer

stop

-> m (f [ByteString])

decrby

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

decrement

-> m (f Integer)

llen

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

append

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

value

-> m (f Integer)

incr

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

hget

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

field

-> m (f (Maybe ByteString))

pexpireat

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

millisecondsTimestamp

-> m (f Bool)

ltrim

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

start

-> Integer

stop

-> m (f Status)

zcard

Arguments

:: RedisCtx m f

=> ByteString

key

-> m (f Integer)

lset

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

index

-> ByteString

value

-> m (f Status)

expireat

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

timestamp

-> m (f Bool)

save :: RedisCtx m f => m (f Status)

move

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

db

-> m (f Bool)

getbit

Arguments

:: RedisCtx m f

=> ByteString

key

-> Integer

offset

-> m (f Integer)

msetnx

Arguments

:: RedisCtx m f

=> [(ByteString, ByteString)]

keyValue

-> m (f Bool)

commandInfo

Arguments

:: RedisCtx m f

=> [ByteString]

commandName

-> m (f [ByteString])

quit :: RedisCtx m f => m (f Status)

blpop

Arguments

:: RedisCtx m f

=> [ByteString]

key

-> Integer

timeout

-> m (f (Maybe (ByteString, ByteString)))

srem

Arguments

:: RedisCtx m f

=> ByteString

key

-> [ByteString]

member

-> m (f Integer)

echo

Arguments

:: RedisCtx m f

=> ByteString

message

-> m (f ByteString)

sismember

Arguments

:: RedisCtx m f

=> ByteString

key

-> ByteString

member

-> m (f Bool)

data ConnectError

Constructors

ConnectAuthError Reply

ConnectSelectError Reply

Instances

Eq ConnectError

Defined in Database.Redis.Connection

Methods

(==) :: ConnectError -> ConnectError -> Bool

(/=) :: ConnectError -> ConnectError -> Bool

Show ConnectError

Defined in Database.Redis.Connection

Methods

showsPrec :: Int -> ConnectError -> ShowS

show :: ConnectError -> String

showList :: [ConnectError] -> ShowS

Exception ConnectError

Defined in Database.Redis.Connection

Methods

toException :: ConnectError -> SomeException

fromException :: SomeException -> Maybe ConnectError

displayException :: ConnectError -> String

data ConnectInfo

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"}

Constructors

ConnInfo

Fields

• connectHost :: HostName
• connectPort :: PortID
• connectAuth :: Maybe ByteString

  When the server is protected by a password, set connectAuth to Just the password. Each connection will then authenticate by the auth command.

• connectDatabase :: Integer

  Each connection will select the database with the given index.

• connectMaxConnections :: Int

  Maximum number of connections to keep open. The smallest acceptable value is 1.

• connectMaxIdleTime :: NominalDiffTime

  Amount of time for which an unused connection is kept open. The smallest acceptable value is 0.5 seconds. If the timeout value in your redis.conf file is non-zero, it should be larger than connectMaxIdleTime.

• connectTimeout :: Maybe NominalDiffTime

  Optional timeout until connection to Redis gets established. ConnectTimeoutException gets thrown if no socket get connected in this interval of time.

• connectTLSParams :: Maybe ClientParams

  Optional TLS parameters. TLS will be enabled if this is provided.

Instances

Show ConnectInfo

Defined in Database.Redis.Connection

Methods

showsPrec :: Int -> ConnectInfo -> ShowS

show :: ConnectInfo -> String

showList :: [ConnectInfo] -> ShowS

defaultConnectInfo :: ConnectInfo

Default information for connecting:

 connectHost           = "localhost"
 connectPort           = PortNumber 6379 -- Redis default port
 connectAuth           = Nothing         -- No password
 connectDatabase       = 0               -- SELECT database 0
 connectMaxConnections = 50              -- Up to 50 connections
 connectMaxIdleTime    = 30              -- Keep open for 30 seconds
 connectTimeout        = Nothing         -- Don't add timeout logic
 connectTLSParams      = Nothing         -- Do not use TLS

checkedConnect :: ConnectInfo -> IO Connection

Constructs a Connection pool to a Redis server designated by the given ConnectInfo, then tests if the server is actually there. Throws an exception if the connection to the Redis server can't be established.

disconnect :: Connection -> IO ()

Destroy all idle resources in the pool.

withConnect :: (MonadMask m, MonadIO m) => ConnectInfo -> (Connection -> m c) -> m c

Memory bracket around connect and disconnect.

withCheckedConnect :: ConnectInfo -> (Connection -> IO c) -> IO c

Memory bracket around checkedConnect and disconnect

connectCluster :: ConnectInfo -> IO Connection

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 - PUBLISH, SUBSCRIBE, PSUBSCRIBE, UNSUBSCRIBE, PUNSUBSCRIBE, RESET

data PubSubController

A controller that stores a set of channels, pattern channels, and callbacks. It allows you to manage Pub/Sub subscriptions and pattern subscriptions and alter them at any time throughout the life of your program. You should typically create the controller at the start of your program and then store it through the life of your program, using addChannels and removeChannels to update the current subscriptions.

type UnregisterCallbacksAction = IO ()

An action that when executed will unregister the callbacks. It is returned from addChannels or addChannelsAndWait and typically you would use it in bracket to guarantee that you unsubscribe from channels. For example, if you are using websockets to distribute messages to clients, you could use something such as:

websocketConn <- Network.WebSockets.acceptRequest pending
let mycallback msg = Network.WebSockets.sendTextData websocketConn msg
bracket (addChannelsAndWait ctrl [("hello", mycallback)] []) id $ const $ do
  {- loop here calling Network.WebSockets.receiveData -}

type PMessageCallback = RedisChannel -> ByteString -> IO ()

A handler for a message from a psubscribed channel. The callback is passed the channel the message was sent on plus the message content.

Similar to MessageCallback, callbacks are executed synchronously and any exceptions are rethrown from pubSubForever.

type MessageCallback = ByteString -> IO ()

A handler for a message from a subscribed channel. The callback is passed the message content.

Messages are processed synchronously in the receiving thread, so if the callback takes a long time it will block other callbacks and other messages from being received. If you need to move long-running work to a different thread, we suggest you use TBQueue with a reasonable bound, so that if messages are arriving faster than you can process them, you do eventually block.

If the callback throws an exception, the exception will be thrown from pubSubForever which will cause the entire Redis connection for all subscriptions to be closed. As long as you call pubSubForever in a loop you will reconnect to your subscribed channels, but you should probably add an exception handler to each callback to prevent this.

type RedisPChannel = ByteString

A Redis pattern channel name

type RedisChannel = ByteString

A Redis channel name

data Message

Constructors

Message

Fields

• msgChannel, msgMessage :: ByteString

PMessage

Fields

• msgPattern, msgChannel, msgMessage :: ByteString

Instances

Show Message

Defined in Database.Redis.PubSub

Methods

showsPrec :: Int -> Message -> ShowS

show :: Message -> String

showList :: [Message] -> ShowS

data PubSub

Encapsulates subscription changes. Use subscribe, unsubscribe, psubscribe, punsubscribe or mempty to construct a value. Combine values by using the Monoid interface, i.e. mappend and mconcat.

Instances

Eq PubSub

Defined in Database.Redis.PubSub

Methods

(==) :: PubSub -> PubSub -> Bool

(/=) :: PubSub -> PubSub -> Bool

Semigroup PubSub

Defined in Database.Redis.PubSub

Methods

(<>) :: PubSub -> PubSub -> PubSub

sconcat :: NonEmpty PubSub -> PubSub

stimes :: Integral b => b -> PubSub -> PubSub

Monoid PubSub

Defined in Database.Redis.PubSub

Methods

mempty :: PubSub

mappend :: PubSub -> PubSub -> PubSub

mconcat :: [PubSub] -> PubSub

publish

Arguments

:: RedisCtx m f

=> ByteString

channel

-> ByteString

message

-> m (f Integer)

Post a message to a channel (http://redis.io/commands/publish).

subscribe

Arguments

:: [ByteString]

channel

-> PubSub

Listen for messages published to the given channels (http://redis.io/commands/subscribe).

unsubscribe

Arguments

:: [ByteString]

channel

-> PubSub

Stop listening for messages posted to the given channels (http://redis.io/commands/unsubscribe).

psubscribe

Arguments

:: [ByteString]

pattern

-> PubSub

Listen for messages published to channels matching the given patterns (http://redis.io/commands/psubscribe).

punsubscribe

Arguments

:: [ByteString]

pattern

-> PubSub

Stop listening for messages posted to channels matching the given patterns (http://redis.io/commands/punsubscribe).

pubSub

Arguments

:: PubSub

Initial subscriptions.

-> (Message -> IO PubSub)

Callback function.

-> Redis ()

Listens to published messages on subscribed channels and channels matching the subscribed patterns. For documentation on the semantics of Redis Pub/Sub see http://redis.io/topics/pubsub.

The given callback function is called for each received message. Subscription changes are triggered by the returned PubSub. To keep subscriptions unchanged, the callback can return mempty.

Example: Subscribe to the "news" channel indefinitely.

 pubSub (subscribe ["news"]) $ \msg -> do
     putStrLn $ "Message from " ++ show (msgChannel msg)
     return mempty
 

Example: Receive a single message from the "chat" channel.

 pubSub (subscribe ["chat"]) $ \msg -> do
     putStrLn $ "Message from " ++ show (msgChannel msg)
     return $ unsubscribe ["chat"]
 

It should be noted that Redis Pub/Sub by its nature is asynchronous so returning unsubscribe does not mean that callback won't be able to receive any further messages. And to guarantee that you won't won't process messages after unsubscription and won't unsubscribe from the same channel more than once you need to use IORef or something similar

newPubSubController

Arguments

:: MonadIO m

=> [(RedisChannel, MessageCallback)]

the initial subscriptions

-> [(RedisPChannel, PMessageCallback)]

the initial pattern subscriptions

-> m PubSubController

Create a new PubSubController. Note that this does not subscribe to any channels, it just creates the controller. The subscriptions will happen once pubSubForever is called.

currentChannels :: MonadIO m => PubSubController -> m [RedisChannel]

Get the list of current channels in the PubSubController. WARNING! This might not exactly reflect the subscribed channels in the Redis server, because there is a delay between adding or removing a channel in the PubSubController and when Redis receives and processes the subscription change request.

currentPChannels :: MonadIO m => PubSubController -> m [RedisPChannel]

Get the list of current pattern channels in the PubSubController. WARNING! This might not exactly reflect the subscribed channels in the Redis server, because there is a delay between adding or removing a channel in the PubSubController and when Redis receives and processes the subscription change request.

addChannels

Arguments

:: MonadIO m

=> PubSubController

-> [(RedisChannel, MessageCallback)]

the channels to subscribe to

-> [(RedisPChannel, PMessageCallback)]

the channels to pattern subscribe to

-> m UnregisterCallbacksAction

Add channels into the PubSubController, and if there is an active pubSubForever, send the subscribe and psubscribe commands to Redis. The addChannels function is thread-safe. This function does not wait for Redis to acknowledge that the channels have actually been subscribed; use addChannelsAndWait for that.

You can subscribe to the same channel or pattern channel multiple times; the PubSubController keeps a list of callbacks and executes each callback in response to a message.

The return value is an action UnregisterCallbacksAction which will unregister the callbacks, which should typically used with bracket.

addChannelsAndWait

Arguments

:: MonadIO m

=> PubSubController

-> [(RedisChannel, MessageCallback)]

the channels to subscribe to

-> [(RedisPChannel, PMessageCallback)]

the channels to psubscribe to

-> m UnregisterCallbacksAction

Call addChannels and then wait for Redis to acknowledge that the channels are actually subscribed.

Note that this function waits for all pending subscription change requests, so if you for example call addChannelsAndWait from multiple threads simultaneously, they all will wait for all pending subscription changes to be acknowledged by Redis (this is due to the fact that we just track the total number of pending change requests sent to Redis and just wait until that count reaches zero).

This also correctly waits if the network connection dies during the subscription change. Say that the network connection dies right after we send a subscription change to Redis. pubSubForever will throw ConnectionLost and addChannelsAndWait will continue to wait. Once you recall pubSubForever with the same PubSubController, pubSubForever will open a new connection, send subscription commands for all channels in the PubSubController (which include the ones we are waiting for), and wait for the responses from Redis. Only once we receive the response from Redis that it has subscribed to all channels in PubSubController will addChannelsAndWait unblock and return.

removeChannels :: MonadIO m => PubSubController -> [RedisChannel] -> [RedisPChannel] -> m ()

Remove channels from the PubSubController, and if there is an active pubSubForever, send the unsubscribe commands to Redis. Note that as soon as this function returns, no more callbacks will be executed even if more messages arrive during the period when we request to unsubscribe from the channel and Redis actually processes the unsubscribe request. This function is thread-safe.

If you remove all channels, the connection in pubSubForever to redis will stay open and waiting for any new channels from a call to addChannels. If you really want to close the connection, use killThread or cancel to kill the thread running pubSubForever.

removeChannelsAndWait :: MonadIO m => PubSubController -> [RedisChannel] -> [RedisPChannel] -> m ()

Call removeChannels and then wait for all pending subscription change requests to be acknowledged by Redis. This uses the same waiting logic as addChannelsAndWait. Since removeChannels immediately notifies the PubSubController to start discarding messages, you likely don't need this function and can just use removeChannels.

pubSubForever

Arguments

:: Connection

The connection pool

-> PubSubController

The controller which keeps track of all subscriptions and handlers

-> IO ()

This action is executed once Redis acknowledges that all the subscriptions in the controller are now subscribed. You can use this after an exception (such as ConnectionLost) to signal that all subscriptions are now reactivated.

-> IO ()

Open a connection to the Redis server, register to all channels in the PubSubController, and process messages and subscription change requests forever. The only way this will ever exit is if there is an exception from the network code or an unhandled exception in a MessageCallback or PMessageCallback. For example, if the network connection to Redis dies, pubSubForever will throw a ConnectionLost. When such an exception is thrown, you can recall pubSubForever with the same PubSubController which will open a new connection and resubscribe to all the channels which are tracked in the PubSubController.

The general pattern is therefore during program startup create a PubSubController and fork a thread which calls pubSubForever in a loop (using an exponential backoff algorithm such as the retry package to not hammer the Redis server if it does die). For example,

myhandler :: ByteString -> IO ()
myhandler msg = putStrLn $ unpack $ decodeUtf8 msg

onInitialComplete :: IO ()
onInitialComplete = putStrLn "Redis acknowledged that mychannel is now subscribed"

main :: IO ()
main = do
  conn <- connect defaultConnectInfo
  pubSubCtrl <- newPubSubController [("mychannel", myhandler)] []
  forkIO $ forever $
      pubSubForever conn pubSubCtrl onInitialComplete
        `catch` (\(e :: SomeException) -> do
          putStrLn $ "Got error: " ++ show e
          threadDelay $ 50*1000) -- TODO: use exponential backoff

  {- elsewhere in your program, use pubSubCtrl to change subscriptions -}

At most one active pubSubForever can be running against a single PubSubController at any time. If two active calls to pubSubForever share a single PubSubController there will be deadlocks. If you do want to process messages using multiple connections to Redis, you can create more than one PubSubController. For example, create one PubSubController for each getNumCapabilities and then create a Haskell thread bound to each capability each calling pubSubForever in a loop. This will create one network connection per controller/capability and allow you to register separate channels and callbacks for each controller, spreading the load across the capabilities.

parseConnectInfo :: String -> Either String ConnectInfo

Parse a ConnectInfo from a URL

Username is ignored, path is used to specify the database:

>>> parseConnectInfo "redis://username:password@host:42/2"
Right (ConnInfo {connectHost = "host", connectPort = PortNumber 42, connectAuth = Just "password", connectDatabase = 2, connectMaxConnections = 50, connectMaxIdleTime = 30s, connectTimeout = Nothing, connectTLSParams = Nothing})

>>> 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"

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

>>> parseConnectInfo "redis://"
Right (ConnInfo {connectHost = "localhost", connectPort = PortNumber 6379, connectAuth = Nothing, connectDatabase = 0, connectMaxConnections = 50, connectMaxIdleTime = 30s, connectTimeout = Nothing, connectTLSParams = Nothing})