Struct Connection

pub struct Connection { /* private fields */ }

Wrapper around redis::aio::MultiplexedConnection.

This structure implements redis::aio::ConnectionLike and can therefore be used just like a regular redis::aio::MultiplexedConnection.

Implementations

impl Connection

pub fn take(this: Self) -> MultiplexedConnection

Takes this Connection from its Pool permanently.

This reduces the size of the Pool.

Methods from Deref<Target = MultiplexedConnection>

pub fn set_response_timeout(&mut self, timeout: Duration)

Sets the time that the multiplexer will wait for responses on operations before failing.

pub async fn send_packed_command( &mut self, cmd: &Cmd, ) -> Result<Value, RedisError>

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

pub async fn send_packed_commands( &mut self, cmd: &Pipeline, offset: usize, count: usize, ) -> Result<Vec<Value>, RedisError>

Sends multiple already encoded (packed) command into the TCP socket and reads count responses from it. This is used to implement pipelining.

pub fn get_cache_statistics(&self) -> Option<CacheStatistics>

Gets CacheStatistics for current connection if caching is enabled.

pub async fn subscribe( &mut self, channel_name: impl ToRedisArgs, ) -> Result<(), RedisError>

Subscribes to a new channel(s).

Updates from the sender will be sent on the push sender that was passed to the connection. If the connection was configured without a push sender, the connection won’t be able to pass messages back to the user.

This method is only available when the connection is using RESP3 protocol, and will return an error otherwise.

let client = redis::Client::open("redis://127.0.0.1/?protocol=resp3").unwrap();
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let config = redis::AsyncConnectionConfig::new().set_push_sender(tx);
let mut con = client.get_multiplexed_async_connection_with_config(&config).await?;
con.subscribe(&["channel_1", "channel_2"]).await?;

pub async fn unsubscribe( &mut self, channel_name: impl ToRedisArgs, ) -> Result<(), RedisError>

Unsubscribes from channel(s).

This method is only available when the connection is using RESP3 protocol, and will return an error otherwise.

let client = redis::Client::open("redis://127.0.0.1/?protocol=resp3").unwrap();
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let config = redis::AsyncConnectionConfig::new().set_push_sender(tx);
let mut con = client.get_multiplexed_async_connection_with_config(&config).await?;
con.subscribe(&["channel_1", "channel_2"]).await?;
con.unsubscribe(&["channel_1", "channel_2"]).await?;

pub async fn psubscribe( &mut self, channel_pattern: impl ToRedisArgs, ) -> Result<(), RedisError>

Subscribes to new channel(s) with pattern(s).

Updates from the sender will be sent on the push sender that was passed to the connection. If the connection was configured without a push sender, the connection won’t be able to pass messages back to the user.

This method is only available when the connection is using RESP3 protocol, and will return an error otherwise.

let client = redis::Client::open("redis://127.0.0.1/?protocol=resp3").unwrap();
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let config = redis::AsyncConnectionConfig::new().set_push_sender(tx);
let mut con = client.get_multiplexed_async_connection_with_config(&config).await?;
con.subscribe(&["channel_1", "channel_2"]).await?;
con.unsubscribe(&["channel_1", "channel_2"]).await?;

pub async fn punsubscribe( &mut self, channel_pattern: impl ToRedisArgs, ) -> Result<(), RedisError>

Unsubscribes from channel pattern(s).

This method is only available when the connection is using RESP3 protocol, and will return an error otherwise.

Trait Implementations

impl AsMut<MultiplexedConnection> for Connection

fn as_mut(&mut self) -> &mut MultiplexedConnection

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<MultiplexedConnection> for Connection

fn as_ref(&self) -> &MultiplexedConnection

Converts this type into a shared reference of the (usually inferred) input type.

impl ConnectionLike for Connection

fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, 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.

impl Deref for Connection

type Target = MultiplexedConnection

The resulting type after dereferencing.

fn deref(&self) -> &MultiplexedConnection

Dereferences the value.

impl DerefMut for Connection

fn deref_mut(&mut self) -> &mut MultiplexedConnection

Mutably dereferences the value.

impl From<Object<Manager>> for Connection

fn from(conn: Object) -> Self

Converts to this type from the input type.