more refactor

veilid-core/src/routing_table/tasks/bootstrap.rs

@@ -294,6 +294,9 @@ impl RoutingTable {
 
         log_rtab!(debug "--- bootstrap_task");
 
+        // Get counts by crypto kind
+        let entry_count = self.inner.read().cached_entry_counts();
+
         // See if we are specifying a direct dialinfo for bootstrap, if so use the direct mechanism
         let mut bootstrap_dialinfos = Vec::<DialInfo>::new();
         for b in &bootstrap {
@@ -341,6 +344,14 @@ impl RoutingTable {
             {
                 // Add this our futures to process in parallel
                 for crypto_kind in VALID_CRYPTO_KINDS {
+                    // Do we need to bootstrap this crypto kind?
+                    let eckey = (RoutingDomain::PublicInternet, crypto_kind);
+                    let cnt = entry_count.get(&eckey).copied().unwrap_or_default();
+                    if cnt != 0 {
+                        continue;
+                    }
+
+                    // Bootstrap this crypto kind
                     let nr = nr.clone();
                     let routing_table = self.clone();
                     unord.push(

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

@@ -134,21 +134,30 @@ impl RoutingTable {
             self.unlocked_inner.kick_buckets_task.tick().await?;
         }
 
-        // See how many live PublicInternet entries we have
-        let live_public_internet_entry_count = self.get_entry_count(
-            RoutingDomain::PublicInternet.into(),
-            BucketEntryState::Unreliable,
-        );
+        // Refresh entry counts
+        let entry_counts = {
+            let mut inner = self.inner.write();
+            inner.refresh_cached_entry_counts()
+        };
+
         let min_peer_count = self.with_config(|c| c.network.dht.min_peer_count as usize);
 
-        // If none, then add the bootstrap nodes to it
-        if live_public_internet_entry_count == 0 {
+        // Figure out which tables need bootstrap or peer minimum refresh
+        let mut needs_bootstrap = false;
+        let mut needs_peer_minimum_refresh = false;
+        for ck in VALID_CRYPTO_KINDS {
+            let eckey = (RoutingDomain::PublicInternet, ck);
+            let cnt = entry_counts.get(&eckey).copied().unwrap_or_default();
+            if cnt == 0 {
+                needs_bootstrap = true;
+            } else if cnt < min_peer_count {
+                needs_peer_minimum_refresh = true;
+            }
+        }
+        if needs_bootstrap {
             self.unlocked_inner.bootstrap_task.tick().await?;
         }
-        // If we still don't have enough peers, find nodes until we do
-        else if !self.unlocked_inner.bootstrap_task.is_running()
-            && live_public_internet_entry_count < min_peer_count
-        {
+        if needs_peer_minimum_refresh {
             self.unlocked_inner.peer_minimum_refresh_task.tick().await?;
         }
 

veilid-core/src/routing_table/tasks/peer_minimum_refresh.rs

@@ -16,6 +16,9 @@ impl RoutingTable {
         self,
         stop_token: StopToken,
     ) -> EyreResult<()> {
+        // Get counts by crypto kind
+        let entry_count = self.inner.read().cached_entry_counts();
+
         let min_peer_count = self.with_config(|c| c.network.dht.min_peer_count as usize);
 
         // For the PublicInternet routing domain, get list of all peers we know about
@@ -24,11 +27,21 @@ impl RoutingTable {
         let mut ord = FuturesOrdered::new();
 
         for crypto_kind in VALID_CRYPTO_KINDS {
+            // Do we need to peer minimum refresh this crypto kind?
+            let eckey = (RoutingDomain::PublicInternet, crypto_kind);
+            let cnt = entry_count.get(&eckey).copied().unwrap_or_default();
+            if cnt == 0 || cnt > min_peer_count {
+                // If we have enough nodes, skip it
+                // If we have zero nodes, bootstrap will get it
+                continue;
+            }
+
             let routing_table = self.clone();
 
             let mut filters = VecDeque::new();
             let filter = Box::new(
                 move |rti: &RoutingTableInner, opt_entry: Option<Arc<BucketEntry>>| {
+                    // Keep only the entries that contain the crypto kind we're looking for
                     if let Some(entry) = opt_entry {
                         entry.with_inner(|e| e.crypto_kinds().contains(&crypto_kind))
                     } else {
@@ -49,8 +62,12 @@ impl RoutingTable {
             for nr in noderefs {
                 let routing_table = self.clone();
                 ord.push_back(
-                    async move { routing_table.reverse_find_node(nr, false).await }
-                        .instrument(Span::current()),
+                    async move {
+                        routing_table
+                            .reverse_find_node(crypto_kind, nr, false)
+                            .await
+                    }
+                    .instrument(Span::current()),
                 );
             }
         }