rustis 0.19.3

Redis async driver for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use criterion::{Bencher, Criterion, criterion_group, criterion_main};
use futures_util::Future;
use std::time::Duration;

pub fn current_thread_runtime() -> tokio::runtime::Runtime {
    let mut builder = tokio::runtime::Builder::new_current_thread();
    builder.enable_io();
    builder.enable_time();
    builder.build().unwrap()
}

pub fn block_on_all<F>(f: F) -> F::Output
where
    F: Future,
{
    current_thread_runtime().block_on(f)
}

fn get_redis_host() -> String {
    std::env::var("REDIS_HOST").unwrap_or_else(|_| "127.0.0.1".to_string())
}

fn get_redis_client() -> redis::Client {
    let redis_host = get_redis_host();
    redis::Client::open(format!("redis://{redis_host}:6379")).unwrap()
}

async fn get_rustis_client() -> rustis::client::Client {
    let redis_host = get_redis_host();
    rustis::client::Client::connect(redis_host).await.unwrap()
}

async fn get_fred_client() -> fred::clients::Client {
    use fred::prelude::*;

    let redis_host = get_redis_host();
    let config = Config::from_url(&format!("redis://{redis_host}:6379/0")).unwrap();
    let client = Client::new(config, None, None, None);
    client.connect();
    client.wait_for_connect().await.unwrap();

    client
}

fn bench_redis_simple_getsetdel_async(b: &mut Bencher) {
    use redis::{AsyncCommands, RedisError};

    let client = get_redis_client();
    let runtime = current_thread_runtime();
    let con = client.get_multiplexed_async_connection();
    let mut con = runtime.block_on(con).unwrap();

    b.iter(|| {
        runtime
            .block_on(async {
                let key = "test_key";
                con.set::<_, _, ()>(key, 42.423456).await?;
                let _: f64 = con.get(key).await?;
                con.del::<_, usize>(key).await?;
                Ok::<_, RedisError>(())
            })
            .unwrap()
    });
}

fn bench_fred_simple_getsetdel_async(b: &mut Bencher) {
    use fred::prelude::*;

    let runtime = current_thread_runtime();
    let client = runtime.block_on(get_fred_client());

    b.iter(|| {
        runtime
            .block_on(async {
                let key = "test_key";
                client
                    .set::<(), _, _>(key, 42.423456, None, None, false)
                    .await?;
                let _: f64 = client.get(key).await?;
                client.del::<usize, _>(key).await?;

                Ok::<_, Error>(())
            })
            .unwrap()
    });
}

fn bench_rustis_simple_getsetdel_async(b: &mut Bencher) {
    use rustis::{
        Error,
        commands::{GenericCommands, StringCommands},
    };

    let runtime = current_thread_runtime();

    let client = runtime.block_on(get_rustis_client());

    b.iter(|| {
        runtime
            .block_on(async {
                let key = "test_key";
                client.set(key, 42.423456).await?;
                let _: f64 = client.get(key).await?;
                client.del(key).await?;

                Ok::<_, Error>(())
            })
            .unwrap()
    });
}

fn bench_generic_api(c: &mut Criterion) {
    let mut group = c.benchmark_group("native_api");
    group
        .measurement_time(Duration::from_secs(10))
        .bench_function(
            "redis_simple_getsetdel_async",
            bench_redis_simple_getsetdel_async,
        )
        .bench_function(
            "fred_simple_getsetdel_async",
            bench_fred_simple_getsetdel_async,
        )
        .bench_function(
            "rustis_simple_getsetdel_async",
            bench_rustis_simple_getsetdel_async,
        );
    group.finish();
}

criterion_group!(bench, bench_generic_api);
criterion_main!(bench);