refactor checkpoint

veilid-core/src/veilid_api/debug.rs

@@ -304,25 +304,41 @@ impl VeilidAPI {
             None => return Ok("Node id not found in routing table".to_owned()),
         };
 
-        if args.len() >= 2 {
-            let pt = get_debug_argument_at(
+        let mut ai = 1;
+        let mut routing_domain = None;
+        while ai < args.len() {
+            if let Ok(pt) = get_debug_argument_at(
                 &args,
-                1,
+                ai,
                 "debug_contact",
                 "protocol_type",
                 get_protocol_type,
-            )?;
-            nr.merge_filter(DialInfoFilter::all().with_protocol_type(pt));
-            if args.len() >= 3 {
-                let at = get_debug_argument_at(
-                    &args,
-                    2,
-                    "debug_contact",
-                    "address_type",
-                    get_address_type,
-                )?;
-                nr.merge_filter(DialInfoFilter::all().with_address_type(at));
+            ) {
+                nr.merge_filter(NodeRefFilter::new().with_protocol_type(pt));
+            } else if let Ok(at) =
+                get_debug_argument_at(&args, ai, "debug_contact", "address_type", get_address_type)
+            {
+                nr.merge_filter(NodeRefFilter::new().with_address_type(at));
+            } else if let Ok(rd) = get_debug_argument_at(
+                &args,
+                ai,
+                "debug_contact",
+                "routing_domain",
+                get_routing_domain,
+            ) {
+                if routing_domain.is_none() {
+                    routing_domain = Some(rd);
+                } else {
+                    return Ok("Multiple routing domains specified".to_owned());
+                }
+            } else {
+                return Ok(format!("Invalid argument specified: {}", args[ai]));
             }
+            ai += 1;
+        }
+
+        if let Some(routing_domain) = routing_domain {
+            nr.merge_filter(NodeRefFilter::new().with_routing_domain(routing_domain))
         }
 
         let cm = network_manager.get_contact_method(nr);
@@ -331,11 +347,14 @@ impl VeilidAPI {
     }
 
     async fn debug_ping(&self, args: String) -> Result<String, VeilidAPIError> {
+        let netman = self.network_manager()?;
+        let routing_table = netman.routing_table();
+        let rpc = netman.rpc_processor();
+
         let args: Vec<String> = args.split_whitespace().map(|s| s.to_owned()).collect();
 
         let node_id = get_debug_argument_at(&args, 0, "debug_ping", "node_id", get_dht_key)?;
 
-        let routing_table = self.network_manager()?.routing_table();
         let mut nr = match routing_table.lookup_node_ref(node_id) {
             Some(nr) => nr,
             None => return Ok("Node id not found in routing table".to_owned()),
@@ -347,11 +366,11 @@ impl VeilidAPI {
             if let Ok(pt) =
                 get_debug_argument_at(&args, ai, "debug_ping", "protocol_type", get_protocol_type)
             {
-                nr.merge_filter(DialInfoFilter::all().with_protocol_type(pt));
+                nr.merge_filter(NodeRefFilter::new().with_protocol_type(pt));
             } else if let Ok(at) =
                 get_debug_argument_at(&args, ai, "debug_ping", "address_type", get_address_type)
             {
-                nr.merge_filter(DialInfoFilter::all().with_address_type(at));
+                nr.merge_filter(NodeRefFilter::new().with_address_type(at));
             } else if let Ok(rd) = get_debug_argument_at(
                 &args,
                 ai,
@@ -370,11 +389,13 @@ impl VeilidAPI {
             ai += 1;
         }
 
-        let rpc = self.network_manager()?.rpc_processor();
+        if let Some(routing_domain) = routing_domain {
+            nr.merge_filter(NodeRefFilter::new().with_routing_domain(routing_domain))
+        }
 
         // Dump routing table entry
         let out = match rpc
-            .rpc_call_status(routing_domain, nr)
+            .rpc_call_status(nr)
             .await
             .map_err(VeilidAPIError::internal)?
         {

veilid-core/src/veilid_api/mod.rs

@@ -460,31 +460,6 @@ pub struct NodeInfo {
 }
 
 impl NodeInfo {
-    pub fn is_valid_in_routing_domain(
-        &self,
-        routing_table: RoutingTable,
-        routing_domain: RoutingDomain,
-    ) -> bool {
-        // Should not be passing around nodeinfo with an invalid network class
-        if matches!(self.network_class, NetworkClass::Invalid) {
-            return false;
-        }
-        // Ensure all of the dial info works in this routing domain
-        for did in self.dial_info_detail_list {
-            if !routing_table.ensure_dial_info_is_valid(routing_domain, &did.dial_info) {
-                return false;
-            }
-        }
-        // Ensure the relay is also valid in this routing domain if it is provided
-        if let Some(relay_peer_info) = self.relay_peer_info {
-            let relay_ni = &relay_peer_info.signed_node_info.node_info;
-            if !relay_ni.is_valid_in_routing_domain(routing_table, routing_domain) {
-                return false;
-            }
-        }
-        true
-    }
-
     pub fn first_filtered_dial_info_detail<F>(&self, filter: F) -> Option<DialInfoDetail>
     where
         F: Fn(&DialInfoDetail) -> bool,
@@ -805,7 +780,7 @@ impl FromStr for SocketAddress {
 
 //////////////////////////////////////////////////////////////////
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct DialInfoFilter {
     pub protocol_type_set: ProtocolTypeSet,
     pub address_type_set: AddressTypeSet,
@@ -1449,8 +1424,8 @@ impl SignedNodeInfo {
         }
     }
 
-    pub fn is_valid(&self) -> bool {
-        self.signature.valid && self.node_info.is_valid()
+    pub fn has_valid_signature(&self) -> bool {
+        self.signature.valid
     }
 }