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

chore: update Rust to 2024 edition (#2066)

Browse Source
This commit is contained in:
Luna Yao
2026-04-10 00:22:12 +08:00
committed by GitHub
parent a8feb9ac2b
commit a879dd1b14
158 changed files with 1327 additions and 1231 deletions
Download Patch File Download Diff File Expand all files Collapse all files
easytier/src/peers/acl_filter.rs
+19 -19
View File
@@ -3,14 +3,14 @@ use std::sync::atomic::Ordering;
use std::time::Instant;
use std::{
net::IpAddr,
sync::{atomic::AtomicBool, Arc},
sync::{Arc, atomic::AtomicBool},
};
use arc_swap::ArcSwap;
use dashmap::DashMap;
use pnet::packet::ipv6::Ipv6Packet;
use pnet::packet::{
ip::IpNextHeaderProtocols, ipv4::Ipv4Packet, tcp::TcpPacket, udp::UdpPacket, Packet as _,
Packet as _, ip::IpNextHeaderProtocols, ipv4::Ipv4Packet, tcp::TcpPacket, udp::UdpPacket,
};
use crate::common::scoped_task::ScopedTask;
@@ -238,23 +238,23 @@ impl AclFilter {
chain_type: ChainType,
processor: &AclProcessor,
) {
if result.should_log {
if let Some(ref log_context) = result.log_context {
let log_message = log_context.to_message();
tracing::info!(
src_ip = %packet_info.src_ip,
dst_ip = %packet_info.dst_ip,
src_port = packet_info.src_port,
dst_port = packet_info.dst_port,
src_group = packet_info.src_groups.join(","),
dst_group = packet_info.dst_groups.join(","),
protocol = ?packet_info.protocol,
action = ?result.action,
rule = result.matched_rule_str().as_deref().unwrap_or("unknown"),
chain_type = ?chain_type,
"ACL: {}", log_message
);
}
if result.should_log
&& let Some(ref log_context) = result.log_context
{
let log_message = log_context.to_message();
tracing::info!(
src_ip = %packet_info.src_ip,
dst_ip = %packet_info.dst_ip,
src_port = packet_info.src_port,
dst_port = packet_info.dst_port,
src_group = packet_info.src_groups.join(","),
dst_group = packet_info.dst_groups.join(","),
protocol = ?packet_info.protocol,
action = ?result.action,
rule = result.matched_rule_str().as_deref().unwrap_or("unknown"),
chain_type = ?chain_type,
"ACL: {}", log_message
);
}
// Update global statistics in the ACL processor
easytier/src/peers/credential_manager.rs
+15 -14
View File
@@ -5,8 +5,8 @@ use std::{
time::{Duration, SystemTime, UNIX_EPOCH},
};
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
use base64::Engine;
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
use serde::{Deserialize, Serialize};
use x25519_dalek::{PublicKey, StaticSecret};
@@ -62,10 +62,10 @@ impl CredentialManager {
.map(|x| x.trim().to_string())
.filter(|x| !x.is_empty())
{
if let Some(existing) = credentials.get(&id) {
if !existing.secret.is_empty() {
return (id, existing.secret.clone());
}
if let Some(existing) = credentials.get(&id)
&& !existing.secret.is_empty()
{
return (id, existing.secret.clone());
}
id
} else {
@@ -191,10 +191,10 @@ impl CredentialManager {
return;
};
let creds = self.credentials.lock().unwrap();
if let Ok(json) = serde_json::to_string_pretty(&*creds) {
if let Err(e) = std::fs::write(path, json) {
tracing::warn!(?e, "failed to save credentials to disk");
}
if let Ok(json) = serde_json::to_string_pretty(&*creds)
&& let Err(e) = std::fs::write(path, json)
{
tracing::warn!(?e, "failed to save credentials to disk");
}
}
@@ -386,11 +386,12 @@ mod tests {
);
assert!(tc.credential.as_ref().unwrap().expiry_unix > 0);
assert!(tc.verify_credential_hmac("sec"));
assert!(tc
.credential
.as_ref()
.map(|x| !x.pubkey.is_empty())
.unwrap_or(false));
assert!(
tc.credential
.as_ref()
.map(|x| !x.pubkey.is_empty())
.unwrap_or(false)
);
let sk: [u8; 32] = BASE64_STANDARD.decode(&secret).unwrap().try_into().unwrap();
let pk = PublicKey::from(&StaticSecret::from(sk)).as_bytes().to_vec();
easytier/src/peers/encrypt/aes_gcm.rs
+1 -1
View File
@@ -137,7 +137,7 @@ impl Encryptor for AesGcmCipher {
#[cfg(test)]
mod tests {
use crate::{
peers::encrypt::{aes_gcm::AesGcmCipher, Encryptor},
peers::encrypt::{Encryptor, aes_gcm::AesGcmCipher},
tunnel::packet_def::{StandardAeadTail, ZCPacket},
};
use zerocopy::FromBytes;
easytier/src/peers/encrypt/ring.rs
+1 -1
View File
@@ -155,7 +155,7 @@ impl Encryptor for RingCipher {
#[cfg(test)]
mod tests {
use crate::{
peers::encrypt::{ring::RingCipher, Encryptor},
peers::encrypt::{Encryptor, ring::RingCipher},
tunnel::packet_def::{StandardAeadTail, ZCPacket},
};
use zerocopy::FromBytes;
easytier/src/peers/encrypt/xor.rs
+1 -1
View File
@@ -61,7 +61,7 @@ impl Encryptor for XorCipher {
#[cfg(test)]
mod tests {
use crate::{
peers::encrypt::{xor::XorCipher, Encryptor},
peers::encrypt::{Encryptor, xor::XorCipher},
tunnel::packet_def::ZCPacket,
};
easytier/src/peers/foreign_network_client.rs
+2 -2
View File
@@ -1,11 +1,11 @@
use std::sync::{Arc, Mutex};
use crate::{
common::{error::Error, global_ctx::ArcGlobalCtx, scoped_task::ScopedTask, PeerId},
common::{PeerId, error::Error, global_ctx::ArcGlobalCtx, scoped_task::ScopedTask},
tunnel::packet_def::ZCPacket,
};
use super::{peer_conn::PeerConn, peer_map::PeerMap, peer_rpc::PeerRpcManager, PacketRecvChan};
use super::{PacketRecvChan, peer_conn::PeerConn, peer_map::PeerMap, peer_rpc::PeerRpcManager};
pub struct ForeignNetworkClient {
global_ctx: ArcGlobalCtx,
easytier/src/peers/foreign_network_manager.rs
+35 -26
View File
@@ -13,21 +13,21 @@ use std::{
use dashmap::{DashMap, DashSet};
use tokio::{
sync::{
mpsc::{self, UnboundedReceiver, UnboundedSender},
Mutex,
mpsc::{self, UnboundedReceiver, UnboundedSender},
},
task::JoinSet,
};
use crate::{
common::{
PeerId,
config::{ConfigLoader, TomlConfigLoader},
error::Error,
global_ctx::{ArcGlobalCtx, GlobalCtx, GlobalCtxEvent, NetworkIdentity, TrustedKeySource},
join_joinset_background, shrink_dashmap,
stats_manager::{LabelSet, LabelType, MetricName, StatsManager},
token_bucket::TokenBucket,
PeerId,
},
peer_center::instance::{PeerCenterInstance, PeerMapWithPeerRpcManager},
peers::route_trait::{Route, RouteInterface},
@@ -44,7 +44,7 @@ use crate::{
};
use super::{
create_packet_recv_chan,
PUBLIC_SERVER_HOSTNAME_PREFIX, PacketRecvChan, PacketRecvChanReceiver, create_packet_recv_chan,
peer_conn::PeerConn,
peer_map::PeerMap,
peer_ospf_route::PeerRoute,
@@ -55,10 +55,9 @@ use super::{
relay_peer_map::RelayPeerMap,
route_trait::NextHopPolicy,
traffic_metrics::{
route_peer_info_instance_id, InstanceLabelKind, LogicalTrafficMetrics,
TrafficMetricRecorder,
InstanceLabelKind, LogicalTrafficMetrics, TrafficMetricRecorder,
route_peer_info_instance_id,
},
PacketRecvChan, PacketRecvChanReceiver, PUBLIC_SERVER_HOSTNAME_PREFIX,
};
#[async_trait::async_trait]
@@ -1454,9 +1453,11 @@ pub mod tests {
.get_foreign_network_manager()
.list_foreign_networks()
.await;
assert!(without_trusted_keys.foreign_networks["net1"]
.trusted_keys
.is_empty());
assert!(
without_trusted_keys.foreign_networks["net1"]
.trusted_keys
.is_empty()
);
let foreign_mgr = pm_center.get_foreign_network_manager();
wait_for_condition(
@@ -1477,9 +1478,11 @@ pub mod tests {
.await;
let with_trusted_keys = foreign_mgr.list_foreign_networks_with_options(true).await;
assert!(!with_trusted_keys.foreign_networks["net1"]
.trusted_keys
.is_empty());
assert!(
!with_trusted_keys.foreign_networks["net1"]
.trusted_keys
.is_empty()
);
}
#[tokio::test]
@@ -1558,12 +1561,14 @@ pub mod tests {
assert!(client.await.unwrap().is_ok());
assert!(server.await.unwrap().is_err());
assert!(pm_center
.get_foreign_network_manager()
.list_foreign_networks()
.await
.foreign_networks
.is_empty());
assert!(
pm_center
.get_foreign_network_manager()
.list_foreign_networks()
.await
.foreign_networks
.is_empty()
);
}
async fn foreign_network_whitelist_helper(name: String) {
@@ -1651,20 +1656,24 @@ pub mod tests {
.unwrap();
assert_eq!(
vec![pm_center
.get_foreign_network_manager()
.get_network_peer_id("net1")
.unwrap()],
vec![
pm_center
.get_foreign_network_manager()
.get_network_peer_id("net1")
.unwrap()
],
pma_net1
.get_foreign_network_client()
.get_peer_map()
.list_peers()
);
assert_eq!(
vec![pm_center
.get_foreign_network_manager()
.get_network_peer_id("net1")
.unwrap()],
vec![
pm_center
.get_foreign_network_manager()
.get_network_peer_id("net1")
.unwrap()
],
pmb_net1
.get_foreign_network_client()
.get_peer_map()
easytier/src/peers/peer.rs
+4 -4
View File
@@ -9,14 +9,14 @@ use tokio::{select, sync::mpsc};
use tracing::Instrument;
use super::{
peer_conn::{PeerConn, PeerConnId},
PacketRecvChan,
peer_conn::{PeerConn, PeerConnId},
};
use crate::{
common::{
PeerId,
error::Error,
global_ctx::{ArcGlobalCtx, GlobalCtxEvent},
PeerId,
},
proto::peer_rpc::PeerIdentityType,
tunnel::packet_def::ZCPacket,
@@ -294,7 +294,7 @@ impl Drop for Peer {
#[cfg(test)]
mod tests {
use base64::prelude::{Engine as _, BASE64_STANDARD};
use base64::prelude::{BASE64_STANDARD, Engine as _};
use rand::rngs::OsRng;
use std::sync::Arc;
use tokio::time::timeout;
@@ -302,7 +302,7 @@ mod tests {
use crate::{
common::{
config::{NetworkIdentity, PeerConfig},
global_ctx::{tests::get_mock_global_ctx, GlobalCtx},
global_ctx::{GlobalCtx, tests::get_mock_global_ctx},
new_peer_id,
},
peers::{create_packet_recv_chan, peer_conn::PeerConn, peer_session::PeerSessionStore},
easytier/src/peers/peer_conn.rs
+27 -26
View File
@@ -3,37 +3,37 @@ use std::{
fmt::Debug,
pin::Pin,
sync::{
atomic::{AtomicU32, Ordering},
Arc,
atomic::{AtomicU32, Ordering},
},
};
use crossbeam::atomic::AtomicCell;
use futures::{StreamExt, TryFutureExt};
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
use base64::Engine as _;
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
use hmac::Mac;
use prost::Message;
use tokio::{
sync::{broadcast, Mutex},
sync::{Mutex, broadcast},
task::JoinSet,
time::{timeout, Duration},
time::{Duration, timeout},
};
use tracing::Instrument;
use zerocopy::AsBytes;
use snow::{params::NoiseParams, HandshakeState};
use snow::{HandshakeState, params::NoiseParams};
use crate::{
common::{
PeerId,
config::{NetworkIdentity, NetworkSecretDigest},
defer,
error::Error,
global_ctx::ArcGlobalCtx,
PeerId,
},
peers::peer_session::{PeerSessionStore, SessionKey, UpsertResponderSessionReturn},
proto::{
@@ -45,20 +45,20 @@ use crate::{
},
},
tunnel::{
Tunnel, TunnelError, ZCPacketStream,
filter::{StatsRecorderTunnelFilter, TunnelFilter, TunnelFilterChain, TunnelWithFilter},
mpsc::{MpscTunnel, MpscTunnelSender},
packet_def::{PacketType, ZCPacket},
stats::{Throughput, WindowLatency},
Tunnel, TunnelError, ZCPacketStream,
},
use_global_var,
};
use super::{
PacketRecvChan,
peer_conn_ping::PeerConnPinger,
peer_session::{PeerSession, PeerSessionAction},
traffic_metrics::AggregateTrafficMetrics,
PacketRecvChan,
};
pub type PeerConnId = uuid::Uuid;
@@ -458,12 +458,12 @@ impl PeerConn {
return Err(Error::WaitRespError(format!(
"conn recv error during wait handshake response, err: {:?}",
e
)))
)));
}
None => {
return Err(Error::WaitRespError(
"conn closed during wait handshake response".to_owned(),
))
));
}
};
@@ -610,7 +610,7 @@ impl PeerConn {
return Err(Error::WaitRespError(format!(
"conn recv error during wait handshake response, err: {:?}",
e
)))
)));
}
};
@@ -716,12 +716,11 @@ impl PeerConn {
remote_network_name: &str,
) -> Result<SecureAuthLevel, Error> {
// 1. Verify proof
if let Some(proof) = proof {
if let Some(mac) = self.global_ctx.get_secret_proof(handshake_hash) {
if mac.verify_slice(proof).is_ok() {
return Ok(SecureAuthLevel::NetworkSecretConfirmed);
}
}
if let Some(proof) = proof
&& let Some(mac) = self.global_ctx.get_secret_proof(handshake_hash)
&& mac.verify_slice(proof).is_ok()
{
return Ok(SecureAuthLevel::NetworkSecretConfirmed);
}
// 2. Check pinned pubkey
@@ -848,10 +847,10 @@ impl PeerConn {
.await??;
self.record_control_rx(&network.network_name, msg2.buf_len() as u64);
let remote_peer_id = msg2.get_src_peer_id().expect("missing src peer id");
if let Some(hint) = self.peer_id_hint {
if hint != remote_peer_id {
return Err(Error::WaitRespError("peer_id mismatch".to_owned()));
}
if let Some(hint) = self.peer_id_hint
&& hint != remote_peer_id
{
return Err(Error::WaitRespError("peer_id mismatch".to_owned()));
}
let msg2_pb = Self::decode_handshake_message::<PeerConnNoiseMsg2Pb>(
PacketType::NoiseHandshakeMsg2,
@@ -1604,16 +1603,16 @@ pub mod tests {
use super::*;
use crate::common::config::PeerConfig;
use crate::common::global_ctx::tests::get_mock_global_ctx;
use crate::common::global_ctx::GlobalCtx;
use crate::common::global_ctx::tests::get_mock_global_ctx;
use crate::common::new_peer_id;
use crate::common::scoped_task::ScopedTask;
use crate::common::stats_manager::{LabelSet, LabelType, MetricName};
use crate::peers::create_packet_recv_chan;
use crate::peers::recv_packet_from_chan;
use crate::tunnel::common::tests::wait_for_condition;
use crate::tunnel::filter::tests::DropSendTunnelFilter;
use crate::tunnel::filter::PacketRecorderTunnelFilter;
use crate::tunnel::filter::tests::DropSendTunnelFilter;
use crate::tunnel::ring::create_ring_tunnel_pair;
pub fn set_secure_mode_cfg(global_ctx: &GlobalCtx, enabled: bool) {
@@ -2489,9 +2488,11 @@ pub mod tests {
);
// Revoke the credential
assert!(admin_ctx
.get_credential_manager()
.revoke_credential(&cred_id));
assert!(
admin_ctx
.get_credential_manager()
.revoke_credential(&cred_id)
);
// Now try to connect with the revoked credential
let (c, s) = create_ring_tunnel_pair();
easytier/src/peers/peer_conn_ping.rs
+5 -5
View File
@@ -1,27 +1,27 @@
use std::{
sync::{
atomic::{AtomicU32, Ordering},
Arc,
atomic::{AtomicU32, Ordering},
},
time::Duration,
};
use rand::{thread_rng, Rng};
use rand::{Rng, thread_rng};
use tokio::{
sync::broadcast,
task::JoinSet,
time::{timeout, Interval},
time::{Interval, timeout},
};
use tracing::Instrument;
use crate::{
common::{error::Error, PeerId},
common::{PeerId, error::Error},
peers::traffic_metrics::AggregateTrafficMetrics,
tunnel::{
TunnelError,
mpsc::MpscTunnelSender,
packet_def::{PacketType, ZCPacket},
stats::{Throughput, WindowLatency},
TunnelError,
},
};
easytier/src/peers/peer_manager.rs
+61 -54
View File
@@ -1,7 +1,7 @@
use std::{
fmt::Debug,
net::{IpAddr, Ipv4Addr, Ipv6Addr},
sync::{atomic::AtomicBool, Arc, Weak},
sync::{Arc, Weak, atomic::AtomicBool},
time::{Duration, Instant, SystemTime},
};
@@ -12,14 +12,15 @@ use dashmap::DashMap;
use tokio::{
sync::{
mpsc::{self, UnboundedReceiver, UnboundedSender},
Mutex, RwLock,
mpsc::{self, UnboundedReceiver, UnboundedSender},
},
task::JoinSet,
};
use crate::{
common::{
PeerId,
compressor::{Compressor as _, DefaultCompressor},
constants::EASYTIER_VERSION,
error::Error,
@@ -27,24 +28,23 @@ use crate::{
shrink_dashmap,
stats_manager::{CounterHandle, LabelSet, LabelType, MetricName},
stun::StunInfoCollectorTrait,
PeerId,
},
peers::{
PeerPacketFilter,
peer_conn::PeerConn,
peer_rpc::PeerRpcManagerTransport,
peer_session::PeerSessionStore,
recv_packet_from_chan,
route_trait::{ForeignNetworkRouteInfoMap, MockRoute, NextHopPolicy, RouteInterface},
traffic_metrics::{
route_peer_info_instance_id, InstanceLabelKind, LogicalTrafficMetrics,
TrafficMetricRecorder,
InstanceLabelKind, LogicalTrafficMetrics, TrafficMetricRecorder,
route_peer_info_instance_id,
},
PeerPacketFilter,
},
proto::{
api::instance::{
self, list_global_foreign_network_response::OneForeignNetwork,
ListGlobalForeignNetworkResponse,
self, ListGlobalForeignNetworkResponse,
list_global_foreign_network_response::OneForeignNetwork,
},
peer_rpc::{
ForeignNetworkRouteInfoEntry, ForeignNetworkRouteInfoKey, PeerIdentityType,
@@ -52,13 +52,13 @@ use crate::{
},
},
tunnel::{
self,
self, Tunnel, TunnelConnector,
packet_def::{CompressorAlgo, PacketType, ZCPacket},
Tunnel, TunnelConnector,
},
};
use super::{
BoxNicPacketFilter, BoxPeerPacketFilter, PacketRecvChan, PacketRecvChanReceiver,
create_packet_recv_chan,
encrypt::{Encryptor, NullCipher},
foreign_network_client::ForeignNetworkClient,
@@ -70,7 +70,6 @@ use super::{
peer_task::ExternalTaskSignal,
relay_peer_map::RelayPeerMap,
route_trait::{ArcRoute, Route},
BoxNicPacketFilter, BoxPeerPacketFilter, PacketRecvChan, PacketRecvChanReceiver,
};
struct RpcTransport {
@@ -1408,10 +1407,10 @@ impl PeerManager {
Err(Error::RouteError(None))
};
if send_result.is_ok() {
if let Some(metrics) = direct_tx_metrics {
metrics.record_tx(dst_peer_id, packet_type, msg_len).await;
}
if send_result.is_ok()
&& let Some(metrics) = direct_tx_metrics
{
metrics.record_tx(dst_peer_id, packet_type, msg_len).await;
}
send_result
@@ -1996,7 +1995,7 @@ mod tests {
use crate::{
common::{
config::Flags,
global_ctx::{tests::get_mock_global_ctx, NetworkIdentity},
global_ctx::{NetworkIdentity, tests::get_mock_global_ctx},
stats_manager::{LabelSet, LabelType, MetricName},
},
connector::{
@@ -2020,11 +2019,11 @@ mod tests {
peer_rpc::SecureAuthLevel,
},
tunnel::{
TunnelConnector, TunnelListener,
common::tests::wait_for_condition,
filter::{tests::DropSendTunnelFilter, TunnelWithFilter},
filter::{TunnelWithFilter, tests::DropSendTunnelFilter},
packet_def::{PacketType, ZCPacket},
ring::create_ring_tunnel_pair,
TunnelConnector, TunnelListener,
},
};
@@ -2194,24 +2193,28 @@ mod tests {
.value,
0
);
assert!(peer_mgr
.get_global_ctx()
.stats_manager()
.get_metric(
MetricName::TrafficBytesTxByInstance,
&network_labels
.clone()
.with_label_type(LabelType::ToInstanceId("unknown".to_string())),
)
.is_none());
assert!(peer_mgr
.get_global_ctx()
.stats_manager()
.get_metric(
MetricName::TrafficPacketsTxByInstance,
&network_labels.with_label_type(LabelType::ToInstanceId("unknown".to_string())),
)
.is_none());
assert!(
peer_mgr
.get_global_ctx()
.stats_manager()
.get_metric(
MetricName::TrafficBytesTxByInstance,
&network_labels
.clone()
.with_label_type(LabelType::ToInstanceId("unknown".to_string())),
)
.is_none()
);
assert!(
peer_mgr
.get_global_ctx()
.stats_manager()
.get_metric(
MetricName::TrafficPacketsTxByInstance,
&network_labels.with_label_type(LabelType::ToInstanceId("unknown".to_string())),
)
.is_none()
);
}
#[tokio::test]
@@ -2265,24 +2268,28 @@ mod tests {
),
0
);
assert!(peer_mgr
.get_global_ctx()
.stats_manager()
.get_metric(
MetricName::TrafficBytesTxByInstance,
&network_labels
.clone()
.with_label_type(LabelType::ToInstanceId("unknown".to_string())),
)
.is_none());
assert!(peer_mgr
.get_global_ctx()
.stats_manager()
.get_metric(
MetricName::TrafficControlBytesTxByInstance,
&network_labels.with_label_type(LabelType::ToInstanceId("unknown".to_string())),
)
.is_none());
assert!(
peer_mgr
.get_global_ctx()
.stats_manager()
.get_metric(
MetricName::TrafficBytesTxByInstance,
&network_labels
.clone()
.with_label_type(LabelType::ToInstanceId("unknown".to_string())),
)
.is_none()
);
assert!(
peer_mgr
.get_global_ctx()
.stats_manager()
.get_metric(
MetricName::TrafficControlBytesTxByInstance,
&network_labels.with_label_type(LabelType::ToInstanceId("unknown".to_string())),
)
.is_none()
);
}
#[tokio::test]
easytier/src/peers/peer_map.rs
+4 -3
View File
@@ -10,22 +10,23 @@ use tokio::sync::RwLock;
use crate::{
common::{
PeerId,
error::Error,
global_ctx::{ArcGlobalCtx, GlobalCtxEvent, NetworkIdentity},
shrink_dashmap, PeerId,
shrink_dashmap,
},
proto::{
api::instance::{self, PeerConnInfo},
peer_rpc::{PeerIdentityType, RoutePeerInfo},
},
tunnel::{packet_def::ZCPacket, TunnelError},
tunnel::{TunnelError, packet_def::ZCPacket},
};
use super::{
PacketRecvChan,
peer::Peer,
peer_conn::{PeerConn, PeerConnId},
route_trait::{ArcRoute, NextHopPolicy},
PacketRecvChan,
};
pub struct PeerMap {
easytier/src/peers/peer_ospf_route.rs
+107 -70
View File
@@ -3,8 +3,8 @@ use std::{
fmt::Debug,
net::{IpAddr, Ipv4Addr, Ipv6Addr},
sync::{
atomic::{AtomicBool, AtomicU32, Ordering},
Arc, Weak,
atomic::{AtomicBool, AtomicU32, Ordering},
},
time::{Duration, Instant, SystemTime},
};
@@ -14,12 +14,12 @@ use cidr::{IpCidr, Ipv4Cidr, Ipv6Cidr};
use crossbeam::atomic::AtomicCell;
use dashmap::DashMap;
use ordered_hash_map::OrderedHashMap;
use parking_lot::{lock_api::RwLockUpgradableReadGuard, RwLock};
use parking_lot::{RwLock, lock_api::RwLockUpgradableReadGuard};
use petgraph::{
Directed,
algo::dijkstra,
graph::{Graph, NodeIndex},
visit::{EdgeRef, IntoNodeReferences},
Directed,
};
use prefix_trie::PrefixMap;
use prost::Message;
@@ -32,25 +32,24 @@ use tokio::{
use crate::{
common::{
PeerId,
config::NetworkIdentity,
constants::EASYTIER_VERSION,
global_ctx::{ArcGlobalCtx, GlobalCtxEvent},
shrink_dashmap,
stun::StunInfoCollectorTrait,
PeerId,
},
peers::route_trait::{Route, RouteInterfaceBox},
proto::{
acl::GroupIdentity,
common::{Ipv4Inet, NatType, StunInfo},
peer_rpc::{
route_foreign_network_infos, route_foreign_network_summary,
sync_route_info_request::ConnInfo, ForeignNetworkRouteInfoEntry,
ForeignNetworkRouteInfoKey, OspfRouteRpc, OspfRouteRpcClientFactory,
OspfRouteRpcServer, PeerGroupInfo, PeerIdVersion, PeerIdentityType,
RouteForeignNetworkInfos, RouteForeignNetworkSummary, RoutePeerInfo, RoutePeerInfos,
SyncRouteInfoError, SyncRouteInfoRequest, SyncRouteInfoResponse,
TrustedCredentialPubkey,
ForeignNetworkRouteInfoEntry, ForeignNetworkRouteInfoKey, OspfRouteRpc,
OspfRouteRpcClientFactory, OspfRouteRpcServer, PeerGroupInfo, PeerIdVersion,
PeerIdentityType, RouteForeignNetworkInfos, RouteForeignNetworkSummary, RoutePeerInfo,
RoutePeerInfos, SyncRouteInfoError, SyncRouteInfoRequest, SyncRouteInfoResponse,
TrustedCredentialPubkey, route_foreign_network_infos, route_foreign_network_summary,
sync_route_info_request::ConnInfo,
},
rpc_types::{
self,
@@ -61,13 +60,13 @@ use crate::{
};
use super::{
PeerPacketFilter,
graph_algo::dijkstra_with_first_hop,
peer_rpc::PeerRpcManager,
route_trait::{
DefaultRouteCostCalculator, ForeignNetworkRouteInfoMap, NextHopPolicy, RouteCostCalculator,
RouteCostCalculatorInterface,
},
PeerPacketFilter,
};
use atomic_shim::AtomicU64;
@@ -2521,13 +2520,12 @@ impl PeerRouteServiceImpl {
let now = SystemTime::now();
let mut to_remove = Vec::new();
for (peer_id, peer_info) in self.synced_route_info.peer_infos.read().iter() {
if let Ok(d) = now.duration_since(peer_info.last_update.unwrap().try_into().unwrap()) {
if d > REMOVE_DEAD_PEER_INFO_AFTER
if let Ok(d) = now.duration_since(peer_info.last_update.unwrap().try_into().unwrap())
&& (d > REMOVE_DEAD_PEER_INFO_AFTER
|| (d > REMOVE_UNREACHABLE_PEER_INFO_AFTER
&& !self.route_table.peer_reachable(*peer_id))
{
to_remove.push(*peer_id);
}
&& !self.route_table.peer_reachable(*peer_id)))
{
to_remove.push(*peer_id);
}
}
@@ -2621,8 +2619,16 @@ impl PeerRouteServiceImpl {
return true;
}
tracing::debug!(?foreign_network, "sync_route request need send to peer. my_id {:?}, dst_peer_id: {:?}, peer_infos: {:?}, conn_info: {:?}, synced_route_info: {:?} session: {:?}",
my_peer_id, dst_peer_id, peer_infos, conn_info, self.synced_route_info, session);
tracing::debug!(
?foreign_network,
"sync_route request need send to peer. my_id {:?}, dst_peer_id: {:?}, peer_infos: {:?}, conn_info: {:?}, synced_route_info: {:?} session: {:?}",
my_peer_id,
dst_peer_id,
peer_infos,
conn_info,
self.synced_route_info,
session
);
session
.need_sync_initiator_info
@@ -2664,7 +2670,11 @@ impl PeerRouteServiceImpl {
tracing::debug!(
"sync_route_info resp: {:?}, req: {:?}, session: {:?}, my_info: {:?}, next_last_sync_succ_timestamp: {:?}",
ret, sync_route_info_req, session, self.global_ctx.network, next_last_sync_succ_timestamp
ret,
sync_route_info_req,
session,
self.global_ctx.network,
next_last_sync_succ_timestamp
);
match ret.as_ref() {
@@ -3020,10 +3030,10 @@ impl RouteSessionManager {
service_impl.my_peer_id
);
// update initiator flag for previous session
if let Some(cur_peer_id_to_initiate) = cur_dst_peer_id_to_initiate {
if let Some(session) = service_impl.get_session(cur_peer_id_to_initiate) {
session.update_initiator_flag(false);
}
if let Some(cur_peer_id_to_initiate) = cur_dst_peer_id_to_initiate
&& let Some(session) = service_impl.get_session(cur_peer_id_to_initiate)
{
session.update_initiator_flag(false);
}
cur_dst_peer_id_to_initiate = new_initiator_dst;
@@ -3247,7 +3257,14 @@ impl RouteSessionManager {
tracing::debug!(
"handling sync_route_info rpc: from_peer_id: {:?}, is_initiator: {:?}, peer_infos: {:?}, conn_info: {:?}, synced_route_info: {:?} session: {:?}, new_route_table: {:?}",
from_peer_id, is_initiator, peer_infos, conn_info, service_impl.synced_route_info, session, service_impl.route_table);
from_peer_id,
is_initiator,
peer_infos,
conn_info,
service_impl.synced_route_info,
session,
service_impl.route_table
);
session
.dst_is_initiator
@@ -3622,8 +3639,8 @@ mod tests {
use std::{
collections::{BTreeSet, HashMap},
sync::{
atomic::{AtomicU32, Ordering},
Arc,
atomic::{AtomicU32, Ordering},
},
time::{Duration, SystemTime},
};
@@ -3631,14 +3648,14 @@ mod tests {
use super::{PeerRoute, REMOVE_DEAD_PEER_INFO_AFTER};
use crate::{
common::{
global_ctx::{tests::get_mock_global_ctx, GlobalCtxEvent, TrustedKeySource},
PeerId,
global_ctx::{GlobalCtxEvent, TrustedKeySource, tests::get_mock_global_ctx},
},
connector::udp_hole_punch::tests::replace_stun_info_collector,
peers::{
create_packet_recv_chan,
peer_manager::{PeerManager, RouteAlgoType},
peer_ospf_route::{PeerIdVersion, PeerRouteServiceImpl, FORCE_USE_CONN_LIST},
peer_ospf_route::{FORCE_USE_CONN_LIST, PeerIdVersion, PeerRouteServiceImpl},
route_trait::{NextHopPolicy, Route, RouteCostCalculatorInterface, RouteInterface},
tests::{connect_peer_manager, create_mock_peer_manager, wait_route_appear},
},
@@ -3917,15 +3934,21 @@ mod tests {
}
assert!(service_impl.synced_route_info.is_admin_peer(&admin_info));
assert!(!service_impl
.synced_route_info
.is_admin_peer(&credential_info));
assert!(service_impl
.synced_route_info
.is_credential_peer(credential_info.peer_id));
assert!(!service_impl
.synced_route_info
.is_credential_peer(admin_info.peer_id));
assert!(
!service_impl
.synced_route_info
.is_admin_peer(&credential_info)
);
assert!(
service_impl
.synced_route_info
.is_credential_peer(credential_info.peer_id)
);
assert!(
!service_impl
.synced_route_info
.is_credential_peer(admin_info.peer_id)
);
}
#[tokio::test]
@@ -3983,14 +4006,18 @@ mod tests {
.synced_route_info
.verify_and_update_credential_trusts(Some(network_secret));
assert!(service_impl
.synced_route_info
.trusted_credential_pubkeys
.contains_key(&admin_key));
assert!(!service_impl
.synced_route_info
.trusted_credential_pubkeys
.contains_key(&credential_key));
assert!(
service_impl
.synced_route_info
.trusted_credential_pubkeys
.contains_key(&admin_key)
);
assert!(
!service_impl
.synced_route_info
.trusted_credential_pubkeys
.contains_key(&credential_key)
);
}
#[tokio::test]
@@ -4055,11 +4082,13 @@ mod tests {
let guard = route.service_impl.synced_route_info.peer_infos.read();
let stored = guard.get(&from_peer_id).unwrap();
assert!(stored
.feature_flag
.as_ref()
.map(|x| x.is_credential_peer)
.unwrap_or(false));
assert!(
stored
.feature_flag
.as_ref()
.map(|x| x.is_credential_peer)
.unwrap_or(false)
);
assert!(stored.proxy_cidrs.is_empty());
assert!(guard.get(&forwarded_peer_id).is_none());
}
@@ -4118,11 +4147,13 @@ mod tests {
.await
.unwrap();
assert!(!route
.service_impl
.synced_route_info
.trusted_credential_pubkeys
.contains_key(&credential_key));
assert!(
!route
.service_impl
.synced_route_info
.trusted_credential_pubkeys
.contains_key(&credential_key)
);
}
#[tokio::test]
@@ -4180,10 +4211,12 @@ mod tests {
.global_ctx
.update_trusted_keys(global_trusted_keys, &network_name);
assert!(service_impl
.synced_route_info
.trusted_credential_pubkeys
.contains_key(&credential_pubkey));
assert!(
service_impl
.synced_route_info
.trusted_credential_pubkeys
.contains_key(&credential_pubkey)
);
service_impl.clear_expired_peer().await;
@@ -4193,16 +4226,20 @@ mod tests {
TrustedKeySource::OspfCredential,
));
assert!(closed_peers.lock().contains(&credential_peer_id));
assert!(!service_impl
.synced_route_info
.peer_infos
.read()
.contains_key(&admin_peer_id));
assert!(!service_impl
.synced_route_info
.peer_infos
.read()
.contains_key(&credential_peer_id));
assert!(
!service_impl
.synced_route_info
.peer_infos
.read()
.contains_key(&admin_peer_id)
);
assert!(
!service_impl
.synced_route_info
.peer_infos
.read()
.contains_key(&credential_peer_id)
);
}
#[rstest::rstest]
easytier/src/peers/peer_rpc.rs
+5 -5
View File
@@ -4,7 +4,7 @@ use futures::{SinkExt as _, StreamExt};
use tokio::task::JoinSet;
use crate::{
common::{error::Error, stats_manager::StatsManager, PeerId},
common::{PeerId, error::Error, stats_manager::StatsManager},
proto::rpc_impl::{self, bidirect::BidirectRpcManager},
tunnel::packet_def::ZCPacket,
};
@@ -109,7 +109,7 @@ pub mod tests {
use tokio::sync::Mutex;
use crate::{
common::{error::Error, new_peer_id, PeerId},
common::{PeerId, error::Error, new_peer_id},
peers::{
peer_rpc::PeerRpcManager,
tests::{connect_peer_manager, create_mock_peer_manager, wait_route_appear},
@@ -119,16 +119,16 @@ pub mod tests {
tests::{GreetingClientFactory, GreetingServer, GreetingService, SayHelloRequest},
},
tunnel::{
packet_def::ZCPacket, ring::create_ring_tunnel_pair, Tunnel, ZCPacketSink,
ZCPacketStream,
Tunnel, ZCPacketSink, ZCPacketStream, packet_def::ZCPacket,
ring::create_ring_tunnel_pair,
},
};
use super::PeerRpcManagerTransport;
fn random_string(len: usize) -> String {
use rand::distributions::Alphanumeric;
use rand::Rng;
use rand::distributions::Alphanumeric;
let mut rng = rand::thread_rng();
let s: Vec<u8> = std::iter::repeat(())
.map(|()| rng.sample(Alphanumeric))
easytier/src/peers/peer_session.rs
+7 -7
View File
@@ -1,7 +1,7 @@
use std::{
sync::{
atomic::{AtomicBool, AtomicU32, Ordering},
Arc, Mutex, RwLock,
atomic::{AtomicBool, AtomicU32, Ordering},
},
time::{SystemTime, UNIX_EPOCH},
};
@@ -10,7 +10,7 @@ use atomic_shim::AtomicU64;
use crate::{
common::PeerId,
peers::encrypt::{create_encryptor, Encryptor},
peers::encrypt::{Encryptor, create_encryptor},
tunnel::packet_def::{StandardAeadTail, ZCPacket},
};
use anyhow::anyhow;
@@ -189,11 +189,11 @@ impl PeerSessionStore {
PeerSessionAction::Sync | PeerSessionAction::Create => {
let root_key = root_key_32.ok_or_else(|| anyhow!("missing root_key"))?;
// If the existing session is invalidated, remove it so we create a fresh one
if let Some(existing) = self.sessions.get(key) {
if !existing.is_valid() {
drop(existing);
self.sessions.remove(key);
}
if let Some(existing) = self.sessions.get(key)
&& !existing.is_valid()
{
drop(existing);
self.sessions.remove(key);
}
let session = self
.sessions
easytier/src/peers/peer_task.rs
+1 -1
View File
@@ -1,6 +1,6 @@
use std::{
result::Result,
sync::{atomic::Ordering, Arc, Mutex},
sync::{Arc, Mutex, atomic::Ordering},
};
use atomic_shim::AtomicU64;
easytier/src/peers/relay_peer_map.rs
+10 -10
View File
@@ -3,13 +3,13 @@ use std::{sync::Arc, time::Instant};
use dashmap::DashMap;
use prost::Message;
use snow::params::NoiseParams;
use tokio::sync::{oneshot, Mutex, OwnedMutexGuard};
use tokio::time::{timeout, Duration};
use tokio::sync::{Mutex, OwnedMutexGuard, oneshot};
use tokio::time::{Duration, timeout};
use crate::peers::foreign_network_client::ForeignNetworkClient;
use crate::{
common::error::Error,
common::{global_ctx::ArcGlobalCtx, PeerId},
common::{PeerId, global_ctx::ArcGlobalCtx},
peers::peer_map::PeerMap,
peers::peer_session::{PeerSession, PeerSessionAction, PeerSessionStore, SessionKey},
peers::route_trait::NextHopPolicy,
@@ -274,13 +274,13 @@ impl RelayPeerMap {
return Ok(());
}
if let Some(next_retry_at) = self.states.get(&dst_peer_id).and_then(|v| v.next_retry_at) {
if Instant::now() < next_retry_at {
self.pending_packets.remove(&dst_peer_id);
return Err(Error::RouteError(Some(
"relay handshake backoff".to_string(),
)));
}
if let Some(next_retry_at) = self.states.get(&dst_peer_id).and_then(|v| v.next_retry_at)
&& Instant::now() < next_retry_at
{
self.pending_packets.remove(&dst_peer_id);
return Err(Error::RouteError(Some(
"relay handshake backoff".to_string(),
)));
}
let mut last_err = None;
easytier/src/peers/route_trait.rs
+1 -1
View File
@@ -6,7 +6,7 @@ use std::{
use dashmap::DashMap;
use crate::{
common::{global_ctx::NetworkIdentity, PeerId},
common::{PeerId, global_ctx::NetworkIdentity},
proto::peer_rpc::{
ForeignNetworkRouteInfoEntry, ForeignNetworkRouteInfoKey, PeerIdentityType,
RouteForeignNetworkInfos, RouteForeignNetworkSummary, RoutePeerInfo,
easytier/src/peers/tests.rs
+23 -17
View File
@@ -5,13 +5,13 @@ use base64::Engine as _;
use crate::{
common::{
PeerId,
error::Error,
global_ctx::{
tests::{get_mock_global_ctx, get_mock_global_ctx_with_network},
NetworkIdentity,
tests::{get_mock_global_ctx, get_mock_global_ctx_with_network},
},
stats_manager::{LabelSet, LabelType, MetricName},
PeerId,
},
proto::api::instance::TrustedKeySourcePb,
tunnel::{
@@ -324,12 +324,14 @@ async fn private_mode_rejects_foreign_network_with_different_secret() {
);
let _ = client_ret;
wait_for_public_peers_empty(client).await;
assert!(server
.get_foreign_network_manager()
.list_foreign_networks()
.await
.foreign_networks
.is_empty());
assert!(
server
.get_foreign_network_manager()
.list_foreign_networks()
.await
.foreign_networks
.is_empty()
);
}
#[tokio::test]
@@ -968,8 +970,8 @@ pub async fn create_mock_peer_manager_credential(
) -> Arc<PeerManager> {
use crate::common::config::NetworkIdentity;
use crate::proto::common::SecureModeConfig;
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
use base64::Engine;
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
let (s, _r) = create_packet_recv_chan();
let g = get_mock_global_ctx_with_network(Some(NetworkIdentity::new_credential(network_name)));
@@ -1127,10 +1129,12 @@ async fn credential_revocation_removes_from_routes() {
.await;
// Now revoke the credential
assert!(admin_a
.get_global_ctx()
.get_credential_manager()
.revoke_credential(&cred_id));
assert!(
admin_a
.get_global_ctx()
.get_credential_manager()
.revoke_credential(&cred_id)
);
// Issue event to trigger OSPF sync
admin_a
.get_global_ctx()
@@ -1416,10 +1420,12 @@ async fn multi_admin_multi_credential_route_and_revocation_isolation() {
)
.await;
assert!(admin_a
.get_global_ctx()
.get_credential_manager()
.revoke_credential(&cred1_id));
assert!(
admin_a
.get_global_ctx()
.get_credential_manager()
.revoke_credential(&cred1_id)
);
admin_a
.get_global_ctx()
.issue_event(crate::common::global_ctx::GlobalCtxEvent::CredentialChanged);
easytier/src/peers/traffic_metrics.rs
+22 -19
View File
@@ -4,9 +4,8 @@ use dashmap::DashMap;
use futures::future::BoxFuture;
use crate::common::{
shrink_dashmap,
PeerId, shrink_dashmap,
stats_manager::{CounterHandle, LabelSet, LabelType, MetricName, StatsManager},
PeerId,
};
use crate::proto::peer_rpc::RoutePeerInfo;
use crate::tunnel::packet_def::PacketType;
@@ -147,11 +146,11 @@ impl LogicalTrafficMetrics {
{
self.total.add_sample(bytes);
if let Some(entry) = self.per_peer.get(&peer_id) {
if entry.value().is_resolved() {
entry.value().counters().add_sample(bytes);
return;
}
if let Some(entry) = self.per_peer.get(&peer_id)
&& entry.value().is_resolved()
{
entry.value().counters().add_sample(bytes);
return;
}
let resolved_instance_id = resolver().await;
@@ -388,18 +387,22 @@ mod tests {
.value,
300
);
assert!(stats_mgr
.get_metric(
MetricName::TrafficBytesTx,
&to_instance_labels("default", UNKNOWN_INSTANCE_ID),
)
.is_none());
assert!(stats_mgr
.get_metric(
MetricName::TrafficBytesTx,
&to_instance_labels("default", resolved_instance_id),
)
.is_none());
assert!(
stats_mgr
.get_metric(
MetricName::TrafficBytesTx,
&to_instance_labels("default", UNKNOWN_INSTANCE_ID),
)
.is_none()
);
assert!(
stats_mgr
.get_metric(
MetricName::TrafficBytesTx,
&to_instance_labels("default", resolved_instance_id),
)
.is_none()
);
assert_eq!(
stats_mgr
.get_metric(