Struct fred::clients::SentinelClient

pub struct SentinelClient { /* private fields */ }

Available on crate feature sentinel-client only.

A struct for interacting directly with Sentinel nodes.

This struct will not communicate with Redis servers behind the sentinel interface, but rather with the sentinel nodes themselves. Callers should use the RedisClient interface with a ServerConfig::Sentinel for interacting with Redis services behind a sentinel layer.

See the sentinel API docs for more information.

Implementations

impl SentinelClient

pub fn new(config: SentinelConfig) -> SentinelClient

Create a new client instance without connecting to the sentinel node.

pub fn on_reconnect(&self) -> impl Stream<Item = Self>

Listen for reconnection notifications.

This function can be used to receive notifications whenever the client successfully reconnects.

A reconnection event is also triggered upon first connecting to the server.

Trait Implementations

impl AclInterface for SentinelClient

fn acl_setuser<S>(&self, username: S, rules: Vec<AclRule>) -> AsyncResult<()> where
    S: Into<Str>, 

Create an ACL user with the specified rules or modify the rules of an existing user.

fn acl_load(&self) -> AsyncResult<()>

When Redis is configured to use an ACL file (with the aclfile configuration option), this command will reload the ACLs from the file, replacing all the current ACL rules with the ones defined in the file.

fn acl_save(&self) -> AsyncResult<()>

When Redis is configured to use an ACL file (with the aclfile configuration option), this command will save the currently defined ACLs from the server memory to the ACL file.

fn acl_list<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The command shows the currently active ACL rules in the Redis server.

fn acl_users<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The command shows a list of all the usernames of the currently configured users in the Redis ACL system.

fn acl_getuser<S>(&self, username: S) -> AsyncResult<Option<AclUser>> where
    S: Into<Str>, 

The command returns all the rules defined for an existing ACL user.

fn acl_deluser<R, S>(&self, usernames: S) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<MultipleStrings>, 

Delete all the specified ACL users and terminate all the connections that are authenticated with such users.

fn acl_cat(&self, category: Option<Str>) -> AsyncResult<Vec<String>>

The command shows the available ACL categories if called without arguments. If a category name is given, the command shows all the Redis commands in the specified category.

fn acl_genpass(&self, bits: Option<u16>) -> AsyncResult<String>

Generate a password with length bits, returning the password.

fn acl_whoami(&self) -> AsyncResult<String>

Return the username the current connection is authenticated with. New connections are authenticated with the “default” user.

fn acl_log_count(&self, count: Option<u32>) -> AsyncResult<RedisValue>

Read count recent ACL security events.

fn acl_log_reset(&self) -> AsyncResult<()>

Clear the ACL security events logs.

impl AuthInterface for SentinelClient

fn auth<S>(&self, username: Option<String>, password: S) -> AsyncResult<()> where
    S: Into<Str>, 

Request for authentication in a password-protected Redis server. Returns ok if successful.

fn hello(
    &self,
    version: RespVersion,
    auth: Option<(String, String)>
) -> AsyncResult<()>

Switch to a different protocol, optionally authenticating in the process.

impl ClientInterface for SentinelClient

fn client_id<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Return the ID of the current connection.

fn connection_ids(&self) -> AsyncResult<HashMap<Arc<String>, i64>>

Read the connection IDs for the active connections to each server.

fn update_sentinel_nodes(&self) -> AsyncResult<()>

Force update the client’s sentinel nodes list if using the sentinel interface.

fn client_info<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The command returns information and statistics about the current client connection in a mostly human readable format.

