satex-load-balancer 0.5.2

Satex Load Balancer Library
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

mod algorithm;
mod consistent;
mod weighted;

use crate::selector::weighted::Weighted;
use crate::Backend;
use std::collections::BTreeSet;

/// Random selection on weighted backends
pub type Random = Weighted<algorithm::Random>;

/// Round-robin selection on weighted backends
pub type RoundRobin = Weighted<algorithm::RoundRobin>;

/// Consistent Ketama hashing on weighted backends
pub type Consistent = consistent::KetamaHashing;

pub trait BackendIter {
    fn next(&mut self) -> Option<&Backend>;
}

pub struct BoxBackendIter(Box<dyn BackendIter + Send + Sync>);

impl BackendIter for BoxBackendIter {
    fn next(&mut self) -> Option<&Backend> {
        self.0.next()
    }
}

pub trait Selector {
    type Iter: BackendIter;

    fn update(&self, backends: &BTreeSet<Backend>);

    fn iter(&self, key: &[u8]) -> Self::Iter;
}

pub(crate) struct Map<S>(S);

impl<S> Map<S> {
    pub fn new(selector: S) -> Self {
        Self(selector)
    }
}

impl<S> Selector for Map<S>
where
    S: Selector + Send + Sync,
    S::Iter: Send + Sync + 'static,
{
    type Iter = BoxBackendIter;

    fn update(&self, backends: &BTreeSet<Backend>) {
        self.0.update(backends);
    }

    fn iter(&self, key: &[u8]) -> Self::Iter {
        BoxBackendIter(Box::new(self.0.iter(key)))
    }
}

pub struct BoxSelector(Box<dyn Selector<Iter = BoxBackendIter> + Send + Sync>);

impl BoxSelector {
    pub fn new<S>(selector: S) -> Self
    where
        S: Selector + Send + Sync + 'static,
        S::Iter: Send + Sync + 'static,
    {
        Self(Box::new(Map::new(selector)))
    }
}

impl Selector for BoxSelector {
    type Iter = BoxBackendIter;

    fn update(&self, backends: &BTreeSet<Backend>) {
        self.0.update(backends)
    }

    fn iter(&self, key: &[u8]) -> Self::Iter {
        self.0.iter(key)
    }
}