[ci skip] debugging

veilid-core/src/routing_table/node_ref/filtered_node_ref.rs

@@ -119,6 +119,24 @@ impl NodeRefOperateTrait for FilteredNodeRef {
         let inner = &mut *routing_table.inner.write();
         self.entry.with_mut(inner, f)
     }
+
+    fn with_inner<T, F>(&self, f: F) -> T
+    where
+        F: FnOnce(&RoutingTableInner) -> T,
+    {
+        let routing_table = self.registry.routing_table();
+        let inner = &*routing_table.inner.read();
+        f(inner)
+    }
+
+    fn with_inner_mut<T, F>(&self, f: F) -> T
+    where
+        F: FnOnce(&mut RoutingTableInner) -> T,
+    {
+        let routing_table = self.registry.routing_table();
+        let inner = &mut *routing_table.inner.write();
+        f(inner)
+    }
 }
 
 impl NodeRefCommonTrait for FilteredNodeRef {}

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

@@ -139,6 +139,24 @@ impl NodeRefOperateTrait for NodeRef {
         let inner = &mut *routing_table.inner.write();
         self.entry.with_mut(inner, f)
     }
+
+    fn with_inner<T, F>(&self, f: F) -> T
+    where
+        F: FnOnce(&RoutingTableInner) -> T,
+    {
+        let routing_table = self.routing_table();
+        let inner = &*routing_table.inner.read();
+        f(inner)
+    }
+
+    fn with_inner_mut<T, F>(&self, f: F) -> T
+    where
+        F: FnOnce(&mut RoutingTableInner) -> T,
+    {
+        let routing_table = self.routing_table();
+        let inner = &mut *routing_table.inner.write();
+        f(inner)
+    }
 }
 
 impl NodeRefCommonTrait for NodeRef {}

veilid-core/src/routing_table/node_ref/node_ref_lock.rs

@@ -90,6 +90,21 @@ impl<'a, N: NodeRefAccessorsTrait + NodeRefOperateTrait + fmt::Debug + fmt::Disp
     {
         panic!("need to locked_mut() for this operation")
     }
+
+    fn with_inner<T, F>(&self, f: F) -> T
+    where
+        F: FnOnce(&RoutingTableInner) -> T,
+    {
+        let inner = &*self.inner.lock();
+        f(inner)
+    }
+
+    fn with_inner_mut<T, F>(&self, _f: F) -> T
+    where
+        F: FnOnce(&mut RoutingTableInner) -> T,
+    {
+        panic!("need to locked_mut() for this operation")
+    }
 }
 
 impl<'a, N: NodeRefAccessorsTrait + NodeRefOperateTrait + fmt::Debug + fmt::Display + Clone>

veilid-core/src/routing_table/node_ref/node_ref_lock_mut.rs

@@ -92,6 +92,22 @@ impl<'a, N: NodeRefAccessorsTrait + NodeRefOperateTrait + fmt::Debug + fmt::Disp
         let inner = &mut *self.inner.lock();
         self.nr.entry().with_mut(inner, f)
     }
+
+    fn with_inner<T, F>(&self, f: F) -> T
+    where
+        F: FnOnce(&RoutingTableInner) -> T,
+    {
+        let inner = &*self.inner.lock();
+        f(inner)
+    }
+
+    fn with_inner_mut<T, F>(&self, f: F) -> T
+    where
+        F: FnOnce(&mut RoutingTableInner) -> T,
+    {
+        let inner = &mut *self.inner.lock();
+        f(inner)
+    }
 }
 
 impl<'a, N: NodeRefAccessorsTrait + NodeRefOperateTrait + fmt::Debug + fmt::Display + Clone>

veilid-core/src/routing_table/node_ref/traits.rs

@@ -20,6 +20,13 @@ pub(crate) trait NodeRefOperateTrait {
     fn operate_mut<T, F>(&self, f: F) -> T
     where
         F: FnOnce(&mut RoutingTableInner, &mut BucketEntryInner) -> T;
+    #[expect(dead_code)]
+    fn with_inner<T, F>(&self, f: F) -> T
+    where
+        F: FnOnce(&RoutingTableInner) -> T;
+    fn with_inner_mut<T, F>(&self, f: F) -> T
+    where
+        F: FnOnce(&mut RoutingTableInner) -> T;
 }
 
 // Common Operations
@@ -115,7 +122,7 @@ pub(crate) trait NodeRefCommonTrait: NodeRefAccessorsTrait + NodeRefOperateTrait
     // }
 
     fn relay(&self, routing_domain: RoutingDomain) -> EyreResult<Option<FilteredNodeRef>> {
-        self.operate_mut(|rti, e| {
+        let Some(rpi) = self.operate(|rti, e| {
             let Some(sni) = e.signed_node_info(routing_domain) else {
                 return Ok(None);
             };
@@ -127,8 +134,14 @@ pub(crate) trait NodeRefCommonTrait: NodeRefAccessorsTrait + NodeRefOperateTrait
             if rti.routing_table().matches_own_node_id(rpi.node_ids()) {
                 bail!("Can't relay though ourselves");
             }
+            Ok(Some(rpi))
+        })?
+        else {
+            return Ok(None);
+        };
 
-            // Register relay node and return noderef
+        // Register relay node and return noderef
+        self.with_inner_mut(|rti| {
             let nr = rti.register_node_with_peer_info(rpi, false)?;
             Ok(Some(nr))
         })