distkit 0.2.3

A toolkit of distributed systems primitives for Rust, backed by Redis
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

//! Setup helpers shared across all doc-test examples.
//!
//! This module is compiled **only** when `cargo test --doc` runs
//! (`#[cfg(doctest)]`). It is not part of the public API and will not appear
//! in the generated documentation.

use std::{
    sync::Arc,
    time::{SystemTime, UNIX_EPOCH},
};

use crate::{
    RedisKey,
    counter::{CounterOptions, LaxCounter, StrictCounter},
    icounter::{
        LaxInstanceAwareCounter, LaxInstanceAwareCounterOptions, StrictInstanceAwareCounter,
        StrictInstanceAwareCounterOptions,
    },
};

fn redis_url() -> String {
    std::env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1:6379".to_string())
}

fn unique_prefix() -> Result<RedisKey, crate::DistkitError> {
    RedisKey::try_from(format!(
        "test_{}_{}_{}",
        uuid::Uuid::new_v4(),
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos(),
        uuid::Uuid::new_v4(),
    ))
}

/// Creates a [`StrictCounter`] with a unique Redis prefix.
pub async fn strict_counter() -> Result<Arc<StrictCounter>, Box<dyn std::error::Error>> {
    let conn = redis::Client::open(redis_url())?
        .get_connection_manager()
        .await?;
    Ok(StrictCounter::new(CounterOptions::new(
        unique_prefix()?,
        conn,
    )))
}

/// Creates a [`LaxCounter`] with a unique Redis prefix.
pub async fn lax_counter() -> Result<Arc<LaxCounter>, Box<dyn std::error::Error>> {
    let conn = redis::Client::open(redis_url())?
        .get_connection_manager()
        .await?;
    Ok(LaxCounter::new(CounterOptions::new(unique_prefix()?, conn)))
}

/// Creates a single [`StrictInstanceAwareCounter`] with a unique Redis prefix.
pub async fn strict_icounter() -> Result<Arc<StrictInstanceAwareCounter>, Box<dyn std::error::Error>>
{
    let conn = redis::Client::open(redis_url())?
        .get_connection_manager()
        .await?;
    Ok(StrictInstanceAwareCounter::new(
        StrictInstanceAwareCounterOptions::new(unique_prefix()?, conn),
    ))
}

/// Creates two [`StrictInstanceAwareCounter`]s sharing the same Redis prefix,
/// simulating two independent server instances.
pub async fn two_strict_icounters() -> Result<
    (
        Arc<StrictInstanceAwareCounter>,
        Arc<StrictInstanceAwareCounter>,
    ),
    Box<dyn std::error::Error>,
> {
    let client = redis::Client::open(redis_url())?;
    let conn1 = client.get_connection_manager().await?;
    let conn2 = client.get_connection_manager().await?;
    let prefix = unique_prefix()?;
    let opts = |conn| StrictInstanceAwareCounterOptions::new(prefix.clone(), conn);
    Ok((
        StrictInstanceAwareCounter::new(opts(conn1)),
        StrictInstanceAwareCounter::new(opts(conn2)),
    ))
}

/// Creates a single [`LaxInstanceAwareCounter`] with a unique Redis prefix.
pub async fn lax_icounter() -> Result<Arc<LaxInstanceAwareCounter>, Box<dyn std::error::Error>> {
    let conn = redis::Client::open(redis_url())?
        .get_connection_manager()
        .await?;
    Ok(LaxInstanceAwareCounter::new(
        LaxInstanceAwareCounterOptions::new(unique_prefix()?, conn),
    ))
}

/// Creates two [`LaxInstanceAwareCounter`]s sharing the same Redis prefix,
/// simulating two independent server instances.
pub async fn two_lax_icounters()
-> Result<(Arc<LaxInstanceAwareCounter>, Arc<LaxInstanceAwareCounter>), Box<dyn std::error::Error>>
{
    let client = redis::Client::open(redis_url())?;
    let conn1 = client.get_connection_manager().await?;
    let conn2 = client.get_connection_manager().await?;
    let prefix = unique_prefix()?;
    let opts = |conn| LaxInstanceAwareCounterOptions::new(prefix.clone(), conn);
    Ok((
        LaxInstanceAwareCounter::new(opts(conn1)),
        LaxInstanceAwareCounter::new(opts(conn2)),
    ))
}