Merge branch 'resolve-fix' of gitlab.com:veilid/veilid into resolve-fix

veilid-cli/Cargo.toml

@@ -54,7 +54,7 @@ flexi_logger = { version = "^0", features = ["use_chrono_for_offset"] }
 thiserror = "^1"
 crossbeam-channel = "^0"
 hex = "^0"
-veilid-tools = { version = "0.2.0", path = "../veilid-tools" }
+veilid-tools = { version = "0.2.1", path = "../veilid-tools" }
 
 json = "^0"
 stop-token = { version = "^0", default-features = false }

veilid-core/Cargo.toml

@@ -59,7 +59,7 @@ network-result-extra = ["veilid-tools/network-result-extra"]
 [dependencies]
 
 # Tools
-veilid-tools = { version = "0.2.0", path = "../veilid-tools", features = [
+veilid-tools = { version = "0.2.1", path = "../veilid-tools", features = [
     "tracing",
 ], default-features = false }
 paste = "1.0.14"
@@ -182,7 +182,7 @@ socket2 = { version = "0.5.3", features = ["all"] }
 # Dependencies for WASM builds only
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 
-veilid-tools = { version = "0.2.0", path = "../veilid-tools", default-features = false, features = [
+veilid-tools = { version = "0.2.1", path = "../veilid-tools", default-features = false, features = [
     "rt-wasm-bindgen",
 ] }
 

veilid-core/build.rs

@@ -1,15 +1,27 @@
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
 
-fn get_workspace_dir() -> PathBuf {
-    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-        .join("..")
-        .canonicalize()
-        .expect("want workspace dir")
+fn search_file<T: AsRef<str>, P: AsRef<str>>(start: T, name: P) -> Option<PathBuf> {
+    let start_path = PathBuf::from(start.as_ref()).canonicalize().ok();
+    let mut path = start_path.as_ref().map(|x| x.as_path());
+    while let Some(some_path) = path {
+        let file_path = some_path.join(name.as_ref());
+        if file_path.exists() {
+            return Some(file_path.to_owned());
         }
+        path = some_path.parent();
+    }
+    None
+}
+
 fn get_desired_capnp_version_string() -> String {
-    std::fs::read_to_string(get_workspace_dir().join(".capnp_version"))
-        .expect("should find .capnp_version file")
+    let capnp_path = search_file(env!("CARGO_MANIFEST_DIR"), ".capnp_version")
+        .expect("should find .capnp_version file");
+    std::fs::read_to_string(&capnp_path)
+        .expect(&format!(
+            "can't read .capnp_version file here: {:?}",
+            capnp_path
+        ))
         .trim()
         .to_owned()
 }
@@ -32,8 +44,13 @@ fn get_capnp_version_string() -> String {
 }
 
 fn get_desired_protoc_version_string() -> String {
-    std::fs::read_to_string(get_workspace_dir().join(".protoc_version"))
-        .expect("should find .protoc_version file")
+    let protoc_path = search_file(env!("CARGO_MANIFEST_DIR"), ".protoc_version")
+        .expect("should find .protoc_version file");
+    std::fs::read_to_string(&protoc_path)
+        .expect(&format!(
+            "can't read .protoc_version file here: {:?}",
+            protoc_path
+        ))
         .trim()
         .to_owned()
 }

veilid-core/src/routing_table/bucket_entry.rs

@@ -649,9 +649,10 @@ impl BucketEntryInner {
             return false;
         }
 
-        // if we have seen the node consistently for longer that UNRELIABLE_PING_SPAN_SECS
         match self.peer_stats.rpc_stats.first_consecutive_seen_ts {
+            // If we have not seen seen a node consecutively, it can't be reliable
             None => false,
+            // If we have seen the node consistently for longer than UNRELIABLE_PING_SPAN_SECS then it is reliable
             Some(ts) => {
                 cur_ts.saturating_sub(ts) >= TimestampDuration::new(UNRELIABLE_PING_SPAN_SECS as u64 * 1000000u64)
             }
@@ -662,11 +663,13 @@ impl BucketEntryInner {
         if self.peer_stats.rpc_stats.failed_to_send >= NEVER_REACHED_PING_COUNT {
             return true;
         }
-        // if we have not heard from the node at all for the duration of the unreliable ping span
+
+        match self.peer_stats.rpc_stats.last_seen_ts {
             // a node is not dead if we haven't heard from it yet,
             // but we give it NEVER_REACHED_PING_COUNT chances to ping before we say it's dead
-        match self.peer_stats.rpc_stats.last_seen_ts {
-            None => self.peer_stats.rpc_stats.recent_lost_answers < NEVER_REACHED_PING_COUNT,
+            None => self.peer_stats.rpc_stats.recent_lost_answers >= NEVER_REACHED_PING_COUNT,
+            
+            // return dead if we have not heard from the node at all for the duration of the unreliable ping span
             Some(ts) => {
                 cur_ts.saturating_sub(ts) >= TimestampDuration::new(UNRELIABLE_PING_SPAN_SECS as u64 * 1000000u64)
             }

veilid-core/src/rpc_processor/mod.rs

@@ -453,7 +453,7 @@ impl RPCProcessor {
 
     //////////////////////////////////////////////////////////////////////
 
-    /// Search the DHT for a single node closest to a key and add it to the routing table and return the node reference
+    /// Search the DHT for a single node and add it to the routing table and return the node reference
     /// If no node was found in the timeout, this returns None
     async fn search_dht_single_key(
         &self,
@@ -491,14 +491,20 @@ impl RPCProcessor {
         };
 
         // Routine to call to check if we're done at each step
-        let check_done = |closest_nodes: &[NodeRef]| {
-            // If the node we want to locate is one of the closest nodes, return it immediately
-            if let Some(out) = closest_nodes
-                .iter()
-                .find(|x| x.node_ids().contains(&node_id))
-            {
-                return Some(out.clone());
+        let check_done = |_:&[NodeRef]| {
+            let Ok(Some(nr)) = routing_table
+                .lookup_node_ref(node_id) else {
+                    return None;
+                };
+        
+            // ensure we have some dial info for the entry already,
+            // and that the node is still alive
+            // if not, we should keep looking for better info
+            if !matches!(nr.state(get_aligned_timestamp()),BucketEntryState::Dead) &&
+                nr.has_any_dial_info() {
+                return Some(nr);
             }
+    
             None
         };
 
@@ -534,8 +540,10 @@ impl RPCProcessor {
                 .map_err(RPCError::internal)?
             {
                 // ensure we have some dial info for the entry already,
+                // and that the node is still alive
                 // if not, we should do the find_node anyway
-                if nr.has_any_dial_info() {
+                if !matches!(nr.state(get_aligned_timestamp()),BucketEntryState::Dead) &&
+                    nr.has_any_dial_info() {
                     return Ok(Some(nr));
                 }
             }

veilid-core/src/veilid_api/debug.rs

@@ -871,6 +871,47 @@ impl VeilidAPI {
         Ok(format!("{:#?}", cm))
     }
 
+    async fn debug_resolve(&self, args: String) -> VeilidAPIResult<String> {
+        let netman = self.network_manager()?;
+        let routing_table = netman.routing_table();
+
+        let args: Vec<String> = args.split_whitespace().map(|s| s.to_owned()).collect();
+
+        let dest = async_get_debug_argument_at(
+            &args,
+            0,
+            "debug_resolve",
+            "destination",
+            get_destination(routing_table.clone()),
+        )
+        .await?;
+
+        match &dest {
+            Destination::Direct {
+                target,
+                safety_selection: _,
+            } => Ok(format!(
+                "Destination: {:#?}\nTarget Entry:\n{}\n",
+                &dest,
+                routing_table.debug_info_entry(target.clone())
+            )),
+            Destination::Relay {
+                relay,
+                target,
+                safety_selection: _,
+            } => Ok(format!(
+                "Destination: {:#?}\nTarget Entry:\n{}\nRelay Entry:\n{}\n",
+                &dest,
+                routing_table.clone().debug_info_entry(target.clone()),
+                routing_table.debug_info_entry(relay.clone())
+            )),
+            Destination::PrivateRoute {
+                private_route: _,
+                safety_selection: _,
+            } => Ok(format!("Destination: {:#?}", &dest)),
+        }
+    }
+
     async fn debug_ping(&self, args: String) -> VeilidAPIResult<String> {
         let netman = self.network_manager()?;
         let routing_table = netman.routing_table();

veilid-wasm/Cargo.toml

@@ -15,7 +15,7 @@ default = ["veilid-core/default-wasm"]
 crypto-test = ["veilid-core/crypto-test"]
 
 [dependencies]
-veilid-core = { version = "0.2.0", path = "../veilid-core", default-features = false }
+veilid-core = { version = "0.2.1", path = "../veilid-core", default-features = false }
 
 tracing = { version = "^0", features = ["log", "attributes"] }
 tracing-wasm = "^0"