distkit 0.2.2

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

//! Distributed counter implementations.
//!
//! This module provides [`StrictCounter`] (immediate consistency) and
//! [`LaxCounter`] (eventual consistency with in-memory buffering). Both
//! implement [`CounterTrait`] and are constructed directly from [`CounterOptions`].

mod lax_counter;
use std::time::Duration;

pub use lax_counter::*;

mod strict_counter;
use redis::aio::ConnectionManager;
pub use strict_counter::*;

mod counter_trait;
pub use counter_trait::*;

mod error;
pub use error::*;

use crate::RedisKey;

#[cfg(test)]
mod tests;

/// Configuration for counter construction.
///
/// Carries a Redis key prefix, a connection manager, and the `allowed_lag`
/// duration used by [`LaxCounter`] to control how long local state is
/// considered fresh before re-fetching from Redis.
#[derive(Debug, Clone)]
pub struct CounterOptions {
    /// Redis key prefix used to namespace all counter keys.
    pub prefix: RedisKey,
    /// Redis connection manager for executing commands.
    pub connection_manager: ConnectionManager,
    /// Maximum acceptable staleness for [`LaxCounter`] reads (default 20 ms).
    /// Controls how often the background task flushes buffered writes to Redis.
    pub allowed_lag: Duration,
}

impl CounterOptions {
    /// Creates counter options with a default `allowed_lag` of 20 ms.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use distkit::{RedisKey, counter::CounterOptions};
    ///
    /// # #[tokio::main]
    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let redis_url = std::env::var("REDIS_URL")
    ///     .unwrap_or_else(|_| "redis://127.0.0.1:6379".to_string());
    /// let client = redis::Client::open(redis_url)?;
    /// let conn = client.get_connection_manager().await?;
    /// let prefix = RedisKey::try_from("my_app".to_string())?;
    /// let options = CounterOptions::new(prefix, conn);
    /// // options.allowed_lag == Duration::from_millis(20)
    /// # Ok(())
    /// # }
    /// ```
    pub fn new(prefix: RedisKey, connection_manager: ConnectionManager) -> Self {
        Self {
            prefix,
            connection_manager,
            allowed_lag: Duration::from_millis(20),
        }
    }
}