client: rename to node

easytier/src/dns/mod.rs

@@ -1,5 +1,5 @@
-mod client;
-mod client_mgr;
+mod node;
+mod node_mgr;
 pub mod config;
 mod peer_mgr;
 mod server;

easytier/src/dns/node.rs

@@ -1,7 +1,7 @@
 use crate::dns::config::DNS_SERVER_RPC_ADDR;
 use crate::dns::peer_mgr::DnsPeerMgr;
 use crate::peers::peer_manager::PeerManager;
-use crate::proto::dns::{DnsClientMgrRpcClientFactory, DnsPeerMgrRpcServer, HeartbeatRequest};
+use crate::proto::dns::{DnsNodeMgrRpcClientFactory, DnsPeerMgrRpcServer, HeartbeatRequest};
 use crate::proto::peer_rpc::RoutePeerInfo;
 use crate::proto::rpc_impl::standalone::StandAloneClient;
 use crate::proto::rpc_types::controller::BaseController;
@@ -12,13 +12,13 @@ use tokio::task::JoinSet;
 use uuid::Uuid;
 
 #[derive(Debug)]
-pub struct DnsClient {
+pub struct DnsNode {
     mgr: Arc<DnsPeerMgr>,
 
     tasks: JoinSet<()>,
 }
 
-impl DnsClient {
+impl DnsNode {
     pub fn new(peer_mgr: Arc<PeerManager>) -> Self {
         let mgr = Arc::new(DnsPeerMgr::new(peer_mgr.clone()));
         peer_mgr
@@ -50,7 +50,7 @@ impl DnsClient {
         loop {
             self.mgr.dirty.notify.notified().await;
             if let Err(e) = self.heartbeat(&mut rpc, &mut heartbeat).await {
-                tracing::error!("DnsClient heartbeat failed: {:?}", e);
+                tracing::error!("heartbeat failed: {:?}", e);
             }
             tokio::time::sleep(Duration::from_secs(1)).await;
         }
@@ -72,7 +72,7 @@ impl DnsClient {
         };
 
         let client = rpc
-            .scoped_client::<DnsClientMgrRpcClientFactory<BaseController>>("".to_string())
+            .scoped_client::<DnsNodeMgrRpcClientFactory<BaseController>>("".to_string())
             .await?;
 
         let response = client.heartbeat(BaseController::default(), request).await?;

easytier/src/dns/node_mgr.rs

@@ -1,7 +1,7 @@
 use crate::dns::utils::addr::NameServerAddr;
 use crate::dns::utils::dirty::{DirtyFlag, DirtyState};
 use crate::dns::zone::{Zone, ZoneGroup};
-use crate::proto::dns::DnsClientMgrRpc;
+use crate::proto::dns::DnsNodeMgrRpc;
 use crate::proto::dns::{DnsSnapshot, HeartbeatRequest, HeartbeatResponse};
 use crate::proto::rpc_types;
 use crate::proto::rpc_types::controller::BaseController;
@@ -15,14 +15,14 @@ use std::time::Duration;
 use uuid::Uuid;
 
 #[derive(Debug, Clone, Default)]
-pub struct DnsClientInfo {
+pub struct DnsNodeInfo {
     digest: Vec<u8>,
     zones: ZoneGroup,
     addresses: HashSet<NameServerAddr>,
     listeners: HashSet<NameServerAddr>,
 }
 
-impl TryFrom<&DnsSnapshot> for DnsClientInfo {
+impl TryFrom<&DnsSnapshot> for DnsNodeInfo {
     type Error = Error;
 
     fn try_from(value: &DnsSnapshot) -> Result<Self, Self::Error> {
@@ -38,22 +38,22 @@ impl TryFrom<&DnsSnapshot> for DnsClientInfo {
 const DNS_CLIENT_TTL: Duration = Duration::from_secs(5);
 
 #[derive(Debug, Default)]
-pub struct DnsClientMgrDirtyFlags {
+pub struct DnsNodeMgrDirtyFlags {
     pub(super) catalog: DirtyFlag,
     pub(super) addresses: DirtyFlag,
     pub(super) listeners: DirtyFlag,
 }
 
 #[derive(Debug)]
-pub struct DnsClientMgr {
-    clients: Cache<Uuid, DnsClientInfo>,
-    pub(super) dirty: DirtyState<DnsClientMgrDirtyFlags>,
+pub struct DnsNodeMgr {
+    nodes: Cache<Uuid, DnsNodeInfo>,
+    pub(super) dirty: DirtyState<DnsNodeMgrDirtyFlags>,
 }
 
-impl DnsClientMgr {
+impl DnsNodeMgr {
     pub fn new() -> Self {
         Self {
-            clients: Cache::builder().time_to_live(DNS_CLIENT_TTL).build(),
+            nodes: Cache::builder().time_to_live(DNS_CLIENT_TTL).build(),
             dirty: Default::default(),
         }
     }
@@ -83,7 +83,7 @@ impl DnsClientMgr {
         let mut zones = vec![Zone::system()];
         let mut local = HashSet::<NameServerAddr>::new();
 
-        for (_, info) in self.clients.iter() {
+        for (_, info) in self.nodes.iter() {
             zones.extend(info.zones);
             local.extend(info.addresses);
             local.extend(info.listeners);
@@ -101,14 +101,14 @@ impl DnsClientMgr {
     }
 
     pub fn iter_addresses(&self) -> impl Iterator<Item = NameServerAddr> + use<'_> {
-        self.clients
+        self.nodes
             .iter()
             .flat_map(|(_, info)| info.addresses)
             .unique()
     }
 
     pub fn iter_listeners(&self) -> impl Iterator<Item = NameServerAddr> + use<'_> {
-        self.clients
+        self.nodes
             .iter()
             .flat_map(|(_, info)| info.listeners)
             .unique()
@@ -116,7 +116,7 @@ impl DnsClientMgr {
 }
 
 #[async_trait::async_trait]
-impl DnsClientMgrRpc for DnsClientMgr {
+impl DnsNodeMgrRpc for DnsNodeMgr {
     type Controller = BaseController;
 
     async fn heartbeat(
@@ -133,8 +133,8 @@ impl DnsClientMgrRpc for DnsClientMgr {
             .into();
 
         let resync = if let Some(snapshot) = input.snapshot.as_ref() {
-            let new = DnsClientInfo::try_from(snapshot)?;
-            let old = self.clients.get(&id).await.unwrap_or_default();
+            let new = DnsNodeInfo::try_from(snapshot)?;
+            let old = self.nodes.get(&id).await.unwrap_or_default();
             if new.digest != old.digest {
                 self.dirty.catalog.mark();
                 if new.addresses != old.addresses {
@@ -144,12 +144,12 @@ impl DnsClientMgrRpc for DnsClientMgr {
                     self.dirty.listeners.mark();
                 }
 
-                self.clients.insert(id, new).await;
+                self.nodes.insert(id, new).await;
                 self.dirty.notify.notify_one();
             }
             false
         } else {
-            self.clients
+            self.nodes
                 .get(&id)
                 .await
                 .is_none_or(|info| info.digest != input.digest)

easytier/src/dns/server.rs

@@ -1,7 +1,7 @@
-use crate::dns::client_mgr::DnsClientMgr;
+use crate::dns::node_mgr::DnsNodeMgr;
 use crate::dns::utils::addr::NameServerAddr;
 use crate::peers::peer_manager::PeerManager;
-use crate::proto::dns::DnsClientMgrRpcServer;
+use crate::proto::dns::DnsNodeMgrRpcServer;
 use derivative::Derivative;
 use derive_more::{Deref, DerefMut, From, Into};
 use hickory_proto::rr::Record;
@@ -127,7 +127,7 @@ impl ResponseHandler for Response {
 #[derive(Derivative)]
 #[derivative(Debug)]
 pub struct DnsServer {
-    mgr: Arc<DnsClientMgr>,
+    mgr: Arc<DnsNodeMgr>,
 
     #[derivative(Debug = "ignore")]
     catalog: DynamicCatalog,
@@ -140,13 +140,13 @@ const DNS_SERVER_LISTENER_TCP_TIMEOUT: Duration = Duration::from_secs(5);
 
 impl DnsServer {
     pub fn new(peer_mgr: Arc<PeerManager>) -> Self {
-        let mgr = Arc::new(DnsClientMgr::new());
+        let mgr = Arc::new(DnsNodeMgr::new());
         peer_mgr
             .get_peer_rpc_mgr()
             .rpc_server()
             .registry()
             .register(
-                DnsClientMgrRpcServer::new_arc(mgr.clone()),
+                DnsNodeMgrRpcServer::new_arc(mgr.clone()),
                 &peer_mgr.get_global_ctx_ref().get_network_name(),
             );
 

easytier/src/proto/dns.proto

@@ -38,6 +38,6 @@ message HeartbeatResponse {
   bool resync = 1;
 }
 
-service DnsClientMgrRpc {
+service DnsNodeMgrRpc {
     rpc Heartbeat(HeartbeatRequest) returns (HeartbeatResponse) {}
 }