api work

veilid-core/src/intf/native/network/network_tcp.rs

@@ -88,8 +88,8 @@ impl Network {
         let (connection_initial_timeout, tls_connection_initial_timeout) = {
             let c = self.config.get();
             (
-                c.network.connection_initial_timeout,
-                c.network.tls.connection_initial_timeout,
+                ms_to_us(c.network.connection_initial_timeout_ms),
+                ms_to_us(c.network.tls.connection_initial_timeout_ms),
             )
         };
 

veilid-core/src/intf/native/network/protocol/ws.rs

@@ -106,9 +106,9 @@ impl WebsocketProtocolHandler {
             format!("GET /{}", c.network.protocol.wss.path.trim_end_matches('/'))
         };
         let connection_initial_timeout = if tls {
-            c.network.tls.connection_initial_timeout
+            ms_to_us(c.network.tls.connection_initial_timeout_ms)
         } else {
-            c.network.connection_initial_timeout
+            ms_to_us(c.network.connection_initial_timeout_ms)
         };
 
         Self {

veilid-core/src/network_manager.rs

@@ -504,8 +504,8 @@ impl NetworkManager {
         let (tsbehind, tsahead) = {
             let c = self.config.get();
             (
-                c.network.rpc.max_timestamp_behind,
-                c.network.rpc.max_timestamp_ahead,
+                c.network.rpc.max_timestamp_behind_ms.map(ms_to_us),
+                c.network.rpc.max_timestamp_ahead_ms.map(ms_to_us),
             )
         };
 

veilid-core/src/routing_table/mod.rs

@@ -92,7 +92,7 @@ impl RoutingTable {
         RoutingTableUnlockedInner {
             rolling_transfers_task: TickTask::new(ROLLING_TRANSFERS_INTERVAL_SECS),
             bootstrap_task: TickTask::new(1),
-            peer_minimum_refresh_task: TickTask::new_us(c.network.dht.min_peer_refresh_time),
+            peer_minimum_refresh_task: TickTask::new_ms(c.network.dht.min_peer_refresh_time_ms),
             ping_validator_task: TickTask::new(1),
         }
     }

veilid-core/src/rpc_processor/mod.rs

@@ -271,7 +271,7 @@ impl RPCProcessor {
             (
                 c.network.dht.resolve_node_count,
                 c.network.dht.resolve_node_fanout,
-                c.network.dht.resolve_node_timeout,
+                c.network.dht.resolve_node_timeout_ms.map(ms_to_us),
             )
         };
 
@@ -1266,7 +1266,7 @@ impl RPCProcessor {
         // set up channel
         let mut concurrency = c.network.rpc.concurrency;
         let mut queue_size = c.network.rpc.queue_size;
-        let mut timeout = c.network.rpc.timeout;
+        let mut timeout = ms_to_us(c.network.rpc.timeout_ms);
         let mut max_route_hop_count = c.network.rpc.max_route_hop_count as usize;
         if concurrency == 0 {
             concurrency = get_concurrency() / 2;
@@ -1411,12 +1411,13 @@ impl RPCProcessor {
         alternate_port: bool,
     ) -> Result<bool, RPCError> {
         let network_manager = self.network_manager();
-        let receipt_time = self
-            .config
-            .get()
-            .network
-            .dht
-            .validate_dial_info_receipt_time;
+        let receipt_time = ms_to_us(
+            self.config
+                .get()
+                .network
+                .dht
+                .validate_dial_info_receipt_time_ms,
+        );
         //
         let (vdi_msg, eventual_value) = {
             let mut vdi_msg = ::capnp::message::Builder::new_default();

veilid-core/src/tests/common/test_veilid_config.rs

@@ -191,36 +191,36 @@ pub fn config_callback(key: String) -> ConfigCallbackReturn {
         "protected_store.insecure_fallback_directory" => Ok(Box::new(get_protected_store_path())),
         "protected_store.delete" => Ok(Box::new(false)),
         "network.max_connections" => Ok(Box::new(16u32)),
-        "network.connection_initial_timeout" => Ok(Box::new(2_000_000u64)),
+        "network.connection_initial_timeout_ms" => Ok(Box::new(2_000u32)),
         "network.node_id" => Ok(Box::new(dht::key::DHTKey::default())),
         "network.node_id_secret" => Ok(Box::new(dht::key::DHTKeySecret::default())),
         "network.bootstrap" => Ok(Box::new(vec![String::from("asdf"), String::from("qwer")])),
         "network.rpc.concurrency" => Ok(Box::new(2u32)),
         "network.rpc.queue_size" => Ok(Box::new(128u32)),
-        "network.rpc.max_timestamp_behind" => Ok(Box::new(Some(10_000_000u64))),
-        "network.rpc.max_timestamp_ahead" => Ok(Box::new(Some(10_000_000u64))),
-        "network.rpc.timeout" => Ok(Box::new(10_000_000u64)),
+        "network.rpc.max_timestamp_behind_ms" => Ok(Box::new(Some(10_000u32))),
+        "network.rpc.max_timestamp_ahead_ms" => Ok(Box::new(Some(10_000u32))),
+        "network.rpc.timeout_ms" => Ok(Box::new(10_000u32)),
         "network.rpc.max_route_hop_count" => Ok(Box::new(7u8)),
-        "network.dht.resolve_node_timeout" => Ok(Box::new(Option::<u64>::None)),
+        "network.dht.resolve_node_timeout_ms" => Ok(Box::new(Option::<u32>::None)),
         "network.dht.resolve_node_count" => Ok(Box::new(20u32)),
         "network.dht.resolve_node_fanout" => Ok(Box::new(3u32)),
         "network.dht.max_find_node_count" => Ok(Box::new(20u32)),
-        "network.dht.get_value_timeout" => Ok(Box::new(Option::<u64>::None)),
+        "network.dht.get_value_timeout_ms" => Ok(Box::new(Option::<u32>::None)),
         "network.dht.get_value_count" => Ok(Box::new(20u32)),
         "network.dht.get_value_fanout" => Ok(Box::new(3u32)),
-        "network.dht.set_value_timeout" => Ok(Box::new(Option::<u64>::None)),
+        "network.dht.set_value_timeout_ms" => Ok(Box::new(Option::<u32>::None)),
         "network.dht.set_value_count" => Ok(Box::new(20u32)),
         "network.dht.set_value_fanout" => Ok(Box::new(5u32)),
         "network.dht.min_peer_count" => Ok(Box::new(20u32)),
-        "network.dht.min_peer_refresh_time" => Ok(Box::new(2000000u64)),
-        "network.dht.validate_dial_info_receipt_time" => Ok(Box::new(5000000u64)),
+        "network.dht.min_peer_refresh_time_ms" => Ok(Box::new(2_000u32)),
+        "network.dht.validate_dial_info_receipt_time_ms" => Ok(Box::new(5_000u32)),
         "network.upnp" => Ok(Box::new(false)),
         "network.natpmp" => Ok(Box::new(false)),
         "network.enable_local_peer_scope" => Ok(Box::new(false)),
         "network.restricted_nat_retries" => Ok(Box::new(3u32)),
         "network.tls.certificate_path" => Ok(Box::new(get_certfile_path())),
         "network.tls.private_key_path" => Ok(Box::new(get_keyfile_path())),
-        "network.tls.connection_initial_timeout" => Ok(Box::new(2_000_000u64)),
+        "network.tls.connection_initial_timeout_ms" => Ok(Box::new(2_000u32)),
         "network.application.https.enabled" => Ok(Box::new(false)),
         "network.application.https.listen_address" => Ok(Box::new(String::from("[::1]:5150"))),
         "network.application.https.path" => Ok(Box::new(String::from("app"))),
@@ -294,7 +294,7 @@ pub async fn test_config() {
     );
     assert_eq!(inner.protected_store.delete, false);
     assert_eq!(inner.network.max_connections, 16);
-    assert_eq!(inner.network.connection_initial_timeout, 2_000_000u64);
+    assert_eq!(inner.network.connection_initial_timeout_ms, 2_000u32);
     assert!(!inner.network.node_id.valid);
     assert!(!inner.network.node_id_secret.valid);
     assert_eq!(
@@ -303,22 +303,25 @@ pub async fn test_config() {
     );
     assert_eq!(inner.network.rpc.concurrency, 2u32);
     assert_eq!(inner.network.rpc.queue_size, 128u32);
-    assert_eq!(inner.network.rpc.timeout, 10_000_000u64);
+    assert_eq!(inner.network.rpc.timeout_ms, 10_000u32);
     assert_eq!(inner.network.rpc.max_route_hop_count, 7u8);
-    assert_eq!(inner.network.dht.resolve_node_timeout, Option::<u64>::None);
+    assert_eq!(
+        inner.network.dht.resolve_node_timeout_ms,
+        Option::<u32>::None
+    );
     assert_eq!(inner.network.dht.resolve_node_count, 20u32);
     assert_eq!(inner.network.dht.resolve_node_fanout, 3u32);
-    assert_eq!(inner.network.dht.get_value_timeout, Option::<u64>::None);
+    assert_eq!(inner.network.dht.get_value_timeout_ms, Option::<u32>::None);
     assert_eq!(inner.network.dht.get_value_count, 20u32);
     assert_eq!(inner.network.dht.get_value_fanout, 3u32);
-    assert_eq!(inner.network.dht.set_value_timeout, Option::<u64>::None);
+    assert_eq!(inner.network.dht.set_value_timeout_ms, Option::<u32>::None);
     assert_eq!(inner.network.dht.set_value_count, 20u32);
     assert_eq!(inner.network.dht.set_value_fanout, 5u32);
     assert_eq!(inner.network.dht.min_peer_count, 20u32);
-    assert_eq!(inner.network.dht.min_peer_refresh_time, 2000000u64);
+    assert_eq!(inner.network.dht.min_peer_refresh_time_ms, 2_000u32);
     assert_eq!(
-        inner.network.dht.validate_dial_info_receipt_time,
-        5000000u64
+        inner.network.dht.validate_dial_info_receipt_time_ms,
+        5_000u32
     );
 
     assert_eq!(inner.network.upnp, false);
@@ -327,7 +330,7 @@ pub async fn test_config() {
     assert_eq!(inner.network.restricted_nat_retries, 3u32);
     assert_eq!(inner.network.tls.certificate_path, get_certfile_path());
     assert_eq!(inner.network.tls.private_key_path, get_keyfile_path());
-    assert_eq!(inner.network.tls.connection_initial_timeout, 2_000_000u64);
+    assert_eq!(inner.network.tls.connection_initial_timeout_ms, 2_000u32);
 
     assert_eq!(inner.network.application.https.enabled, false);
     assert_eq!(inner.network.application.https.listen_address, "[::1]:5150");

veilid-core/src/veilid_api/mod.rs

@@ -1196,7 +1196,7 @@ impl VeilidAPI {
             (
                 c.network.dht.resolve_node_count,
                 c.network.dht.resolve_node_fanout,
-                c.network.dht.resolve_node_timeout,
+                c.network.dht.resolve_node_timeout_ms.map(ms_to_us),
             )
         };
 
@@ -1224,7 +1224,7 @@ impl VeilidAPI {
             (
                 c.network.dht.resolve_node_count,
                 c.network.dht.resolve_node_fanout,
-                c.network.dht.resolve_node_timeout,
+                c.network.dht.resolve_node_timeout_ms.map(ms_to_us),
             )
         };
 

veilid-core/src/veilid_config.rs

@@ -84,33 +84,33 @@ pub struct VeilidConfigProtocol {
 pub struct VeilidConfigTLS {
     pub certificate_path: String,
     pub private_key_path: String,
-    pub connection_initial_timeout: u64,
+    pub connection_initial_timeout_ms: u32,
 }
 
 #[derive(Default, Clone)]
 pub struct VeilidConfigDHT {
-    pub resolve_node_timeout: Option<u64>,
+    pub resolve_node_timeout_ms: Option<u32>,
     pub resolve_node_count: u32,
     pub resolve_node_fanout: u32,
     pub max_find_node_count: u32,
-    pub get_value_timeout: Option<u64>,
+    pub get_value_timeout_ms: Option<u32>,
     pub get_value_count: u32,
     pub get_value_fanout: u32,
-    pub set_value_timeout: Option<u64>,
+    pub set_value_timeout_ms: Option<u32>,
     pub set_value_count: u32,
     pub set_value_fanout: u32,
     pub min_peer_count: u32,
-    pub min_peer_refresh_time: u64,
-    pub validate_dial_info_receipt_time: u64,
+    pub min_peer_refresh_time_ms: u32,
+    pub validate_dial_info_receipt_time_ms: u32,
 }
 
 #[derive(Default, Clone)]
 pub struct VeilidConfigRPC {
     pub concurrency: u32,
     pub queue_size: u32,
-    pub max_timestamp_behind: Option<u64>,
-    pub max_timestamp_ahead: Option<u64>,
-    pub timeout: u64,
+    pub max_timestamp_behind_ms: Option<u32>,
+    pub max_timestamp_ahead_ms: Option<u32>,
+    pub timeout_ms: u32,
     pub max_route_hop_count: u8,
 }
 
@@ -125,7 +125,7 @@ pub struct VeilidConfigLeases {
 #[derive(Default, Clone)]
 pub struct VeilidConfigNetwork {
     pub max_connections: u32,
-    pub connection_initial_timeout: u64,
+    pub connection_initial_timeout_ms: u32,
     pub node_id: key::DHTKey,
     pub node_id_secret: key::DHTKeySecret,
     pub bootstrap: Vec<String>,
@@ -238,26 +238,26 @@ impl VeilidConfig {
             get_config!(inner.network.node_id);
             get_config!(inner.network.node_id_secret);
             get_config!(inner.network.max_connections);
-            get_config!(inner.network.connection_initial_timeout);
+            get_config!(inner.network.connection_initial_timeout_ms);
             get_config!(inner.network.bootstrap);
-            get_config!(inner.network.dht.resolve_node_timeout);
+            get_config!(inner.network.dht.resolve_node_timeout_ms);
             get_config!(inner.network.dht.resolve_node_count);
             get_config!(inner.network.dht.resolve_node_fanout);
             get_config!(inner.network.dht.max_find_node_count);
-            get_config!(inner.network.dht.get_value_timeout);
+            get_config!(inner.network.dht.get_value_timeout_ms);
             get_config!(inner.network.dht.get_value_count);
             get_config!(inner.network.dht.get_value_fanout);
-            get_config!(inner.network.dht.set_value_timeout);
+            get_config!(inner.network.dht.set_value_timeout_ms);
             get_config!(inner.network.dht.set_value_count);
             get_config!(inner.network.dht.set_value_fanout);
             get_config!(inner.network.dht.min_peer_count);
-            get_config!(inner.network.dht.min_peer_refresh_time);
-            get_config!(inner.network.dht.validate_dial_info_receipt_time);
+            get_config!(inner.network.dht.min_peer_refresh_time_ms);
+            get_config!(inner.network.dht.validate_dial_info_receipt_time_ms);
             get_config!(inner.network.rpc.concurrency);
             get_config!(inner.network.rpc.queue_size);
-            get_config!(inner.network.rpc.max_timestamp_behind);
-            get_config!(inner.network.rpc.max_timestamp_ahead);
-            get_config!(inner.network.rpc.timeout);
+            get_config!(inner.network.rpc.max_timestamp_behind_ms);
+            get_config!(inner.network.rpc.max_timestamp_ahead_ms);
+            get_config!(inner.network.rpc.timeout_ms);
             get_config!(inner.network.rpc.max_route_hop_count);
             get_config!(inner.network.upnp);
             get_config!(inner.network.natpmp);
@@ -265,7 +265,7 @@ impl VeilidConfig {
             get_config!(inner.network.restricted_nat_retries);
             get_config!(inner.network.tls.certificate_path);
             get_config!(inner.network.tls.private_key_path);
-            get_config!(inner.network.tls.connection_initial_timeout);
+            get_config!(inner.network.tls.connection_initial_timeout_ms);
             get_config!(inner.network.application.https.enabled);
             get_config!(inner.network.application.https.listen_address);
             get_config!(inner.network.application.https.path);

veilid-core/src/xx/tick_task.rs

@@ -32,6 +32,14 @@ impl TickTask {
             single_future: SingleFuture::new(),
         }
     }
+    pub fn new_ms(tick_period_ms: u32) -> Self {
+        Self {
+            last_timestamp_us: AtomicU64::new(0),
+            tick_period_us: (tick_period_ms as u64) * 1000u64,
+            routine: OnceCell::new(),
+            single_future: SingleFuture::new(),
+        }
+    }
     pub fn new(tick_period_sec: u32) -> Self {
         Self {
             last_timestamp_us: AtomicU64::new(0),

veilid-core/src/xx/tools.rs

@@ -41,6 +41,10 @@ pub fn secs_to_timestamp(secs: f64) -> u64 {
     (secs * 1000000.0f64) as u64
 }
 
+pub fn ms_to_us(ms: u32) -> u64 {
+    (ms as u64) * 1000u64
+}
+
 // Calculate retry attempt with logarhythmic falloff
 pub fn retry_falloff_log(
     last_us: u64,