node: add server election

peer_mgr

server: add peer_mgr

peer_mgr

easytier/src/dns/node.rs

@@ -1,28 +1,30 @@
 use crate::common::global_ctx::GlobalCtxEvent;
 use crate::common::PeerId;
-use crate::dns::config::DNS_SERVER_RPC_ADDR;
+use crate::dns::config::{DNS_SERVER_ELECTION_INTERVAL, DNS_SERVER_RPC_ADDR};
 use crate::dns::peer_mgr::DnsPeerMgr;
+use crate::dns::server::DnsServer;
 use crate::peers::peer_manager::PeerManager;
+use crate::peers::NicPacketFilter;
 use crate::proto::dns::{DnsNodeMgrRpcClientFactory, DnsPeerMgrRpcServer, HeartbeatRequest};
-use crate::proto::rpc_impl::standalone::StandAloneClient;
+use crate::proto::rpc_impl::standalone::{StandAloneClient, StandAloneServer};
 use crate::proto::rpc_types::controller::BaseController;
-use crate::tunnel::tcp::TcpTunnelConnector;
+use crate::tunnel::tcp::{TcpTunnelConnector, TcpTunnelListener};
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::{broadcast, Notify};
 use tokio::task::JoinSet;
-use tokio::time::{sleep_until, Instant};
+use tokio::time::{sleep, sleep_until, Instant};
 use uuid::Uuid;
 
 #[derive(Debug)]
 pub struct DnsNode {
     mgr: Arc<DnsPeerMgr>,
 
-    election: Arc<Notify>,
+    peer_mgr: Arc<PeerManager>,
 }
 
 impl DnsNode {
-    pub fn new(peer_mgr: Arc<PeerManager>, election: Arc<Notify>) -> Self {
+    pub fn new(peer_mgr: Arc<PeerManager>) -> Self {
         let mgr = Arc::new(DnsPeerMgr::new(peer_mgr.clone()));
         peer_mgr
             .get_peer_rpc_mgr()
@@ -33,17 +35,55 @@ impl DnsNode {
                 &peer_mgr.get_global_ctx_ref().get_network_name(),
             );
 
-        Self {
-            mgr,
-            election,
-        }
+        Self { mgr, peer_mgr }
     }
 
     pub fn id(&self) -> Uuid {
-        self.mgr.get_global_ctx_ref().get_id()
+        self.peer_mgr.get_global_ctx_ref().get_id()
     }
 
     pub async fn run(&self) {
+        let election = Notify::new();
+
+        tokio::join!(self.run_election(&election), self.run_node(&election));
+    }
+
+    async fn run_election(&self, election: &Notify) {
+        loop {
+            tokio::select! {
+                biased;
+                _ = election.notified() => {}
+                _ = sleep(DNS_SERVER_ELECTION_INTERVAL) => {}
+            }
+
+            let mut rpc =
+                StandAloneServer::new(TcpTunnelListener::new(DNS_SERVER_RPC_ADDR.clone()));
+
+            if rpc.serve().await.is_err() {
+                // Another instance already owns the address — that's fine.
+                continue;
+            }
+
+            tracing::info!("won DNS server election, starting DnsServer");
+
+            let server = Arc::new(DnsServer::new(self.peer_mgr.clone(), rpc));
+
+            self.peer_mgr
+                .add_nic_packet_process_pipeline(Box::new(server.clone()))
+                .await;
+
+            server.run().await;
+
+            let _ = self
+                .peer_mgr
+                .remove_nic_packet_process_pipeline(server.id())
+                .await;
+
+            tracing::warn!("DnsServer exited, will retry election");
+        }
+    }
+
+    async fn run_node(&self, election: &Notify) {
         let mut rpc = StandAloneClient::new(TcpTunnelConnector::new(DNS_SERVER_RPC_ADDR.clone()));
         let mut heartbeat = HeartbeatRequest {
             id: Some(self.id().into()),
@@ -55,7 +95,7 @@ impl DnsNode {
         let sleep = sleep_until(last_heartbeat);
         tokio::pin!(sleep);
 
-        let mut subscriber = self.mgr.get_global_ctx_ref().subscribe();
+        let mut subscriber = self.peer_mgr.get_global_ctx_ref().subscribe();
         let mut tasks = JoinSet::new();
 
         loop {
@@ -73,7 +113,7 @@ impl DnsNode {
                 _ = &mut sleep => {
                     if let Err(e) = self.heartbeat(&mut rpc, &mut heartbeat).await {
                         tracing::error!("heartbeat failed: {:?}", e);
-                        self.election.notify_one();
+                        election.notify_one();
                     }
 
                     last_heartbeat = Instant::now();
@@ -143,13 +183,13 @@ impl DnsNode {
     }
 
     fn refresh(&self, tasks: &mut JoinSet<()>, peer_ids: Vec<PeerId>) {
-        let my_peer_id = self.mgr.my_peer_id();
+        let my_peer_id = self.peer_mgr.my_peer_id();
         for peer_id in peer_ids {
             if peer_id == my_peer_id {
                 continue;
             }
             let mgr = self.mgr.clone();
-            let route = mgr.get_route();
+            let route = self.peer_mgr.get_route();
             tasks.spawn(async move {
                 if let Some(peer_info) = route.get_peer_info(peer_id).await {
                     mgr.refresh(peer_id, peer_info.dns).await;