mirror/Easytier
1
0
Fork 0
mirror of https://github.com/EasyTier/EasyTier.git synced 2026-05-07 02:09:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

clippy all codes (#1214)

Browse Source 
1. clippy code
2. add fmt and clippy check in ci
This commit is contained in:
Sijie.Sun
2025-08-10 22:56:41 +08:00
committed by GitHub
parent 0087ac3ffc
commit e43537939a
144 changed files with 1475 additions and 1531 deletions
Download Patch File Download Diff File Expand all files Collapse all files
easytier/src/peers/acl_filter.rs
+8 -2
View File
@@ -27,6 +27,12 @@ pub struct AclFilter {
acl_enabled: Arc<AtomicBool>,
}
impl Default for AclFilter {
fn default() -> Self {
Self::new()
}
}
impl AclFilter {
pub fn new() -> Self {
Self {
@@ -75,8 +81,8 @@ impl AclFilter {
let rules_stats = processor.get_rules_stats();
AclStats {
global: global_stats.into_iter().map(|(k, v)| (k, v)).collect(),
conn_track: conn_track.iter().map(|x| x.value().clone()).collect(),
global: global_stats.into_iter().collect(),
conn_track: conn_track.iter().map(|x| *x.value()).collect(),
rules: rules_stats,
}
}
easytier/src/peers/encrypt/aes_gcm.rs
+9 -9
View File
@@ -15,21 +15,21 @@ pub struct AesGcmCipher {
#[derive(Clone)]
pub enum AesGcmEnum {
AES128GCM(Aes128Gcm),
AES256GCM(Aes256Gcm),
AES128GCM(Box<Aes128Gcm>),
AES256GCM(Box<Aes256Gcm>),
}
impl AesGcmCipher {
pub fn new_128(key: [u8; 16]) -> Self {
let key: &Key<Aes128Gcm> = &key.into();
Self {
cipher: AesGcmEnum::AES128GCM(Aes128Gcm::new(key)),
cipher: AesGcmEnum::AES128GCM(Box::new(Aes128Gcm::new(key))),
}
}
pub fn new_256(key: [u8; 32]) -> Self {
let key: &Key<Aes256Gcm> = &key.into();
Self {
cipher: AesGcmEnum::AES256GCM(Aes256Gcm::new(key)),
cipher: AesGcmEnum::AES256GCM(Box::new(Aes256Gcm::new(key))),
}
}
}
@@ -80,7 +80,7 @@ impl Encryptor for AesGcmCipher {
zc_packet
.mut_inner()
.truncate(old_len - AES_GCM_ENCRYPTION_RESERVED);
return Ok(());
Ok(())
}
fn encrypt(&self, zc_packet: &mut ZCPacket) -> Result<(), Error> {
@@ -104,7 +104,7 @@ impl Encryptor for AesGcmCipher {
}
};
return match rs {
match rs {
Ok(tag) => {
tail.tag.copy_from_slice(tag.as_slice());
@@ -114,7 +114,7 @@ impl Encryptor for AesGcmCipher {
Ok(())
}
Err(_) => Err(Error::EncryptionFailed),
};
}
}
}
@@ -137,10 +137,10 @@ mod tests {
packet.payload().len(),
text.len() + AES_GCM_ENCRYPTION_RESERVED
);
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), true);
assert!(packet.peer_manager_header().unwrap().is_encrypted());
cipher.decrypt(&mut packet).unwrap();
assert_eq!(packet.payload(), text);
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), false);
assert!(!packet.peer_manager_header().unwrap().is_encrypted());
}
}
easytier/src/peers/encrypt/mod.rs
+1 -1
View File
@@ -43,7 +43,7 @@ impl Encryptor for NullCipher {
fn decrypt(&self, zc_packet: &mut ZCPacket) -> Result<(), Error> {
let pm_header = zc_packet.peer_manager_header().unwrap();
if pm_header.is_encrypted() {
return Err(Error::DecryptionFailed);
Err(Error::DecryptionFailed)
} else {
Ok(())
}
easytier/src/peers/encrypt/openssl_cipher.rs
+4 -4
View File
@@ -212,12 +212,12 @@ mod tests {
// 加密
cipher.encrypt(&mut packet).unwrap();
assert!(packet.payload().len() > text.len() + OPENSSL_ENCRYPTION_RESERVED);
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), true);
assert!(packet.peer_manager_header().unwrap().is_encrypted());
// 解密
cipher.decrypt(&mut packet).unwrap();
assert_eq!(packet.payload(), text);
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), false);
assert!(!packet.peer_manager_header().unwrap().is_encrypted());
}
#[test]
@@ -231,11 +231,11 @@ mod tests {
// 加密
cipher.encrypt(&mut packet).unwrap();
assert!(packet.payload().len() > text.len());
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), true);
assert!(packet.peer_manager_header().unwrap().is_encrypted());
// 解密
cipher.decrypt(&mut packet).unwrap();
assert_eq!(packet.payload(), text);
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), false);
assert!(!packet.peer_manager_header().unwrap().is_encrypted());
}
}
easytier/src/peers/encrypt/ring_aes_gcm.rs
+8 -8
View File
@@ -65,7 +65,7 @@ impl Encryptor for AesGcmCipher {
let text_and_tag_len = payload_len - AES_GCM_ENCRYPTION_RESERVED + 16;
let aes_tail = AesGcmTail::ref_from_suffix(zc_packet.payload()).unwrap();
let nonce = aead::Nonce::assume_unique_for_key(aes_tail.nonce.clone());
let nonce = aead::Nonce::assume_unique_for_key(aes_tail.nonce);
let rs = match &self.cipher {
AesGcmEnum::AesGCM128(cipher, _) => cipher.open_in_place(
@@ -79,7 +79,7 @@ impl Encryptor for AesGcmCipher {
&mut zc_packet.mut_payload()[..text_and_tag_len],
),
};
if let Err(_) = rs {
if rs.is_err() {
return Err(Error::DecryptionFailed);
}
@@ -89,7 +89,7 @@ impl Encryptor for AesGcmCipher {
zc_packet
.mut_inner()
.truncate(old_len - AES_GCM_ENCRYPTION_RESERVED);
return Ok(());
Ok(())
}
fn encrypt(&self, zc_packet: &mut ZCPacket) -> Result<(), Error> {
@@ -101,7 +101,7 @@ impl Encryptor for AesGcmCipher {
let mut tail = AesGcmTail::default();
rand::thread_rng().fill_bytes(&mut tail.nonce);
let nonce = aead::Nonce::assume_unique_for_key(tail.nonce.clone());
let nonce = aead::Nonce::assume_unique_for_key(tail.nonce);
let rs = match &self.cipher {
AesGcmEnum::AesGCM128(cipher, _) => cipher.seal_in_place_separate_tag(
@@ -115,7 +115,7 @@ impl Encryptor for AesGcmCipher {
zc_packet.mut_payload(),
),
};
return match rs {
match rs {
Ok(tag) => {
let tag = tag.as_ref();
if tag.len() != 16 {
@@ -129,7 +129,7 @@ impl Encryptor for AesGcmCipher {
Ok(())
}
Err(_) => Err(Error::EncryptionFailed),
};
}
}
}
@@ -152,10 +152,10 @@ mod tests {
packet.payload().len(),
text.len() + AES_GCM_ENCRYPTION_RESERVED
);
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), true);
assert!(packet.peer_manager_header().unwrap().is_encrypted());
cipher.decrypt(&mut packet).unwrap();
assert_eq!(packet.payload(), text);
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), false);
assert!(!packet.peer_manager_header().unwrap().is_encrypted());
}
}
easytier/src/peers/encrypt/ring_chacha20.rs
+4 -4
View File
@@ -44,7 +44,7 @@ impl Encryptor for RingChaCha20Cipher {
let text_and_tag_len = payload_len - CHACHA20_POLY1305_ENCRYPTION_RESERVED + 16;
let chacha20_tail = ChaCha20Poly1305Tail::ref_from_suffix(zc_packet.payload()).unwrap();
let nonce = Nonce::assume_unique_for_key(chacha20_tail.nonce.clone());
let nonce = Nonce::assume_unique_for_key(chacha20_tail.nonce);
let rs = self.cipher.open_in_place(
nonce,
@@ -75,7 +75,7 @@ impl Encryptor for RingChaCha20Cipher {
let mut tail = ChaCha20Poly1305Tail::default();
rand::thread_rng().fill_bytes(&mut tail.nonce);
let nonce = Nonce::assume_unique_for_key(tail.nonce.clone());
let nonce = Nonce::assume_unique_for_key(tail.nonce);
let rs =
self.cipher
@@ -116,10 +116,10 @@ mod tests {
packet.payload().len(),
text.len() + CHACHA20_POLY1305_ENCRYPTION_RESERVED
);
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), true);
assert!(packet.peer_manager_header().unwrap().is_encrypted());
cipher.decrypt(&mut packet).unwrap();
assert_eq!(packet.payload(), text);
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), false);
assert!(!packet.peer_manager_header().unwrap().is_encrypted());
}
}
easytier/src/peers/encrypt/xor_cipher.rs
+2 -2
View File
@@ -75,12 +75,12 @@ mod tests {
// 加密
cipher.encrypt(&mut packet).unwrap();
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), true);
assert!(packet.peer_manager_header().unwrap().is_encrypted());
assert_ne!(packet.payload(), text); // 加密后数据应该不同
// 解密
cipher.decrypt(&mut packet).unwrap();
assert_eq!(packet.payload(), text);
assert_eq!(packet.peer_manager_header().unwrap().is_encrypted(), false);
assert!(!packet.peer_manager_header().unwrap().is_encrypted());
}
}
easytier/src/peers/foreign_network_client.rs
+1 -1
View File
@@ -53,7 +53,7 @@ impl ForeignNetworkClient {
pub fn get_next_hop(&self, peer_id: PeerId) -> Option<PeerId> {
if self.peer_map.has_peer(peer_id) {
return Some(peer_id.clone());
return Some(peer_id);
}
None
}
easytier/src/peers/foreign_network_manager.rs
+51 -48
View File
@@ -362,31 +362,32 @@ impl ForeignNetworkEntry {
.get_gateway_peer_id(to_peer_id, NextHopPolicy::LeastHop)
.await;
if gateway_peer_id.is_some() && peer_map.has_peer(gateway_peer_id.unwrap()) {
if let Err(e) = peer_map
.send_msg_directly(zc_packet, gateway_peer_id.unwrap())
.await
{
tracing::error!(
?e,
"send packet to foreign peer inside peer map failed"
match gateway_peer_id {
Some(peer_id) if peer_map.has_peer(peer_id) => {
if let Err(e) = peer_map.send_msg_directly(zc_packet, peer_id).await {
tracing::error!(
?e,
"send packet to foreign peer inside peer map failed"
);
}
}
_ => {
let mut foreign_packet = ZCPacket::new_for_foreign_network(
&network_name,
to_peer_id,
&zc_packet,
);
let via_peer = gateway_peer_id.unwrap_or(to_peer_id);
foreign_packet.fill_peer_manager_hdr(
my_node_id,
via_peer,
PacketType::ForeignNetworkPacket as u8,
);
if let Err(e) = pm_sender.send(foreign_packet).await {
tracing::error!("send packet to peer with pm failed: {:?}", e);
}
}
} else {
let mut foreign_packet = ZCPacket::new_for_foreign_network(
&network_name,
to_peer_id,
&zc_packet,
);
foreign_packet.fill_peer_manager_hdr(
my_node_id,
gateway_peer_id.unwrap_or(to_peer_id),
PacketType::ForeignNetworkPacket as u8,
);
if let Err(e) = pm_sender.send(foreign_packet).await {
tracing::error!("send packet to peer with pm failed: {:?}", e);
}
}
};
}
}
});
@@ -434,9 +435,10 @@ impl ForeignNetworkManagerData {
let _ = v.remove(network_name);
v.is_empty()
});
if let Some(_) = self
if self
.network_peer_maps
.remove_if(network_name, |_, v| v.peer_map.is_empty())
.is_some()
{
self.network_peer_last_update.remove(network_name);
}
@@ -446,7 +448,7 @@ impl ForeignNetworkManagerData {
let Some(peer_map) = self
.network_peer_maps
.get(network_name)
.and_then(|v| Some(v.peer_map.clone()))
.map(|v| v.peer_map.clone())
else {
return;
};
@@ -492,7 +494,7 @@ impl ForeignNetworkManagerData {
self.peer_network_map
.entry(dst_peer_id)
.or_insert_with(|| DashSet::new())
.or_default()
.insert(network_identity.network_name.clone());
self.network_peer_last_update
@@ -553,7 +555,7 @@ impl ForeignNetworkManager {
self.data
.network_peer_maps
.get(network_name)
.and_then(|v| Some(v.my_peer_id))
.map(|v| v.my_peer_id)
}
pub async fn add_peer_conn(&self, peer_conn: PeerConn) -> Result<(), Error> {
@@ -574,7 +576,7 @@ impl ForeignNetworkManager {
&peer_conn.get_network_identity(),
peer_conn.get_my_peer_id(),
peer_conn.get_peer_id(),
!ret.is_err(),
ret.is_ok(),
&self.global_ctx,
&self.packet_sender_to_mgr,
)
@@ -608,22 +610,21 @@ impl ForeignNetworkManager {
if new_added {
self.start_event_handler(&entry).await;
} else {
if let Some(peer) = entry.peer_map.get_peer_by_id(peer_conn.get_peer_id()) {
let direct_conns_len = peer.get_directly_connections().len();
let max_count = use_global_var!(MAX_DIRECT_CONNS_PER_PEER_IN_FOREIGN_NETWORK);
if direct_conns_len >= max_count as usize {
return Err(anyhow::anyhow!(
"too many direct conns, cur: {}, max: {}",
direct_conns_len,
max_count
)
.into());
}
} else if let Some(peer) = entry.peer_map.get_peer_by_id(peer_conn.get_peer_id()) {
let direct_conns_len = peer.get_directly_connections().len();
let max_count = use_global_var!(MAX_DIRECT_CONNS_PER_PEER_IN_FOREIGN_NETWORK);
if direct_conns_len >= max_count as usize {
return Err(anyhow::anyhow!(
"too many direct conns, cur: {}, max: {}",
direct_conns_len,
max_count
)
.into());
}
}
Ok(entry.peer_map.add_new_peer_conn(peer_conn).await)
entry.peer_map.add_new_peer_conn(peer_conn).await;
Ok(())
}
async fn start_event_handler(&self, entry: &ForeignNetworkEntry) {
@@ -686,9 +687,11 @@ impl ForeignNetworkManager {
peers: Default::default(),
};
for peer in item.peer_map.list_peers().await {
let mut peer_info = PeerInfo::default();
peer_info.peer_id = peer;
peer_info.conns = item.peer_map.list_peer_conns(peer).await.unwrap_or(vec![]);
let peer_info = PeerInfo {
peer_id: peer,
conns: item.peer_map.list_peer_conns(peer).await.unwrap_or(vec![]),
..Default::default()
};
entry.peers.push(peer_info);
}
@@ -701,7 +704,7 @@ impl ForeignNetworkManager {
self.data
.network_peer_last_update
.get(network_name)
.map(|v| v.clone())
.map(|v| *v)
}
pub async fn send_msg_to_peer(
@@ -820,7 +823,7 @@ pub mod tests {
let pm_center = create_mock_peer_manager_with_mock_stun(NatType::Unknown).await;
tracing::debug!("pm_center: {:?}", pm_center.my_peer_id());
let mut flag = pm_center.get_global_ctx().get_flags();
flag.relay_network_whitelist = vec!["net1".to_string(), "net2*".to_string()].join(" ");
flag.relay_network_whitelist = ["net1".to_string(), "net2*".to_string()].join(" ");
pm_center.get_global_ctx().config.set_flags(flag);
let pma_net1 = create_mock_peer_manager_for_foreign_network(name.as_str()).await;
@@ -1026,7 +1029,7 @@ pub mod tests {
drop(pm_center);
wait_for_condition(
|| async { pma_net1.list_routes().await.len() == 0 },
|| async { pma_net1.list_routes().await.is_empty() },
Duration::from_secs(5),
)
.await;
@@ -1168,7 +1171,7 @@ pub mod tests {
println!("drop pm_center1, id: {:?}", pm_center1.my_peer_id());
drop(pm_center1);
wait_for_condition(
|| async { pma_net1.list_routes().await.len() == 0 },
|| async { pma_net1.list_routes().await.is_empty() },
Duration::from_secs(5),
)
.await;
easytier/src/peers/graph_algo.rs
+20 -21
View File
@@ -60,14 +60,13 @@ impl<K: PartialOrd, T> Ord for MinScored<K, T> {
}
}
pub type DijkstraResult<K, NodeId> = (HashMap<NodeId, K>, HashMap<NodeId, (NodeId, usize)>);
pub fn dijkstra_with_first_hop<G, F, K>(
graph: G,
start: G::NodeId,
mut edge_cost: F,
) -> (
HashMap<G::NodeId, K>,
HashMap<G::NodeId, (G::NodeId, usize)>,
)
) -> DijkstraResult<K, G::NodeId>
where
G: IntoEdges + Visitable,
G::NodeId: Eq + Hash + Clone,
@@ -79,43 +78,43 @@ where
let mut first_hop = HashMap::new();
let mut visit_next = BinaryHeap::new();
let zero_score = K::default();
scores.insert(start.clone(), zero_score);
visit_next.push(MinScored(zero_score, start.clone()));
first_hop.insert(start.clone(), (start.clone(), 0));
scores.insert(start, zero_score);
visit_next.push(MinScored(zero_score, start));
first_hop.insert(start, (start, 0));
while let Some(MinScored(node_score, node)) = visit_next.pop() {
if visited.is_visited(&node) {
continue;
}
for edge in graph.edges(node.clone()) {
for edge in graph.edges(node) {
let next = edge.target();
if visited.is_visited(&next) {
continue;
}
let next_score = node_score + edge_cost(edge);
match scores.entry(next.clone()) {
match scores.entry(next) {
Occupied(mut ent) => {
if next_score < *ent.get() {
*ent.get_mut() = next_score;
visit_next.push(MinScored(next_score, next.clone()));
visit_next.push(MinScored(next_score, next));
// 继承前驱的 first_hop，或自己就是第一跳
let hop = if node == start {
(next.clone(), 0)
(next, 0)
} else {
first_hop[&node].clone()
first_hop[&node]
};
first_hop.insert(next.clone(), (hop.0, hop.1 + 1));
first_hop.insert(next, (hop.0, hop.1 + 1));
}
}
Vacant(ent) => {
ent.insert(next_score);
visit_next.push(MinScored(next_score, next.clone()));
visit_next.push(MinScored(next_score, next));
let hop = if node == start {
(next.clone(), 0)
(next, 0)
} else {
first_hop[&node].clone()
first_hop[&node]
};
first_hop.insert(next.clone(), (hop.0, hop.1 + 1));
first_hop.insert(next, (hop.0, hop.1 + 1));
}
}
}
@@ -138,9 +137,9 @@ mod tests {
let c = graph.add_node("c");
let d = graph.add_node("d");
graph.extend_with_edges(&[(a, b, 1)]);
graph.extend_with_edges(&[(b, c, 1)]);
graph.extend_with_edges(&[(c, d, 2)]);
graph.extend_with_edges([(a, b, 1)]);
graph.extend_with_edges([(b, c, 1)]);
graph.extend_with_edges([(c, d, 2)]);
let (scores, first_hop) = dijkstra_with_first_hop(&graph, a, |edge| *edge.weight());
@@ -162,7 +161,7 @@ mod tests {
let d = graph.add_node("d");
let e = graph.add_node("e");
graph.extend_with_edges(&[(a, b, 1), (a, c, 2), (b, d, 1), (c, d, 3), (d, e, 1)]);
graph.extend_with_edges([(a, b, 1), (a, c, 2), (b, d, 1), (c, d, 3), (d, e, 1)]);
let (scores, first_hop) = dijkstra_with_first_hop(&graph, a, |edge| *edge.weight());
easytier/src/peers/peer.rs
+3 -3
View File
@@ -148,7 +148,7 @@ impl Peer {
}
// find a conn with the smallest latency
let mut min_latency = std::u64::MAX;
let mut min_latency = u64::MAX;
for conn in self.conns.iter() {
let latency = conn.value().get_stats().latency_us;
if latency < min_latency {
@@ -176,7 +176,7 @@ impl Peer {
if !has_key {
return Err(Error::NotFound);
}
self.close_event_sender.send(conn_id.clone()).await.unwrap();
self.close_event_sender.send(*conn_id).await.unwrap();
Ok(())
}
@@ -277,7 +277,7 @@ mod tests {
// wait for remote peer conn close
timeout(std::time::Duration::from_secs(5), async {
while (&remote_peer).list_peer_conns().await.len() != 0 {
while !remote_peer.list_peer_conns().await.is_empty() {
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}
})
easytier/src/peers/peer_conn.rs
+10 -9
View File
@@ -102,7 +102,7 @@ pub struct PeerConn {
tunnel: Arc<Mutex<Box<dyn Any + Send + 'static>>>,
sink: MpscTunnelSender,
recv: Arc<Mutex<Option<Pin<Box<dyn ZCPacketStream>>>>>,
recv: Mutex<Option<Pin<Box<dyn ZCPacketStream>>>>,
tunnel_info: Option<TunnelInfo>,
tasks: JoinSet<Result<(), TunnelError>>,
@@ -149,7 +149,7 @@ impl PeerConn {
let conn_id = PeerConnId::new_v4();
PeerConn {
conn_id: conn_id.clone(),
conn_id,
my_peer_id,
global_ctx,
@@ -158,7 +158,7 @@ impl PeerConn {
mpsc_tunnel.close()
})))),
sink,
recv: Arc::new(Mutex::new(Some(recv))),
recv: Mutex::new(Some(recv)),
tunnel_info,
tasks: JoinSet::new(),
@@ -238,7 +238,7 @@ impl PeerConn {
));
}
return Ok(rsp);
Ok(rsp)
}
async fn wait_handshake_loop(&mut self) -> Result<HandshakeRequest, Error> {
@@ -424,10 +424,8 @@ impl PeerConn {
if let Err(e) = ctrl_sender.send(zc_packet) {
tracing::error!(?e, "peer conn send ctrl resp error");
}
} else {
if sender.send(zc_packet).await.is_err() {
break;
}
} else if sender.send(zc_packet).await.is_err() {
break;
}
}
@@ -650,7 +648,10 @@ mod tests {
let throughput = c_peer.throughput.clone();
let _t = ScopedTask::from(tokio::spawn(async move {
// if not drop both, we mock some rx traffic for client peer to test pinger
while !drop_both {
if drop_both {
return;
}
loop {
tokio::time::sleep(Duration::from_millis(100)).await;
throughput.record_rx_bytes(3);
}
easytier/src/peers/peer_conn_ping.rs
+2 -2
View File
@@ -106,7 +106,7 @@ impl PingIntervalController {
}
self.last_send_logic_time = self.logic_time;
return true;
true
}
}
@@ -255,7 +255,7 @@ impl PeerConnPinger {
"pingpong controller send pingpong task, seq: {}, node_id: {}, controller: {:?}",
req_seq,
my_node_id,
controller
controller,
);
let mut sink = sink.clone();
easytier/src/peers/peer_manager.rs
+33 -48
View File
@@ -351,7 +351,8 @@ impl PeerManager {
"network identity not match".to_string(),
));
}
Ok(self.peers.add_new_peer_conn(peer_conn).await)
self.peers.add_new_peer_conn(peer_conn).await;
Ok(())
}
pub async fn add_client_tunnel(
@@ -377,10 +378,8 @@ impl PeerManager {
pub fn has_directly_connected_conn(&self, peer_id: PeerId) -> bool {
if let Some(peer) = self.peers.get_peer_by_id(peer_id) {
peer.has_directly_connected_conn()
} else if self.foreign_network_client.get_peer_map().has_peer(peer_id) {
true
} else {
false
self.foreign_network_client.get_peer_map().has_peer(peer_id)
}
}
@@ -441,14 +440,14 @@ impl PeerManager {
match addr {
SocketAddr::V4(addr) => {
if let Some(virtual_ipv4) = virtual_ipv4 {
if virtual_ipv4.contains(&addr.ip()) {
if virtual_ipv4.contains(addr.ip()) {
anyhow::bail!("tunnel src host is from the virtual network (ignore this error please)");
}
}
}
SocketAddr::V6(addr) => {
if let Some(virtual_ipv6) = virtual_ipv6 {
if virtual_ipv6.contains(&addr.ip()) {
if virtual_ipv6.contains(addr.ip()) {
anyhow::bail!("tunnel src host is from the virtual network (ignore this error please)");
}
}
@@ -489,7 +488,7 @@ impl PeerManager {
rand::random::<PeerId>()
}).value());
}
peer.set_peer_id(peer_id.clone().unwrap());
peer.set_peer_id(peer_id.unwrap());
tracing::info!(
?peer_id,
@@ -742,10 +741,8 @@ impl PeerManager {
let mut processed = false;
let mut zc_packet = Some(ret);
let mut idx = 0;
for pipeline in pipe_line.read().await.iter().rev() {
for (idx, pipeline) in pipe_line.read().await.iter().rev().enumerate() {
tracing::trace!(?zc_packet, ?idx, "try_process_packet_from_peer");
idx += 1;
zc_packet = pipeline
.try_process_packet_from_peer(zc_packet.unwrap())
.await;
@@ -938,14 +935,17 @@ impl PeerManager {
let entry = resp
.foreign_networks
.entry(info.key.as_ref().unwrap().peer_id)
.or_insert_with(|| Default::default());
.or_insert_with(Default::default);
let Some(route_info) = info.value.as_ref() else {
continue;
};
let mut f = OneForeignNetwork::default();
f.network_name = info.key.as_ref().unwrap().network_name.clone();
f.peer_ids
.extend(info.value.as_ref().unwrap().foreign_peer_ids.iter());
f.last_updated = format!("{}", info.value.as_ref().unwrap().last_update.unwrap());
f.version = info.value.as_ref().unwrap().version;
let f = OneForeignNetwork {
network_name: info.key.as_ref().unwrap().network_name.clone(),
peer_ids: route_info.foreign_peer_ids.clone(),
last_updated: format!("{}", route_info.last_update.unwrap()),
version: route_info.version,
};
entry.foreign_networks.push(f);
}
@@ -1033,14 +1033,8 @@ impl PeerManager {
|| ipv4_addr.is_multicast()
|| *ipv4_addr == ipv4_inet.last_address()
{
dst_peers.extend(
self.peers
.list_routes()
.await
.iter()
.map(|x| x.key().clone()),
);
} else if let Some(peer_id) = self.peers.get_peer_id_by_ipv4(&ipv4_addr).await {
dst_peers.extend(self.peers.list_routes().await.iter().map(|x| *x.key()));
} else if let Some(peer_id) = self.peers.get_peer_id_by_ipv4(ipv4_addr).await {
dst_peers.push(peer_id);
} else {
for exit_node in &self.exit_nodes {
@@ -1075,14 +1069,8 @@ impl PeerManager {
.unwrap_or(64);
let ipv6_inet = cidr::Ipv6Inet::new(*ipv6_addr, network_length).unwrap();
if ipv6_addr.is_multicast() || *ipv6_addr == ipv6_inet.last_address() {
dst_peers.extend(
self.peers
.list_routes()
.await
.iter()
.map(|x| x.key().clone()),
);
} else if let Some(peer_id) = self.peers.get_peer_id_by_ipv6(&ipv6_addr).await {
dst_peers.extend(self.peers.list_routes().await.iter().map(|x| *x.key()));
} else if let Some(peer_id) = self.peers.get_peer_id_by_ipv6(ipv6_addr).await {
dst_peers.push(peer_id);
} else if !ipv6_addr.is_unicast_link_local() {
// NOTE: never route link local address to exit node.
@@ -1168,14 +1156,13 @@ impl PeerManager {
let mut errs: Vec<Error> = vec![];
let mut msg = Some(msg);
let total_dst_peers = dst_peers.len();
for i in 0..total_dst_peers {
for (i, peer_id) in dst_peers.iter().enumerate() {
let mut msg = if i == total_dst_peers - 1 {
msg.take().unwrap()
} else {
msg.clone().unwrap()
};
let peer_id = &dst_peers[i];
msg.mut_peer_manager_header()
.unwrap()
.to_peer_id
@@ -1632,16 +1619,16 @@ mod tests {
..Default::default()
});
tokio::time::sleep(Duration::from_secs(2)).await;
wait_route_appear_with_cost(peer_mgr_a.clone(), peer_mgr_c.my_peer_id, Some(3))
if wait_route_appear_with_cost(peer_mgr_a.clone(), peer_mgr_c.my_peer_id, Some(3))
.await
.expect(
format!(
"route not appear, a route table: {}, table: {:#?}",
peer_mgr_a.get_route().dump().await,
peer_mgr_a.get_route().list_routes().await
)
.as_str(),
);
.is_err()
{
panic!(
"route not appear, a route table: {}, table: {:#?}",
peer_mgr_a.get_route().dump().await,
peer_mgr_a.get_route().list_routes().await
)
}
let ret = peer_mgr_a
.get_route()
@@ -1767,8 +1754,7 @@ mod tests {
.get_foreign_network_client()
.list_public_peers()
.await
.len()
== 0
.is_empty()
},
Duration::from_secs(10),
)
@@ -1810,8 +1796,7 @@ mod tests {
.get_foreign_network_client()
.list_public_peers()
.await
.len()
== 0
.is_empty()
},
Duration::from_secs(10),
)
easytier/src/peers/peer_map.rs
+10 -12
View File
@@ -49,8 +49,8 @@ impl PeerMap {
}
async fn add_new_peer(&self, peer: Peer) {
let peer_id = peer.peer_node_id.clone();
self.peer_map.insert(peer_id.clone(), Arc::new(peer));
let peer_id = peer.peer_node_id;
self.peer_map.insert(peer_id, Arc::new(peer));
self.global_ctx
.issue_event(GlobalCtxEvent::PeerAdded(peer_id));
}
@@ -75,7 +75,7 @@ impl PeerMap {
let conn_id = close_notifier.get_conn_id();
let conn_info = peer_conn.get_conn_info();
self.alive_conns
.insert((conn_info.peer_id, conn_id.clone()), conn_info.clone());
.insert((conn_info.peer_id, conn_id), conn_info.clone());
tokio::spawn(async move {
if let Some(mut waiter) = close_notifier.get_waiter().await {
let _ = waiter.recv().await;
@@ -173,9 +173,7 @@ impl PeerMap {
) -> Vec<PeerId> {
let mut ret = Vec::new();
for route in self.routes.read().await.iter() {
let peers = route
.list_peers_own_foreign_network(&network_identity)
.await;
let peers = route.list_peers_own_foreign_network(network_identity).await;
ret.extend(peers);
}
ret
@@ -195,7 +193,7 @@ impl PeerMap {
};
self.send_msg_directly(msg, gateway_peer_id).await?;
return Ok(());
Ok(())
}
pub async fn get_peer_id_by_ipv4(&self, ipv4: &Ipv4Addr) -> Option<PeerId> {
@@ -263,7 +261,7 @@ impl PeerMap {
let Some(peer) = self.get_peer_by_id(*peer_id) else {
continue;
};
if peer.list_peer_conns().await.len() > 0 {
if !peer.list_peer_conns().await.is_empty() {
ret.push(*peer_id);
}
}
@@ -274,7 +272,7 @@ impl PeerMap {
if let Some(p) = self.get_peer_by_id(peer_id) {
Some(p.list_peer_conns().await)
} else {
return None;
None
}
}
@@ -291,7 +289,7 @@ impl PeerMap {
if let Some(p) = self.get_peer_by_id(peer_id) {
p.close_peer_conn(conn_id).await
} else {
return Err(Error::NotFound);
Err(Error::NotFound)
}
}
@@ -339,7 +337,7 @@ impl PeerMap {
}
pub async fn list_route_infos(&self) -> Vec<cli::Route> {
for route in self.routes.read().await.iter() {
if let Some(route) = self.routes.read().await.iter().next() {
return route.list_routes().await;
}
vec![]
@@ -361,7 +359,7 @@ impl PeerMap {
pub fn get_alive_conns(&self) -> DashMap<(PeerId, PeerConnId), PeerConnInfo> {
self.alive_conns
.iter()
.map(|v| (v.key().clone(), v.value().clone()))
.map(|v| (*v.key(), v.value().clone()))
.collect()
}
easytier/src/peers/peer_ospf_route.rs
+75 -89
View File
@@ -170,7 +170,7 @@ impl RoutePeerInfo {
};
let need_update_periodically = if let Ok(Ok(d)) =
SystemTime::try_from(new.last_update.unwrap()).map(|x| x.elapsed())
SystemTime::try_from(new.last_update.unwrap_or_default()).map(|x| x.elapsed())
{
d > UPDATE_PEER_INFO_PERIOD
} else {
@@ -186,45 +186,41 @@ impl RoutePeerInfo {
}
}
impl Into<crate::proto::cli::Route> for RoutePeerInfo {
fn into(self) -> crate::proto::cli::Route {
let network_length = if self.network_length == 0 {
impl From<RoutePeerInfo> for crate::proto::cli::Route {
fn from(val: RoutePeerInfo) -> Self {
let network_length = if val.network_length == 0 {
24
} else {
self.network_length
val.network_length
};
crate::proto::cli::Route {
peer_id: self.peer_id,
ipv4_addr: if let Some(ipv4_addr) = self.ipv4_addr {
Some(Ipv4Inet {
address: Some(ipv4_addr.into()),
network_length,
})
} else {
None
},
peer_id: val.peer_id,
ipv4_addr: val.ipv4_addr.map(|ipv4_addr| Ipv4Inet {
address: Some(ipv4_addr),
network_length,
}),
next_hop_peer_id: 0, // next_hop_peer_id is calculated in RouteTable.
cost: 0, // cost is calculated in RouteTable.
path_latency: 0, // path_latency is calculated in RouteTable.
proxy_cidrs: self.proxy_cidrs.clone(),
hostname: self.hostname.unwrap_or_default(),
proxy_cidrs: val.proxy_cidrs.clone(),
hostname: val.hostname.unwrap_or_default(),
stun_info: {
let mut stun_info = StunInfo::default();
if let Ok(udp_nat_type) = NatType::try_from(self.udp_stun_info as i32) {
if let Ok(udp_nat_type) = NatType::try_from(val.udp_stun_info) {
stun_info.set_udp_nat_type(udp_nat_type);
}
Some(stun_info)
},
inst_id: self.inst_id.map(|x| x.to_string()).unwrap_or_default(),
version: self.easytier_version,
feature_flag: self.feature_flag,
inst_id: val.inst_id.map(|x| x.to_string()).unwrap_or_default(),
version: val.easytier_version,
feature_flag: val.feature_flag,
next_hop_peer_id_latency_first: None,
cost_latency_first: None,
path_latency_latency_first: None,
ipv6_addr: self.ipv6_addr.map(Into::into),
ipv6_addr: val.ipv6_addr,
}
}
}
@@ -235,10 +231,10 @@ struct RouteConnBitmap {
bitmap: Vec<u8>,
}
impl Into<crate::proto::peer_rpc::RouteConnBitmap> for RouteConnBitmap {
fn into(self) -> crate::proto::peer_rpc::RouteConnBitmap {
impl From<RouteConnBitmap> for crate::proto::peer_rpc::RouteConnBitmap {
fn from(val: RouteConnBitmap) -> Self {
crate::proto::peer_rpc::RouteConnBitmap {
peer_ids: self
peer_ids: val
.peer_ids
.into_iter()
.map(|x| PeerIdVersion {
@@ -246,7 +242,7 @@ impl Into<crate::proto::peer_rpc::RouteConnBitmap> for RouteConnBitmap {
version: x.1,
})
.collect(),
bitmap: self.bitmap,
bitmap: val.bitmap,
}
}
}
@@ -318,7 +314,7 @@ impl SyncedRouteInfo {
fn get_connected_peers<T: FromIterator<PeerId>>(&self, peer_id: PeerId) -> Option<T> {
self.conn_map
.get(&peer_id)
.map(|x| x.0.clone().iter().map(|x| *x).collect())
.map(|x| x.0.clone().iter().copied().collect())
}
fn remove_peer(&self, peer_id: PeerId) {
@@ -403,8 +399,8 @@ impl SyncedRouteInfo {
my_peer_id: PeerId,
my_peer_route_id: u64,
dst_peer_id: PeerId,
peer_infos: &Vec<RoutePeerInfo>,
raw_peer_infos: &Vec<DynamicMessage>,
peer_infos: &[RoutePeerInfo],
raw_peer_infos: &[DynamicMessage],
) -> Result<(), Error> {
let mut need_inc_version = false;
for (idx, route_info) in peer_infos.iter().enumerate() {
@@ -476,7 +472,7 @@ impl SyncedRouteInfo {
})
.or_insert_with(|| {
need_inc_version = true;
(connceted_peers, version.clone().into())
(connceted_peers, (*version).into())
});
}
if need_inc_version {
@@ -512,11 +508,8 @@ impl SyncedRouteInfo {
my_peer_route_id: u64,
global_ctx: &ArcGlobalCtx,
) -> bool {
let mut old = self
.peer_infos
.entry(my_peer_id)
.or_insert(RoutePeerInfo::new());
let new = old.update_self(my_peer_id, my_peer_route_id, &global_ctx);
let mut old = self.peer_infos.entry(my_peer_id).or_default();
let new = old.update_self(my_peer_id, my_peer_route_id, global_ctx);
let new_version = new.version;
let old_version = old.version;
*old = new;
@@ -616,8 +609,8 @@ impl SyncedRouteInfo {
}
fn is_peer_directly_connected(&self, src_peer_id: PeerId, dst_peer_id: PeerId) -> bool {
return self.is_peer_bidirectly_connected(src_peer_id, dst_peer_id)
|| self.is_peer_bidirectly_connected(dst_peer_id, src_peer_id);
self.is_peer_bidirectly_connected(src_peer_id, dst_peer_id)
|| self.is_peer_bidirectly_connected(dst_peer_id, src_peer_id)
}
}
@@ -674,7 +667,7 @@ impl RouteTable {
fn get_nat_type(&self, peer_id: PeerId) -> Option<NatType> {
self.peer_infos
.get(&peer_id)
.map(|x| NatType::try_from(x.udp_stun_info as i32).unwrap_or_default())
.map(|x| NatType::try_from(x.udp_stun_info).unwrap_or_default())
}
// return graph and start node index (node of my peer id).
@@ -710,9 +703,9 @@ impl RouteTable {
for item in peer_id_to_node_index.iter() {
let src_peer_id = item.key();
let src_node_idx = item.value();
let connected_peers = synced_info
let connected_peers: BTreeSet<_> = synced_info
.get_connected_peers(*src_peer_id)
.unwrap_or(BTreeSet::new());
.unwrap_or_default();
// if avoid relay, just set all outgoing edges to a large value: AVOID_RELAY_COST.
let peer_avoid_relay_data = synced_info.get_avoid_relay_data(*src_peer_id);
@@ -798,7 +791,7 @@ impl RouteTable {
}
// Step 3: 第二次 Dijkstra - 在子图上找代价最小的路径
self.gen_next_hop_map_with_least_cost(&subgraph, &start_node_idx.clone().unwrap(), version);
self.gen_next_hop_map_with_least_cost(&subgraph, &start_node_idx.unwrap(), version);
}
fn gen_next_hop_map_with_least_cost(
@@ -813,7 +806,7 @@ impl RouteTable {
let info = NextHopInfo {
next_hop_peer_id: *graph.node_weight(*next_hop).unwrap(),
path_latency: (*costs.get(dst).unwrap() % AVOID_RELAY_COST) as i32,
path_len: *path_len as usize,
path_len: { *path_len },
version,
};
let dst_peer_id = *graph.node_weight(*dst).unwrap();
@@ -841,7 +834,7 @@ impl RouteTable {
// build next hop map
let (graph, start_node) =
Self::build_peer_graph_from_synced_info(my_peer_id, &synced_info, cost_calc);
Self::build_peer_graph_from_synced_info(my_peer_id, synced_info, cost_calc);
if graph.node_count() == 0 {
tracing::warn!("no peer in graph, cannot build next hop map");
@@ -1031,11 +1024,11 @@ impl SyncRouteSession {
.unwrap_or(false)
}
fn update_dst_saved_peer_info_version(&self, infos: &Vec<RoutePeerInfo>) {
fn update_dst_saved_peer_info_version(&self, infos: &[RoutePeerInfo]) {
for info in infos.iter() {
self.dst_saved_peer_info_versions
.entry(info.peer_id)
.or_insert_with(|| AtomicVersion::new())
.or_insert_with(AtomicVersion::new)
.set_if_larger(info.version);
}
}
@@ -1044,7 +1037,7 @@ impl SyncRouteSession {
for (peer_id, version) in conn_bitmap.peer_ids.iter() {
self.dst_saved_conn_bitmap_version
.entry(*peer_id)
.or_insert_with(|| AtomicVersion::new())
.or_insert_with(AtomicVersion::new)
.set_if_larger(*version);
}
}
@@ -1053,7 +1046,7 @@ impl SyncRouteSession {
for item in foreign_network.infos.iter() {
self.dst_saved_foreign_network_versions
.entry(item.key.clone().unwrap())
.or_insert_with(|| AtomicVersion::new())
.or_insert_with(AtomicVersion::new)
.set_if_larger(item.value.as_ref().unwrap().version);
}
}
@@ -1249,13 +1242,10 @@ impl PeerRouteServiceImpl {
.list_foreign_networks()
.await;
let updated = self
.synced_route_info
.update_my_foreign_network(self.my_peer_id, foreign_networks);
// do not need update owner map because we always filter out my peer id.
updated
self.synced_route_info
.update_my_foreign_network(self.my_peer_id, foreign_networks)
}
fn update_route_table(&self) {
@@ -1317,7 +1307,7 @@ impl PeerRouteServiceImpl {
};
self.foreign_network_owner_map
.entry(network_identity)
.or_insert_with(|| Vec::new())
.or_default()
.push(entry.my_peer_id_for_this_network);
self.foreign_network_my_peer_id_map.insert(
@@ -1350,8 +1340,7 @@ impl PeerRouteServiceImpl {
.synced_route_info
.conn_map
.iter()
.map(|x| x.value().clone().0.into_iter())
.flatten()
.flat_map(|x| x.value().clone().0.into_iter())
.collect::<BTreeSet<_>>();
let all_peer_ids = self
@@ -1364,7 +1353,7 @@ impl PeerRouteServiceImpl {
.collect::<Vec<_>>();
let mut conn_bitmap = RouteConnBitmap::new();
conn_bitmap.bitmap = vec![0; (all_peer_ids.len() * all_peer_ids.len() + 7) / 8];
conn_bitmap.bitmap = vec![0; (all_peer_ids.len() * all_peer_ids.len()).div_ceil(8)];
conn_bitmap.peer_ids = all_peer_ids;
let all_peer_ids = &conn_bitmap.peer_ids;
@@ -1419,7 +1408,7 @@ impl PeerRouteServiceImpl {
for (peer_id, local_version) in self.cached_local_conn_map.lock().unwrap().peer_ids.iter() {
let peer_version = session
.dst_saved_conn_bitmap_version
.get(&peer_id)
.get(peer_id)
.map(|item| item.get());
if peer_version.is_none() || peer_version.unwrap() < *local_version {
need_update = true;
@@ -1442,7 +1431,7 @@ impl PeerRouteServiceImpl {
for item in self.synced_route_info.foreign_network.iter() {
if session
.dst_saved_foreign_network_versions
.get(&item.key())
.get(item.key())
.map(|x| x.get() >= item.value().version)
.unwrap_or(false)
{
@@ -1485,9 +1474,9 @@ impl PeerRouteServiceImpl {
Option<RouteConnBitmap>,
Option<RouteForeignNetworkInfos>,
) {
let route_infos = self.build_route_info(&session);
let conn_bitmap = self.build_conn_bitmap(&session);
let foreign_network = self.build_foreign_network_info(&session);
let route_infos = self.build_route_info(session);
let conn_bitmap = self.build_conn_bitmap(session);
let foreign_network = self.build_foreign_network_info(session);
(route_infos, conn_bitmap, foreign_network)
}
@@ -1661,19 +1650,19 @@ impl PeerRouteServiceImpl {
session.update_dst_session_id(resp.session_id);
if let Some(peer_infos) = &peer_infos {
session.update_dst_saved_peer_info_version(&peer_infos);
session.update_dst_saved_peer_info_version(peer_infos);
}
if let Some(conn_bitmap) = &conn_bitmap {
session.update_dst_saved_conn_bitmap_version(&conn_bitmap);
session.update_dst_saved_conn_bitmap_version(conn_bitmap);
}
if let Some(foreign_network) = &foreign_network {
session.update_dst_saved_foreign_network_version(&foreign_network);
session.update_dst_saved_foreign_network_version(foreign_network);
}
}
}
return false;
false
}
fn update_peer_info_last_update(&self) {
@@ -1767,11 +1756,10 @@ impl OspfRouteRpc for RouteSessionManager {
Ok(match ret {
Ok(v) => v,
Err(e) => {
let mut resp = SyncRouteInfoResponse::default();
resp.error = Some(e as i32);
resp
}
Err(e) => SyncRouteInfoResponse {
error: Some(e as i32),
..Default::default()
},
})
}
}
@@ -1828,12 +1816,9 @@ impl RouteSessionManager {
select! {
_ = tokio::time::sleep(Duration::from_secs(1)) => {}
ret = sync_now.recv() => match ret {
Err(e) => {
tracing::debug!(?e, "session_task sync_now recv failed, ospf route may exit");
break;
},
_ => {}
ret = sync_now.recv() => if let Err(e) = ret {
tracing::debug!(?e, "session_task sync_now recv failed, ospf route may exit");
break;
}
}
}
@@ -1903,7 +1888,7 @@ impl RouteSessionManager {
};
!session.dst_is_initiator.load(Ordering::Relaxed)
})
.map(|x| *x)
.copied()
.collect::<Vec<_>>();
if initiator_candidates.is_empty() {
@@ -1998,6 +1983,7 @@ impl RouteSessionManager {
tracing::debug!(?ret, ?reason, "sync_now_broadcast.send");
}
#[allow(clippy::too_many_arguments)]
async fn do_sync_route_info(
&self,
from_peer_id: PeerId,
@@ -2034,7 +2020,7 @@ impl RouteSessionManager {
}
if let Some(conn_bitmap) = &conn_bitmap {
service_impl.synced_route_info.update_conn_map(&conn_bitmap);
service_impl.synced_route_info.update_conn_map(conn_bitmap);
session.update_dst_saved_conn_bitmap_version(conn_bitmap);
need_update_route_table = true;
}
@@ -2046,7 +2032,7 @@ impl RouteSessionManager {
if let Some(foreign_network) = &foreign_network {
service_impl
.synced_route_info
.update_foreign_network(&foreign_network);
.update_foreign_network(foreign_network);
session.update_dst_saved_foreign_network_version(foreign_network);
}
@@ -2267,7 +2253,7 @@ impl Route for PeerRoute {
route.cost_latency_first = next_hop_peer_latency_first.map(|x| x.path_len as i32);
route.path_latency_latency_first = next_hop_peer_latency_first.map(|x| x.path_latency);
route.feature_flag = item.feature_flag.clone();
route.feature_flag = item.feature_flag;
routes.push(route);
}
@@ -2455,7 +2441,7 @@ mod tests {
let r_a = create_mock_route(p_a.clone()).await;
let r_b = create_mock_route(p_b.clone()).await;
for r in vec![r_a.clone(), r_b.clone()].iter() {
for r in [r_a.clone(), r_b.clone()].iter() {
wait_for_condition(
|| async {
println!("route: {:?}", r.list_routes().await);
@@ -2507,7 +2493,7 @@ mod tests {
drop(p_b);
wait_for_condition(
|| async { r_a.list_routes().await.len() == 0 },
|| async { r_a.list_routes().await.is_empty() },
Duration::from_secs(5),
)
.await;
@@ -2531,7 +2517,7 @@ mod tests {
let r_b = create_mock_route(p_b.clone()).await;
let r_c = create_mock_route(p_c.clone()).await;
for r in vec![r_a.clone(), r_b.clone(), r_c.clone()].iter() {
for r in [r_a.clone(), r_b.clone(), r_c.clone()].iter() {
wait_for_condition(
|| async { r.service_impl.synced_route_info.peer_infos.len() == 3 },
Duration::from_secs(5),
@@ -2563,10 +2549,10 @@ mod tests {
connect_peer_manager(p_d.clone(), p_c.clone()).await;
// find the smallest peer_id, which should be a center node
let mut all_route = vec![r_a.clone(), r_b.clone(), r_c.clone(), r_d.clone()];
let mut all_route = [r_a.clone(), r_b.clone(), r_c.clone(), r_d.clone()];
all_route.sort_by(|a, b| a.my_peer_id.cmp(&b.my_peer_id));
let mut all_peer_mgr = vec![p_a.clone(), p_b.clone(), p_c.clone(), p_d.clone()];
all_peer_mgr.sort_by(|a, b| a.my_peer_id().cmp(&b.my_peer_id()));
let mut all_peer_mgr = [p_a.clone(), p_b.clone(), p_c.clone(), p_d.clone()];
all_peer_mgr.sort_by_key(|a| a.my_peer_id());
wait_for_condition(
|| async { all_route[0].service_impl.sessions.len() == 3 },
@@ -2664,7 +2650,7 @@ mod tests {
let r_b = create_mock_route(p_b.clone()).await;
let r_c = create_mock_route(p_c.clone()).await;
for r in vec![r_a.clone(), r_b.clone(), r_c.clone()].iter() {
for r in [r_a.clone(), r_b.clone(), r_c.clone()].iter() {
wait_for_condition(
|| async { r.service_impl.synced_route_info.peer_infos.len() == 3 },
Duration::from_secs(5),
@@ -2684,7 +2670,7 @@ mod tests {
drop(r_c);
drop(p_c);
for r in vec![r_a.clone(), r_b.clone()].iter() {
for r in [r_a.clone(), r_b.clone()].iter() {
wait_for_condition(
|| async { r.list_routes().await.len() == 1 },
Duration::from_secs(5),
@@ -2717,7 +2703,7 @@ mod tests {
.await
.unwrap();
wait_for_condition(
|| async { r_a.list_routes().await.len() == 0 },
|| async { r_a.list_routes().await.is_empty() },
Duration::from_secs(5),
)
.await;
@@ -2756,7 +2742,7 @@ mod tests {
// in normal mode, packet from p_c should directly forward to p_a
wait_for_condition(
|| async { r_d.get_next_hop(p_a.my_peer_id()).await != None },
|| async { (r_d.get_next_hop(p_a.my_peer_id()).await).is_some() },
Duration::from_secs(5),
)
.await;
easytier/src/peers/peer_rpc.rs
+5 -2
View File
@@ -4,7 +4,7 @@ use futures::{SinkExt as _, StreamExt};
use tokio::task::JoinSet;
use crate::{
common::{error::Error, PeerId, stats_manager::StatsManager},
common::{error::Error, stats_manager::StatsManager, PeerId},
proto::rpc_impl::{self, bidirect::BidirectRpcManager},
tunnel::packet_def::ZCPacket,
};
@@ -47,7 +47,10 @@ impl PeerRpcManager {
}
}
pub fn new_with_stats_manager(tspt: impl PeerRpcManagerTransport, stats_manager: Arc<StatsManager>) -> Self {
pub fn new_with_stats_manager(
tspt: impl PeerRpcManagerTransport,
stats_manager: Arc<StatsManager>,
) -> Self {
Self {
tspt: Arc::new(Box::new(tspt)),
bidirect_rpc: BidirectRpcManager::new_with_stats_manager(stats_manager),
easytier/src/peers/route_trait.rs
+6 -8
View File
@@ -1,4 +1,7 @@
use std::{net::{Ipv4Addr, Ipv6Addr}, sync::Arc};
use std::{
net::{Ipv4Addr, Ipv6Addr},
sync::Arc,
};
use dashmap::DashMap;
@@ -10,18 +13,13 @@ use crate::{
},
};
#[derive(Clone, Debug)]
#[derive(Clone, Debug, Default)]
pub enum NextHopPolicy {
#[default]
LeastHop,
LeastCost,
}
impl Default for NextHopPolicy {
fn default() -> Self {
NextHopPolicy::LeastHop
}
}
pub type ForeignNetworkRouteInfoMap =
DashMap<ForeignNetworkRouteInfoKey, ForeignNetworkRouteInfoEntry>;
easytier/src/peers/rpc_service.rs
+19 -15
View File
@@ -40,17 +40,19 @@ impl PeerManagerRpcService {
let peer_map = peer_manager.get_peer_map();
let mut peer_infos = Vec::new();
for peer in peers {
let mut peer_info = PeerInfo::default();
peer_info.peer_id = peer;
peer_info.default_conn_id = peer_map
.get_peer_default_conn_id(peer)
.await
.map(Into::into);
peer_info.directly_connected_conns = peer_map
.get_directly_connections_by_peer_id(peer)
.into_iter()
.map(Into::into)
.collect();
let mut peer_info = PeerInfo {
peer_id: peer,
default_conn_id: peer_map
.get_peer_default_conn_id(peer)
.await
.map(Into::into),
directly_connected_conns: peer_map
.get_directly_connections_by_peer_id(peer)
.into_iter()
.map(Into::into)
.collect(),
..Default::default()
};
if let Some(conns) = peer_map.list_peer_conns(peer).await {
peer_info.conns = conns;
@@ -93,8 +95,9 @@ impl PeerManageRpc for PeerManagerRpcService {
_: BaseController,
_request: ListRouteRequest, // Accept request of type HelloRequest
) -> Result<ListRouteResponse, rpc_types::error::Error> {
let mut reply = ListRouteResponse::default();
reply.routes = self.peer_manager.list_routes().await;
let reply = ListRouteResponse {
routes: self.peer_manager.list_routes().await,
};
Ok(reply)
}
@@ -103,8 +106,9 @@ impl PeerManageRpc for PeerManagerRpcService {
_: BaseController,
_request: DumpRouteRequest, // Accept request of type HelloRequest
) -> Result<DumpRouteResponse, rpc_types::error::Error> {
let mut reply = DumpRouteResponse::default();
reply.result = self.peer_manager.dump_route().await;
let reply = DumpRouteResponse {
result: self.peer_manager.dump_route().await,
};
Ok(reply)
}
easytier/src/peers/tests.rs
+1 -1
View File
@@ -65,7 +65,7 @@ pub async fn wait_route_appear_with_cost(
}
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
}
return Err(Error::NotFound);
Err(Error::NotFound)
}
pub async fn wait_route_appear(