refactor

veilid-core/src/network_manager/tasks/mod.rs

@@ -0,0 +1,82 @@
+pub mod public_address_check;
+pub mod rolling_transfers;
+
+use super::*;
+
+impl NetworkManager {
+    pub(crate) fn start_tasks(&self) {
+        // Set rolling transfers tick task
+        {
+            let this = self.clone();
+            self.unlocked_inner
+                .rolling_transfers_task
+                .set_routine(move |s, l, t| {
+                    Box::pin(
+                        this.clone()
+                            .rolling_transfers_task_routine(s, l, t)
+                            .instrument(trace_span!(
+                                parent: None,
+                                "NetworkManager rolling transfers task routine"
+                            )),
+                    )
+                });
+        }
+
+        // Set public address check task
+        {
+            let this = self.clone();
+            self.unlocked_inner
+                .public_address_check_task
+                .set_routine(move |s, l, t| {
+                    Box::pin(
+                        this.clone()
+                            .public_address_check_task_routine(s, l, t)
+                            .instrument(trace_span!(
+                                parent: None,
+                                "public address check task routine"
+                            )),
+                    )
+                });
+        }
+    }
+
+    pub async fn tick(&self) -> EyreResult<()> {
+        let routing_table = self.routing_table();
+        let net = self.net();
+        let receipt_manager = self.receipt_manager();
+
+        // Run the rolling transfers task
+        self.unlocked_inner.rolling_transfers_task.tick().await?;
+
+        // Run the routing table tick
+        routing_table.tick().await?;
+
+        // Run the low level network tick
+        net.tick().await?;
+
+        // Run the receipt manager tick
+        receipt_manager.tick().await?;
+
+        // Purge the client whitelist
+        self.purge_client_whitelist();
+
+        Ok(())
+    }
+
+    pub(crate) async fn stop_tasks(&self) {
+        debug!("stopping rolling transfers task");
+        if let Err(e) = self.unlocked_inner.rolling_transfers_task.stop().await {
+            warn!("rolling_transfers_task not stopped: {}", e);
+        }
+        debug!("stopping node info update singlefuture");
+        if self
+            .unlocked_inner
+            .node_info_update_single_future
+            .join()
+            .await
+            .is_err()
+        {
+            error!("node_info_update_single_future not stopped");
+        }
+    }
+}

veilid-core/src/network_manager/tasks/public_address_check.rs

@@ -0,0 +1,28 @@
+use super::super::*;
+use crate::xx::*;
+
+impl NetworkManager {
+    // Clean up the public address check tables, removing entries that have timed out
+    #[instrument(level = "trace", skip(self), err)]
+    pub(crate) async fn public_address_check_task_routine(
+        self,
+        stop_token: StopToken,
+        _last_ts: u64,
+        cur_ts: u64,
+    ) -> EyreResult<()> {
+        // go through public_address_inconsistencies_table and time out things that have expired
+        let mut inner = self.inner.lock();
+        for (_, pait_v) in &mut inner.public_address_inconsistencies_table {
+            let mut expired = Vec::new();
+            for (addr, exp_ts) in pait_v.iter() {
+                if *exp_ts <= cur_ts {
+                    expired.push(*addr);
+                }
+            }
+            for exp in expired {
+                pait_v.remove(&exp);
+            }
+        }
+        Ok(())
+    }
+}

veilid-core/src/network_manager/tasks/rolling_transfers.rs

@@ -0,0 +1,52 @@
+use super::super::*;
+
+use crate::xx::*;
+
+impl NetworkManager {
+    // Compute transfer statistics for the low level network
+    #[instrument(level = "trace", skip(self), err)]
+    pub(crate) async fn rolling_transfers_task_routine(
+        self,
+        _stop_token: StopToken,
+        last_ts: u64,
+        cur_ts: u64,
+    ) -> EyreResult<()> {
+        // log_net!("--- network manager rolling_transfers task");
+        {
+            let inner = &mut *self.inner.lock();
+
+            // Roll the low level network transfer stats for our address
+            inner
+                .stats
+                .self_stats
+                .transfer_stats_accounting
+                .roll_transfers(last_ts, cur_ts, &mut inner.stats.self_stats.transfer_stats);
+
+            // Roll all per-address transfers
+            let mut dead_addrs: HashSet<PerAddressStatsKey> = HashSet::new();
+            for (addr, stats) in &mut inner.stats.per_address_stats {
+                stats.transfer_stats_accounting.roll_transfers(
+                    last_ts,
+                    cur_ts,
+                    &mut stats.transfer_stats,
+                );
+
+                // While we're here, lets see if this address has timed out
+                if cur_ts - stats.last_seen_ts >= IPADDR_MAX_INACTIVE_DURATION_US {
+                    // it's dead, put it in the dead list
+                    dead_addrs.insert(*addr);
+                }
+            }
+
+            // Remove the dead addresses from our tables
+            for da in &dead_addrs {
+                inner.stats.per_address_stats.remove(da);
+            }
+        }
+
+        // Send update
+        self.send_network_update();
+
+        Ok(())
+    }
+}