tower-resilience-adaptive 0.9.3

Adaptive concurrency limiter for Tower services using AIMD and Vegas algorithms
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
133
134
135
136
137
138
139
140

//! Layer implementation for adaptive concurrency limiting.

use crate::{AdaptiveService, Algorithm, ConcurrencyAlgorithm};
use std::sync::Arc;
use tower_layer::Layer;

/// A Tower layer that applies adaptive concurrency limiting.
///
/// This layer dynamically adjusts the number of concurrent requests based
/// on observed latency and error rates, using algorithms like AIMD or Vegas.
///
/// # Example
///
/// ```rust,no_run
/// use tower_resilience_adaptive::{AdaptiveLimiterLayer, Aimd};
/// use std::time::Duration;
///
/// let layer = AdaptiveLimiterLayer::new(
///     Aimd::builder()
///         .initial_limit(10)
///         .latency_threshold(Duration::from_millis(100))
///         .build()
/// );
/// ```
pub struct AdaptiveLimiterLayer<A> {
    algorithm: Arc<A>,
}

impl<A> AdaptiveLimiterLayer<A>
where
    A: ConcurrencyAlgorithm,
{
    /// Create a new adaptive limiter layer with the given algorithm.
    pub fn new(algorithm: A) -> Self {
        Self {
            algorithm: Arc::new(algorithm),
        }
    }

    /// Create a builder for configuring the layer.
    pub fn builder() -> AdaptiveLimiterLayerBuilder {
        AdaptiveLimiterLayerBuilder::new()
    }
}

impl<A> Clone for AdaptiveLimiterLayer<A> {
    fn clone(&self) -> Self {
        Self {
            algorithm: Arc::clone(&self.algorithm),
        }
    }
}

impl<S, A> Layer<S> for AdaptiveLimiterLayer<A>
where
    A: ConcurrencyAlgorithm + 'static,
{
    type Service = AdaptiveService<S, A>;

    fn layer(&self, service: S) -> Self::Service {
        AdaptiveService::new(service, Arc::clone(&self.algorithm))
    }
}

/// Builder for configuring an adaptive limiter layer.
pub struct AdaptiveLimiterLayerBuilder {
    _private: (),
}

impl AdaptiveLimiterLayerBuilder {
    fn new() -> Self {
        Self { _private: () }
    }

    /// Use the AIMD algorithm.
    pub fn aimd(self) -> crate::AimdBuilder {
        crate::Aimd::builder()
    }

    /// Use the Vegas algorithm.
    pub fn vegas(self) -> crate::VegasBuilder {
        crate::Vegas::builder()
    }
}

/// Extension trait for building layers from algorithm builders.
pub trait IntoLayer {
    /// The algorithm type produced.
    type Algorithm: ConcurrencyAlgorithm;

    /// Build the layer.
    fn into_layer(self) -> AdaptiveLimiterLayer<Self::Algorithm>;
}

impl IntoLayer for crate::Aimd {
    type Algorithm = crate::Aimd;

    fn into_layer(self) -> AdaptiveLimiterLayer<Self::Algorithm> {
        AdaptiveLimiterLayer::new(self)
    }
}

impl IntoLayer for crate::Vegas {
    type Algorithm = crate::Vegas;

    fn into_layer(self) -> AdaptiveLimiterLayer<Self::Algorithm> {
        AdaptiveLimiterLayer::new(self)
    }
}

impl IntoLayer for Algorithm {
    type Algorithm = Algorithm;

    fn into_layer(self) -> AdaptiveLimiterLayer<Self::Algorithm> {
        AdaptiveLimiterLayer::new(self)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::Aimd;
    use std::time::Duration;

    #[test]
    fn test_layer_creation() {
        let algorithm = Aimd::builder()
            .initial_limit(10)
            .latency_threshold(Duration::from_millis(100))
            .build();
        let layer = AdaptiveLimiterLayer::new(algorithm);
        let _ = layer.clone();
    }

    #[test]
    fn test_into_layer() {
        let layer = Aimd::builder().initial_limit(10).build().into_layer();
        let _ = layer.clone();
    }
}