Struct Client

pub struct Client { /* private fields */ }

The client type.

Implementations

impl Client

The client acts as connector to the redis server. By itself it does not do much other than providing a convenient way to fetch a connection from it. In the future the plan is to provide a connection pool in the client.

When opening a client a URL in the following format should be used:

redis://host:port/db

Example usage::

let client = redis::Client::open("redis://127.0.0.1/").unwrap();
let con = client.get_connection().unwrap();

pub fn open<T: IntoConnectionInfo>(params: T) -> RedisResult<Client>

Connects to a redis server and returns a client. This does not actually open a connection yet but it does perform some basic checks on the URL that might make the operation fail.

pub fn get_connection(&self) -> RedisResult<Connection>

Instructs the client to actually connect to redis and returns a connection object. The connection object can be used to send commands to the server. This can fail with a variety of errors (like unreachable host) so it’s important that you handle those errors.

pub fn get_connection_with_timeout( &self, timeout: Duration, ) -> RedisResult<Connection>

Instructs the client to actually connect to redis with specified timeout and returns a connection object. The connection object can be used to send commands to the server. This can fail with a variety of errors (like unreachable host) so it’s important that you handle those errors.

pub fn get_connection_info(&self) -> &ConnectionInfo

Returns a reference of client connection info object.

impl Client

To enable async support you need to chose one of the supported runtimes and active its corresponding feature: tokio-comp or async-std-comp

pub async fn get_async_connection(&self) -> RedisResult<Connection>

👎Deprecated: aio::Connection is deprecated. Use client::get_multiplexed_async_connection instead.

Returns an async connection from the client.

pub async fn get_tokio_connection(&self) -> RedisResult<Connection>

👎Deprecated: aio::Connection is deprecated. Use client::get_multiplexed_async_connection instead.

Returns an async connection from the client.

pub async fn get_multiplexed_async_connection( &self, ) -> RedisResult<MultiplexedConnection>

Returns an async connection from the client.

pub async fn get_multiplexed_async_connection_with_timeouts( &self, response_timeout: Duration, connection_timeout: Duration, ) -> RedisResult<MultiplexedConnection>

👎Deprecated: Use get_multiplexed_async_connection_with_config instead

Returns an async connection from the client.

pub async fn get_multiplexed_async_connection_with_config( &self, config: &AsyncConnectionConfig, ) -> RedisResult<MultiplexedConnection>

Returns an async connection from the client.

pub async fn get_multiplexed_tokio_connection_with_response_timeouts( &self, response_timeout: Duration, connection_timeout: Duration, ) -> RedisResult<MultiplexedConnection>

Returns an async multiplexed connection from the client.

A multiplexed connection can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket).

pub async fn get_multiplexed_tokio_connection( &self, ) -> RedisResult<MultiplexedConnection>

Returns an async multiplexed connection from the client.

A multiplexed connection can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket).

pub async fn create_multiplexed_tokio_connection_with_response_timeout( &self, response_timeout: Duration, ) -> RedisResult<(MultiplexedConnection, impl Future<Output = ()>)>

Returns an async multiplexed connection from the client and a future which must be polled to drive any requests submitted to it (see Self::get_multiplexed_async_connection).

A multiplexed connection can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket). The multiplexer will return a timeout error on any request that takes longer then response_timeout.

pub async fn create_multiplexed_tokio_connection( &self, ) -> RedisResult<(MultiplexedConnection, impl Future<Output = ()>)>

Returns an async multiplexed connection from the client and a future which must be polled to drive any requests submitted to it (see Self::get_multiplexed_async_connection).

A multiplexed connection can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket).

pub async fn get_tokio_connection_manager( &self, ) -> RedisResult<ConnectionManager>

👎Deprecated: use get_connection_manager instead

Returns an async ConnectionManager from the client.

The connection manager wraps a MultiplexedConnection. If a command to that connection fails with a connection error, then a new connection is established in the background and the error is returned to the caller.

This means that on connection loss at least one command will fail, but the connection will be re-established automatically if possible. Please refer to the ConnectionManager docs for detailed reconnecting behavior.

A connection manager can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket).

pub async fn get_connection_manager(&self) -> RedisResult<ConnectionManager>

Returns an async ConnectionManager from the client.

The connection manager wraps a MultiplexedConnection. If a command to that connection fails with a connection error, then a new connection is established in the background and the error is returned to the caller.

