net_pool/
backend.rs

1use std::cmp::Ordering;
2use std::hash::{Hash, Hasher};
3use std::net::{AddrParseError, IpAddr, SocketAddr, SocketAddrV4, SocketAddrV6};
4use std::str::FromStr;
5
6#[derive(Clone, Debug)]
7pub enum Address {
8    Ori(String),
9    Addr(SocketAddr),
10}
11
12impl Address {
13    pub fn hash_code(&self) -> u64 {
14        match self {
15            Address::Ori(ori) => crate::utils::bytes_to_hash_code(ori.as_bytes()),
16            Address::Addr(addr) => crate::utils::socketaddr_to_hash_code(addr),
17        }
18    }
19}
20
21impl From<String> for Address {
22    fn from(ori: String) -> Self {
23        Address::Ori(ori)
24    }
25}
26
27impl From<&str> for Address {
28    fn from(ori: &str) -> Self {
29        Address::Ori(ori.to_string())
30    }
31}
32
33impl From<SocketAddr> for Address {
34    fn from(addr: SocketAddr) -> Self {
35        Address::Addr(addr)
36    }
37}
38
39impl<I: Into<IpAddr>> From<(I, u16)> for Address {
40    fn from(value: (I, u16)) -> Self {
41        Address::from(SocketAddr::from(value))
42    }
43}
44
45impl From<SocketAddrV4> for Address {
46    fn from(value: SocketAddrV4) -> Self {
47        Address::from(SocketAddr::from(value))
48    }
49}
50
51impl From<SocketAddrV6> for Address {
52    fn from(value: SocketAddrV6) -> Self {
53        Address::from(SocketAddr::from(value))
54    }
55}
56
57impl FromStr for Address {
58    type Err = AddrParseError;
59
60    fn from_str(s: &str) -> Result<Self, Self::Err> {
61        let a = SocketAddr::from_str(s)?;
62        Ok(Address::from(a))
63    }
64}
65
66#[derive(Clone, Debug)]
67pub struct BackendState {
68    hash_code: u64,
69    valid: bool,
70    address: Address,
71}
72
73impl BackendState {
74    pub fn new(addr: Address) -> BackendState {
75        let hash_code = addr.hash_code();
76        BackendState {
77            hash_code,
78            valid: true,
79            address: addr,
80        }
81    }
82
83    pub fn hash_code(&self) -> u64 {
84        self.hash_code
85    }
86
87    pub fn set_valid(&mut self, valid: bool) {
88        self.valid = valid;
89    }
90
91    pub fn get_valid(&self) -> bool {
92        self.valid
93    }
94
95    pub fn get_address(&self) -> &Address {
96        &self.address
97    }
98}
99
100impl Hash for BackendState {
101    fn hash<H: Hasher>(&self, state: &mut H) {
102        state.write_u64(self.hash_code)
103    }
104}
105
106impl Eq for BackendState {}
107
108impl PartialEq for BackendState {
109    fn eq(&self, other: &Self) -> bool {
110        self.hash_code.eq(&other.hash_code)
111    }
112}
113
114impl PartialOrd for BackendState {
115    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
116        self.hash_code.partial_cmp(&other.hash_code)
117    }
118}
119
120impl Ord for BackendState {
121    fn cmp(&self, other: &Self) -> Ordering {
122        self.hash_code.cmp(&other.hash_code)
123    }
124}
125
126impl From<Address> for BackendState {
127    fn from(addr: Address) -> Self {
128        BackendState::new(addr)
129    }
130}
131
132#[derive(Default)]
133pub struct BackendStates(Vec<BackendState>);
134
135impl BackendStates {
136    pub fn new() -> Self {
137        BackendStates(Vec::new())
138    }
139
140    pub fn contain(&self, hash_code: u64) -> bool {
141        self.0
142            .iter()
143            .find(|bs| bs.hash_code() == hash_code)
144            .is_some()
145    }
146
147    pub fn add_backend(&mut self, addr: Address) {
148        let hash_code = addr.hash_code();
149        if self.0.iter().any(|bs| bs.hash_code == hash_code) {
150            return;
151        }
152
153        self.0.push(BackendState::new(addr));
154        self.sort_backends();
155    }
156
157    pub fn remove_backend(&mut self, addr: &Address) -> bool {
158        let c = self.0.len();
159        let hash_code = addr.hash_code();
160        self.0.retain(|bs| bs.hash_code != hash_code);
161        self.0.len() != c
162    }
163
164    pub fn set_backend_valid(&mut self, addr: &Address, valid: bool) {
165        if let Some(bs) = self.get_backend_mut(addr) {
166            bs.valid = valid;
167        }
168    }
169
170    pub fn get_backend_valid(&self, addr: &Address) -> Option<bool> {
171        self.get_backend(addr).map(|bs| bs.valid)
172    }
173
174    pub fn get_backend(&self, addr: &Address) -> Option<&BackendState> {
175        let hash_code = addr.hash_code();
176        self.0.iter().find(|bs| bs.hash_code == hash_code)
177    }
178
179    pub fn get_backend_mut(&mut self, addr: &Address) -> Option<&mut BackendState> {
180        let hash_code = addr.hash_code();
181        self.0.iter_mut().find(|bs| bs.hash_code == hash_code)
182    }
183
184    pub fn get_backends(&self) -> &[BackendState] {
185        self.0.as_slice()
186    }
187
188    pub fn get_backends_mut(&mut self) -> &mut [BackendState] {
189        self.0.as_mut_slice()
190    }
191
192    fn sort_backends(&mut self) {
193        self.0.sort_by(|bs1, bs2| bs1.hash_code.cmp(&bs2.hash_code));
194    }
195}
net_pool/backend.rs

net_pool/
backend.rs