fn client_kill<R>(&self, filters: Vec<ClientKillFilter>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Close a given connection or set of connections.

fn client_list<R, I>(
    &self,
    type: Option<ClientKillType>,
    ids: Option<Vec<String>>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The CLIENT LIST command returns information and statistics about the client connections server in a mostly human readable format.

fn client_getname<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

The CLIENT GETNAME returns the name of the current connection as set by CLIENT SETNAME.

fn client_setname<S>(&self, name: S) -> AsyncResult<()> where
    S: Into<Str>, 

Assign a name to the current connection.

fn client_pause(
    &self,
    timeout: i64,
    mode: Option<ClientPauseKind>
) -> AsyncResult<()>

CLIENT PAUSE is a connections control command able to suspend all the Redis clients for the specified amount of time (in milliseconds).

fn client_unpause(&self) -> AsyncResult<()>

CLIENT UNPAUSE is used to resume command processing for all clients that were paused by CLIENT PAUSE.

fn client_reply(&self, flag: ClientReplyFlag) -> AsyncResult<()>

The CLIENT REPLY command controls whether the server will reply the client’s commands. The following modes are available:

fn client_unblock<R, S>(
    &self,
    id: S,
    flag: Option<ClientUnblockFlag>
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<RedisValue>, 

This command can unblock, from a different connection, a client blocked in a blocking operation, such as for instance BRPOP or XREAD or WAIT.

fn unblock_self(&self, flag: Option<ClientUnblockFlag>) -> AsyncResult<()>

A convenience function to unblock any blocked connection on this client.

impl ClientLike for SentinelClient

fn id(&self) -> &Arc<String>

The unique ID identifying this client and underlying connections.

fn client_config(&self) -> RedisConfig

Read the config used to initialize the client.

fn client_reconnect_policy(&self) -> Option<ReconnectPolicy>

Read the reconnect policy used to initialize the client.

fn protocol_version(&self) -> RespVersion

Read the RESP version used by the client when communicating with the server.

fn has_reconnect_policy(&self) -> bool

Whether or not the client has a reconnection policy.

fn is_pipelined(&self) -> bool

Whether or not the client will automatically pipeline commands.

fn update_perf_config(&self, config: PerformanceConfig)

Update the internal PerformanceConfig in place with new values.

fn state(&self) -> ClientState

Read the state of the underlying connection(s).

fn is_connected(&self) -> bool

Whether or not the client has an active connection to the server(s).

fn connect(&self, policy: Option<ReconnectPolicy>) -> ConnectHandle

Connect to the Redis server with an optional reconnection policy.

fn wait_for_connect(&self) -> AsyncResult<()>

Wait for the client to connect to the server, or return an error if the initial connection cannot be established. If the client is already connected this future will resolve immediately.

fn on_error(&self) -> AsyncStream<RedisError>

Listen for protocol and connection errors. This stream can be used to more intelligently handle errors that may not appear in the request-response cycle, and so cannot be handled by response futures.

fn quit(&self) -> AsyncResult<()>

Close the connection to the Redis server. The returned future resolves when the command has been written to the socket, not when the connection has been fully closed. Some time after this future resolves the future returned by connect will resolve which indicates that the connection has been fully closed.

fn shutdown(&self, flags: Option<ShutdownFlags>) -> AsyncResult<()>

Shut down the server and quit the client.

fn ping(&self) -> AsyncResult<()>

Ping the Redis server.

fn info<R>(&self, section: Option<InfoKind>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Read info about the server.

fn custom<R, T>(&self, cmd: CustomCommand, args: Vec<T>) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    T: TryInto<RedisValue>,
    T::Error: Into<RedisError>, 

Run a custom command that is not yet supported via another interface on this client. This is most useful when interacting with third party modules or extensions.

fn custom_raw<T>(
    &self,
    cmd: CustomCommand,
    args: Vec<T>
) -> AsyncResult<Resp3Frame> where
    T: TryInto<RedisValue>,
    T::Error: Into<RedisError>, 

Run a custom command similar to custom, but return the response frame directly without any parsing.

impl Clone for SentinelClient

fn clone(&self) -> SentinelClient

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Display for SentinelClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HeartbeatInterface for SentinelClient

fn enable_heartbeat(
    &self,
    interval: Duration,
    break_on_error: bool
) -> AsyncResult<()>

Return a future that will ping the server on an interval.

impl MetricsInterface for SentinelClient

fn read_redelivery_count(&self) -> usize

Read the number of request redeliveries.

fn take_redelivery_count(&self) -> usize

Read and reset the number of request redeliveries.

fn command_queue_len(&self) -> usize

Read the number of buffered commands that have not yet been sent to the server.

fn read_latency_metrics(&self) -> Stats

Available on crate feature metrics only.

Read latency metrics across all commands.

fn take_latency_metrics(&self) -> Stats

Available on crate feature metrics only.

Read and consume latency metrics, resetting their values afterwards.

fn read_network_latency_metrics(&self) -> Stats

Available on crate feature metrics only.

Read network latency metrics across all commands.

fn take_network_latency_metrics(&self) -> Stats

Available on crate feature metrics only.

Read and consume network latency metrics, resetting their values afterwards.

fn read_req_size_metrics(&self) -> Stats

Available on crate feature metrics only.

Read request payload size metrics across all commands.

fn take_req_size_metrics(&self) -> Stats

Available on crate feature metrics only.

Read and consume request payload size metrics, resetting their values afterwards.

fn read_res_size_metrics(&self) -> Stats

Available on crate feature metrics only.

Read response payload size metrics across all commands.

fn take_res_size_metrics(&self) -> Stats

Available on crate feature metrics only.

Read and consume response payload size metrics, resetting their values afterwards.

impl PubsubInterface for SentinelClient

fn on_message(&self) -> AsyncStream<(String, RedisValue)>

Listen for (channel, message) tuples on the publish-subscribe interface. Keyspace events are not sent on this interface.

fn on_keyspace_event(&self) -> AsyncStream<KeyspaceEvent>

Listen for keyspace and keyevent notifications on the publish subscribe interface.

fn subscribe<S>(&self, channel: S) -> AsyncResult<usize> where
    S: Into<Str>, 

Subscribe to a channel on the PubSub interface, returning the number of channels to which the client is subscribed.

fn unsubscribe<S>(&self, channel: S) -> AsyncResult<usize> where
    S: Into<Str>, 

Unsubscribe from a channel on the PubSub interface, returning the number of channels to which hte client is subscribed.

fn psubscribe<S>(&self, patterns: S) -> AsyncResult<Vec<usize>> where
    S: Into<MultipleStrings>, 

Subscribes the client to the given patterns.

fn punsubscribe<S>(&self, patterns: S) -> AsyncResult<Vec<usize>> where
    S: Into<MultipleStrings>, 

Unsubscribes the client from the given patterns, or from all of them if none is given.

fn publish<R, S, V>(&self, channel: S, message: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    S: Into<Str>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Publish a message on the PubSub interface, returning the number of clients that received the message.

impl SentinelInterface for SentinelClient

fn ckquorum<R, N>(&self, name: N) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    N: Into<Str>, 

Check if the current Sentinel configuration is able to reach the quorum needed to failover a master, and the majority needed to authorize the failover.

fn flushconfig<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Force Sentinel to rewrite its configuration on disk, including the current Sentinel state.

fn failover<R, N>(&self, name: N) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    N: Into<Str>, 

Force a failover as if the master was not reachable, and without asking for agreement to other Sentinels.

fn get_master_addr_by_name<R, N>(&self, name: N) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    N: Into<Str>, 

Return the ip and port number of the master with that name.

fn info_cache<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Return cached INFO output from masters and replicas.

fn master<R, N>(&self, name: N) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    N: Into<Str>, 

Show the state and info of the specified master.

fn masters<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Show a list of monitored masters and their state.

fn monitor<R, N>(
    &self,
    name: N,
    ip: IpAddr,
    port: u16,
    quorum: u32
) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    N: Into<Str>, 

Start Sentinel’s monitoring.

fn myid<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

Return the ID of the Sentinel instance.

fn pending_scripts<R>(&self) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

This command returns information about pending scripts.

fn remove<R, N>(&self, name: N) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    N: Into<Str>, 

Stop Sentinel’s monitoring.

fn replicas<R, N>(&self, name: N) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    N: Into<Str>, 

Show a list of replicas for this master, and their state.

fn sentinels<R, N>(&self, name: N) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    N: Into<Str>, 

Show a list of sentinel instances for this master, and their state.

fn set<R, N, V>(&self, name: N, args: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    N: Into<Str>,
    V: TryInto<RedisMap>,
    V::Error: Into<RedisError>, 

Set Sentinel’s monitoring configuration.

fn simulate_failure<R>(&self, kind: SentinelFailureKind) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send, 

This command simulates different Sentinel crash scenarios.

fn reset<R, P>(&self, pattern: P) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    P: Into<Str>, 

This command will reset all the masters with matching name.

fn config_get<R, K>(&self, name: K) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<Str>, 

Get the current value of a global Sentinel configuration parameter. The specified name may be a wildcard, similar to the Redis CONFIG GET command.

fn config_set<R, K, V>(&self, name: K, value: V) -> AsyncResult<R> where
    R: FromRedis + Unpin + Send,
    K: Into<Str>,
    V: TryInto<RedisValue>,
    V::Error: Into<RedisError>, 

Set the value of a global Sentinel configuration parameter.