This means that on connection loss at least one command will fail, but the connection will be re-established automatically if possible. Please refer to the ConnectionManager docs for detailed reconnecting behavior.

A connection manager can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket).

pub async fn get_tokio_connection_manager_with_backoff( &self, exponent_base: u64, factor: u64, number_of_retries: usize, ) -> RedisResult<ConnectionManager>

👎Deprecated: Use get_connection_manager_with_config instead

Returns an async ConnectionManager from the client.

The connection manager wraps a MultiplexedConnection. If a command to that connection fails with a connection error, then a new connection is established in the background and the error is returned to the caller.

This means that on connection loss at least one command will fail, but the connection will be re-established automatically if possible. Please refer to the ConnectionManager docs for detailed reconnecting behavior.

A connection manager can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket).

pub async fn get_tokio_connection_manager_with_backoff_and_timeouts( &self, exponent_base: u64, factor: u64, number_of_retries: usize, response_timeout: Duration, connection_timeout: Duration, ) -> RedisResult<ConnectionManager>

👎Deprecated: Use get_connection_manager_with_config instead

Returns an async ConnectionManager from the client.

The connection manager wraps a MultiplexedConnection. If a command to that connection fails with a connection error, then a new connection is established in the background and the error is returned to the caller.

This means that on connection loss at least one command will fail, but the connection will be re-established automatically if possible. Please refer to the ConnectionManager docs for detailed reconnecting behavior.

A connection manager can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket).

pub async fn get_connection_manager_with_backoff_and_timeouts( &self, exponent_base: u64, factor: u64, number_of_retries: usize, response_timeout: Duration, connection_timeout: Duration, ) -> RedisResult<ConnectionManager>

👎Deprecated: Use get_connection_manager_with_config instead

Returns an async ConnectionManager from the client.

The connection manager wraps a MultiplexedConnection. If a command to that connection fails with a connection error, then a new connection is established in the background and the error is returned to the caller.

This means that on connection loss at least one command will fail, but the connection will be re-established automatically if possible. Please refer to the ConnectionManager docs for detailed reconnecting behavior.

A connection manager can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket).

pub async fn get_connection_manager_with_config( &self, config: ConnectionManagerConfig, ) -> RedisResult<ConnectionManager>

Returns an async ConnectionManager from the client.

The connection manager wraps a MultiplexedConnection. If a command to that connection fails with a connection error, then a new connection is established in the background and the error is returned to the caller.

This means that on connection loss at least one command will fail, but the connection will be re-established automatically if possible. Please refer to the ConnectionManager docs for detailed reconnecting behavior.

A connection manager can be cloned, allowing requests to be sent concurrently on the same underlying connection (tcp/unix socket).

pub async fn get_connection_manager_with_backoff( &self, exponent_base: u64, factor: u64, number_of_retries: usize, ) -> RedisResult<ConnectionManager>

👎Deprecated: Use get_connection_manager_with_config instead

Returns an async ConnectionManager from the client.

The connection manager wraps a MultiplexedConnection. If a command to that connection fails with a connection error, then a new connection is established in the background and the error is returned to the caller.

This means that on connection loss at least one command will fail, but the connection will be re-established automatically if possible. Please refer to the ConnectionManager docs for detailed reconnecting behavior.

A connection manager can be cloned, allowing requests to be be sent concurrently on the same underlying connection (tcp/unix socket).

pub async fn get_async_pubsub(&self) -> RedisResult<PubSub>

Returns an async receiver for pub-sub messages.

pub async fn get_async_monitor(&self) -> RedisResult<Monitor>

Returns an async receiver for monitor messages.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ConnectionLike for Client

fn req_packed_command(&mut self, cmd: &[u8]) -> RedisResult<Value>

Sends an already encoded (packed) command into the TCP socket and reads the single response from it.

fn get_db(&self) -> i64

Returns the database this connection is bound to. Note that this information might be unreliable because it’s initially cached and also might be incorrect if the connection like object is not actually connected.

fn check_connection(&mut self) -> bool

Check that all connections it has are available (PING internally).

fn is_open(&self) -> bool

Returns the connection status.

fn req_command(&mut self, cmd: &Cmd) -> RedisResult<Value>

Sends a Cmd into the TCP socket and reads a single response from it.

impl Debug for Client

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

Formats the value using the given formatter.