Struct mini_redis::client::Client

pub struct Client { /* fields omitted */ }

Established connection with a Redis server.

Backed by a single TcpStream, Client provides basic network client functionality (no pooling, retrying, ...). Connections are established using the connect function.

Requests are issued using the various methods of Client.

Implementations

impl Client

pub async fn get<'_, '_>(&'_ mut self, key: &'_ str) -> Result<Option<Bytes>>

Get the value of key.

If the key does not exist the special value None is returned.

Examples

Demonstrates basic usage.

use mini_redis::client;

#[tokio::main]
async fn main() {
    let mut client = client::connect("localhost:6379").await.unwrap();

    let val = client.get("foo").await.unwrap();
    println!("Got = {:?}", val);
}

pub async fn set<'_, '_>(&'_ mut self, key: &'_ str, value: Bytes) -> Result<()>

Set key to hold the given value.

The value is associated with key until it is overwritten by the next call to set or it is removed.

If key already holds a value, it is overwritten. Any previous time to live associated with the key is discarded on successful SET operation.

Examples

Demonstrates basic usage.

use mini_redis::client;

#[tokio::main]
async fn main() {
    let mut client = client::connect("localhost:6379").await.unwrap();

    client.set("foo", "bar".into()).await.unwrap();

    // Getting the value immediately works
    let val = client.get("foo").await.unwrap().unwrap();
    assert_eq!(val, "bar");
}

pub async fn set_expires<'_, '_>(
    &'_ mut self,
    key: &'_ str,
    value: Bytes,
    expiration: Duration
) -> Result<()>

Set key to hold the given value. The value expires after expiration

The value is associated with key until one of the following:

• it expires.
• it is overwritten by the next call to set.
• it is removed.

If key already holds a value, it is overwritten. Any previous time to live associated with the key is discarded on a successful SET operation.

Examples

Demonstrates basic usage. This example is not guaranteed to always work as it relies on time based logic and assumes the client and server stay relatively synchronized in time. The real world tends to not be so favorable.

use mini_redis::client;
use tokio::time;
use std::time::Duration;

#[tokio::main]
async fn main() {
    let ttl = Duration::from_millis(500);
    let mut client = client::connect("localhost:6379").await.unwrap();

    client.set_expires("foo", "bar".into(), ttl).await.unwrap();

    // Getting the value immediately works
    let val = client.get("foo").await.unwrap().unwrap();
    assert_eq!(val, "bar");

    // Wait for the TTL to expire
    time::sleep(ttl).await;

    let val = client.get("foo").await.unwrap();
    assert!(val.is_some());
}

pub async fn publish<'_, '_>(
    &'_ mut self,
    channel: &'_ str,
    message: Bytes
) -> Result<u64>

Posts message to the given channel.

Returns the number of subscribers currently listening on the channel. There is no guarantee that these subscribers receive the message as they may disconnect at any time.

Examples

Demonstrates basic usage.

use mini_redis::client;

#[tokio::main]
async fn main() {
    let mut client = client::connect("localhost:6379").await.unwrap();

    let val = client.publish("foo", "bar".into()).await.unwrap();
    println!("Got = {:?}", val);
}

pub async fn subscribe(self, channels: Vec<String>) -> Result<Subscriber>

Subscribes the client to the specified channels.

Once a client issues a subscribe command, it may no longer issue any non-pub/sub commands. The function consumes self and returns a Subscriber.

The Subscriber value is used to receive messages as well as manage the list of channels the client is subscribed to.