Struct Client 

pub struct Client { /* private fields */ }

Redis’ own client, re-exported so from_client needs no direct dependency. 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>(params: T) -> Result<Client, RedisError>

where T: IntoConnectionInfo,

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) -> Result<Connection, RedisError>

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, ) -> Result<Connection, RedisError>

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.

pub fn build_with_tls<C>( conn_info: C, tls_certs: TlsCertificates, ) -> Result<Client, RedisError>

where C: IntoConnectionInfo,

Available on crate feature tls-rustls only.

Constructs a new Client with parameters necessary to create a TLS connection.

• conn_info - URL using the rediss:// scheme.
• tls_certs - TlsCertificates structure containing:
  • client_tls - Optional ClientTlsConfig containing byte streams for
    • client_cert - client’s byte stream containing client certificate in PEM format
    • client_key - client’s byte stream containing private key in PEM format
  • root_cert - Optional byte stream yielding PEM formatted file for root certificates.

If ClientTlsConfig ( cert+key pair ) is not provided, then client-side authentication is not enabled. If root_cert is not provided, then system root certificates are used instead.

Examples

use std::{fs::File, io::{BufReader, Read}};

use redis::{Client, AsyncTypedCommands as _, TlsCertificates, ClientTlsConfig};

async fn do_redis_code(
    url: &str,
    root_cert_file: &str,
    cert_file: &str,
    key_file: &str
) -> redis::RedisResult<()> {
    let root_cert_file = File::open(root_cert_file).expect("cannot open private cert file");
    let mut root_cert_vec = Vec::new();
    BufReader::new(root_cert_file)
        .read_to_end(&mut root_cert_vec)
        .expect("Unable to read ROOT cert file");

    let cert_file = File::open(cert_file).expect("cannot open private cert file");
    let mut client_cert_vec = Vec::new();
    BufReader::new(cert_file)
        .read_to_end(&mut client_cert_vec)
        .expect("Unable to read client cert file");

    let key_file = File::open(key_file).expect("cannot open private key file");
    let mut client_key_vec = Vec::new();
    BufReader::new(key_file)
        .read_to_end(&mut client_key_vec)
        .expect("Unable to read client key file");

    let client = Client::build_with_tls(
        url,
        TlsCertificates {
            client_tls: Some(ClientTlsConfig{
                client_cert: client_cert_vec,
                client_key: client_key_vec,
            }),
            root_cert: Some(root_cert_vec),
        }
    )
    .expect("Unable to build client");

    let connection_info = client.get_connection_info();

    println!(">>> connection info: {connection_info:?}");

    let mut con = client.get_multiplexed_async_connection().await?;

    con.set("key1", b"foo").await?;

    redis::cmd("SET")
        .arg(&["key2", "bar"])
        .exec_async(&mut con)
        .await?;

    let result = redis::cmd("MGET")
        .arg(&["key1", "key2"])
        .query_async(&mut con)
        .await;
    assert_eq!(result, Ok(("foo".to_string(), b"bar".to_vec())));
    println!("Result from MGET: {result:?}");

    Ok(())
}

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate 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]) -> Result<Value, RedisError>

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) -> Result<Value, RedisError>

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<(), Error>

Formats the value using the given formatter.