From 9c2a7488f17d543975d9b0911b6c107b9abd2e34 Mon Sep 17 00:00:00 2001 From: John Smith Date: Thu, 10 Nov 2022 21:53:45 -0500 Subject: [PATCH] bug fixes --- veilid-core/src/crypto/envelope.rs | 8 +- veilid-core/src/crypto/key.rs | 2 +- veilid-core/src/intf/table_db.rs | 3 +- veilid-core/src/network_manager/mod.rs | 36 ++--- .../native/network_class_discovery.rs | 4 +- veilid-core/src/network_manager/tasks.rs | 14 +- veilid-core/src/routing_table/bucket_entry.rs | 30 +++-- veilid-core/src/routing_table/debug.rs | 12 +- veilid-core/src/routing_table/mod.rs | 6 +- .../src/routing_table/route_spec_store.rs | 55 ++++---- veilid-core/src/rpc_processor/mod.rs | 14 +- veilid-core/src/veilid_api/mod.rs | 123 ++++++++---------- .../src/veilid_api/serialize_helpers.rs | 5 +- 13 files changed, 166 insertions(+), 146 deletions(-) diff --git a/veilid-core/src/crypto/envelope.rs b/veilid-core/src/crypto/envelope.rs index 3a3c75e4..03cb0cf1 100644 --- a/veilid-core/src/crypto/envelope.rs +++ b/veilid-core/src/crypto/envelope.rs @@ -4,6 +4,7 @@ use super::*; use crate::xx::*; use crate::*; use core::convert::TryInto; +use crate::routing_table::VersionRange; // #[repr(C, packed)] // struct EnvelopeHeader { @@ -271,8 +272,11 @@ impl Envelope { self.version } - pub fn get_min_max_version(&self) -> (u8, u8) { - (self.min_version, self.max_version) + pub fn get_min_max_version(&self) -> VersionRange { + VersionRange { + min: self.min_version, + max: self.max_version, + } } pub fn get_timestamp(&self) -> u64 { diff --git a/veilid-core/src/crypto/key.rs b/veilid-core/src/crypto/key.rs index 79ae26e5..ad484a65 100644 --- a/veilid-core/src/crypto/key.rs +++ b/veilid-core/src/crypto/key.rs @@ -39,7 +39,7 @@ pub const DHT_SIGNATURE_LENGTH_ENCODED: usize = 86; macro_rules! byte_array_type { ($name:ident, $size:expr) => { #[derive(Clone, Copy, RkyvArchive, RkyvSerialize, RkyvDeserialize)] - #[archive_attr(repr(C), derive(CheckBytes))] + #[archive_attr(repr(C), derive(CheckBytes, Hash, Eq, PartialEq, PartialOrd, Ord))] pub struct $name { pub bytes: [u8; $size], pub valid: bool, diff --git a/veilid-core/src/intf/table_db.rs b/veilid-core/src/intf/table_db.rs index ddf6cf72..6064d051 100644 --- a/veilid-core/src/intf/table_db.rs +++ b/veilid-core/src/intf/table_db.rs @@ -1,6 +1,5 @@ use crate::xx::*; use crate::*; -use serde::{Deserialize, Serialize}; cfg_if! { if #[cfg(target_arch = "wasm32")] { @@ -223,7 +222,7 @@ impl<'a> TableDBTransaction<'a> { /// Store a key in rkyv format with a value in a column in the TableDB pub fn store_json(&mut self, col: u32, key: &[u8], value: &T) -> EyreResult<()> where - T: Serialize, + T: serde::Serialize, { let v = serde_json::to_vec(value)?; self.dbt.as_mut().unwrap().put(col, key, v.as_slice()); diff --git a/veilid-core/src/network_manager/mod.rs b/veilid-core/src/network_manager/mod.rs index 37ec14ef..6c87aaf1 100644 --- a/veilid-core/src/network_manager/mod.rs +++ b/veilid-core/src/network_manager/mod.rs @@ -646,15 +646,16 @@ impl NetworkManager { /// Get our node's capabilities in the PublicInternet routing domain fn generate_public_internet_node_status(&self) -> PublicInternetNodeStatus { - let node_info = self + let own_peer_info = self .routing_table() - .get_own_node_info(RoutingDomain::PublicInternet); + .get_own_peer_info(RoutingDomain::PublicInternet); + let own_node_info = own_peer_info.signed_node_info.node_info(); - let will_route = node_info.can_inbound_relay(); // xxx: eventually this may have more criteria added - let will_tunnel = node_info.can_inbound_relay(); // xxx: we may want to restrict by battery life and network bandwidth at some point - let will_signal = node_info.can_signal(); - let will_relay = node_info.can_inbound_relay(); - let will_validate_dial_info = node_info.can_validate_dial_info(); + let will_route = own_node_info.can_inbound_relay(); // xxx: eventually this may have more criteria added + let will_tunnel = own_node_info.can_inbound_relay(); // xxx: we may want to restrict by battery life and network bandwidth at some point + let will_signal = own_node_info.can_signal(); + let will_relay = own_node_info.can_inbound_relay(); + let will_validate_dial_info = own_node_info.can_validate_dial_info(); PublicInternetNodeStatus { will_route, @@ -666,12 +667,14 @@ impl NetworkManager { } /// Get our node's capabilities in the LocalNetwork routing domain fn generate_local_network_node_status(&self) -> LocalNetworkNodeStatus { - let node_info = self + let own_peer_info = self .routing_table() - .get_own_node_info(RoutingDomain::LocalNetwork); + .get_own_peer_info(RoutingDomain::LocalNetwork); - let will_relay = node_info.can_inbound_relay(); - let will_validate_dial_info = node_info.can_validate_dial_info(); + let own_node_info = own_peer_info.signed_node_info.node_info(); + + let will_relay = own_node_info.can_inbound_relay(); + let will_validate_dial_info = own_node_info.can_validate_dial_info(); LocalNetworkNodeStatus { will_relay, @@ -960,17 +963,18 @@ impl NetworkManager { } // Get node's min/max version and see if we can send to it // and if so, get the max version we can use - let version = if let Some((node_min, node_max)) = node_ref.min_max_version() { + let version = if let Some(min_max_version) = node_ref.min_max_version() { #[allow(clippy::absurd_extreme_comparisons)] - if node_min > MAX_CRYPTO_VERSION || node_max < MIN_CRYPTO_VERSION { + if min_max_version.min > MAX_CRYPTO_VERSION || min_max_version.max < MIN_CRYPTO_VERSION + { bail!( "can't talk to this node {} because version is unsupported: ({},{})", via_node_id, - node_min, - node_max + min_max_version.min, + min_max_version.max ); } - cmp::min(node_max, MAX_CRYPTO_VERSION) + cmp::min(min_max_version.max, MAX_CRYPTO_VERSION) } else { MAX_CRYPTO_VERSION }; diff --git a/veilid-core/src/network_manager/native/network_class_discovery.rs b/veilid-core/src/network_manager/native/network_class_discovery.rs index 2b8b8aca..7a2daa08 100644 --- a/veilid-core/src/network_manager/native/network_class_discovery.rs +++ b/veilid-core/src/network_manager/native/network_class_discovery.rs @@ -129,8 +129,8 @@ impl DiscoveryContext { move |rti: &RoutingTableInner, _k: DHTKey, v: Option>| { let v = v.unwrap(); v.with(rti, |_rti, e| { - if let Some(n) = e.node_info(RoutingDomain::PublicInternet) { - n.relay_peer_info.is_none() + if let Some(n) = e.signed_node_info(RoutingDomain::PublicInternet) { + n.relay_id().is_none() } else { false } diff --git a/veilid-core/src/network_manager/tasks.rs b/veilid-core/src/network_manager/tasks.rs index 07554099..6ec80996 100644 --- a/veilid-core/src/network_manager/tasks.rs +++ b/veilid-core/src/network_manager/tasks.rs @@ -295,15 +295,14 @@ impl NetworkManager { if let Some(nr) = routing_table.register_node_with_signed_node_info( RoutingDomain::PublicInternet, k, - SignedDirectNodeInfo::with_no_signature(NodeInfo { + SignedNodeInfo::Direct(SignedDirectNodeInfo::with_no_signature(NodeInfo { network_class: NetworkClass::InboundCapable, // Bootstraps are always inbound capable outbound_protocols: ProtocolTypeSet::only(ProtocolType::UDP), // Bootstraps do not participate in relaying and will not make outbound requests, but will have UDP enabled address_types: AddressTypeSet::all(), // Bootstraps are always IPV4 and IPV6 capable min_version: v.min_version, // Minimum crypto version specified in txt record max_version: v.max_version, // Maximum crypto version specified in txt record dial_info_detail_list: v.dial_info_details, // Dial info is as specified in the bootstrap list - relay_peer_info: None, // Bootstraps never require a relay themselves - }), + })), true, ) { // Add this our futures to process in parallel @@ -524,7 +523,8 @@ impl NetworkManager { ) -> EyreResult<()> { // Get our node's current node info and network class and do the right thing let routing_table = self.routing_table(); - let node_info = routing_table.get_own_node_info(RoutingDomain::PublicInternet); + let own_peer_info = routing_table.get_own_peer_info(RoutingDomain::PublicInternet); + let own_node_info = own_peer_info.signed_node_info.node_info(); let network_class = routing_table.get_network_class(RoutingDomain::PublicInternet); // Get routing domain editor @@ -541,7 +541,7 @@ impl NetworkManager { info!("Relay node died, dropping relay {}", relay_node); editor.clear_relay_node(); false - } else if !node_info.requires_relay() { + } else if !own_node_info.requires_relay() { info!( "Relay node no longer required, dropping relay {}", relay_node @@ -557,7 +557,7 @@ impl NetworkManager { }; // Do we need a relay? - if !has_relay && node_info.requires_relay() { + if !has_relay && own_node_info.requires_relay() { // Do we want an outbound relay? let mut got_outbound_relay = false; if network_class.outbound_wants_relay() { @@ -604,7 +604,7 @@ impl NetworkManager { ) -> EyreResult<()> { // Get our node's current node info and network class and do the right thing let routing_table = self.routing_table(); - let node_info = routing_table.get_own_node_info(RoutingDomain::PublicInternet); + let own_peer_info = routing_table.get_own_peer_info(RoutingDomain::PublicInternet); let network_class = routing_table.get_network_class(RoutingDomain::PublicInternet); // Get routing domain editor diff --git a/veilid-core/src/routing_table/bucket_entry.rs b/veilid-core/src/routing_table/bucket_entry.rs index fdecd02e..11032215 100644 --- a/veilid-core/src/routing_table/bucket_entry.rs +++ b/veilid-core/src/routing_table/bucket_entry.rs @@ -1,6 +1,6 @@ use super::*; use core::sync::atomic::{AtomicU32, Ordering}; -use serde::{Deserialize, Serialize}; +use rkyv::with::Skip; /// Reliable pings are done with increased spacing between pings @@ -40,10 +40,11 @@ pub enum BucketEntryState { } #[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)] -struct LastConnectionKey(ProtocolType, AddressType); +pub struct LastConnectionKey(ProtocolType, AddressType); /// Bucket entry information specific to the LocalNetwork RoutingDomain -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, RkyvArchive, RkyvSerialize, RkyvDeserialize)] +#[archive_attr(repr(C), derive(CheckBytes))] pub struct BucketEntryPublicInternet { /// The PublicInternet node info signed_node_info: Option>, @@ -54,7 +55,8 @@ pub struct BucketEntryPublicInternet { } /// Bucket entry information specific to the LocalNetwork RoutingDomain -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, RkyvArchive, RkyvSerialize, RkyvDeserialize)] +#[archive_attr(repr(C), derive(CheckBytes))] pub struct BucketEntryLocalNetwork { /// The LocalNetwork node info signed_node_info: Option>, @@ -65,16 +67,18 @@ pub struct BucketEntryLocalNetwork { } /// A range of cryptography versions supported by this entry -#[derive(Debug, Serialize, Deserialize)] +#[derive(Copy, Clone, Debug, RkyvArchive, RkyvSerialize, RkyvDeserialize)] +#[archive_attr(repr(C), derive(CheckBytes))] pub struct VersionRange { /// The minimum cryptography version supported by this entry - min: u8, + pub min: u8, /// The maximum cryptography version supported by this entry - max: u8, + pub max: u8, } /// The data associated with each bucket entry -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, RkyvArchive, RkyvSerialize, RkyvDeserialize)] +#[archive_attr(repr(C), derive(CheckBytes))] pub struct BucketEntryInner { /// The minimum and maximum range of cryptography versions supported by the node, /// inclusive of the requirements of any relay the node may be using @@ -83,7 +87,7 @@ pub struct BucketEntryInner { /// and dial info has last changed, for example when our IP address changes updated_since_last_network_change: bool, /// The last connection descriptors used to contact this node, per protocol type - #[serde(skip)] + #[with(Skip)] last_connections: BTreeMap, /// The node info for this entry on the publicinternet routing domain public_internet: BucketEntryPublicInternet, @@ -92,18 +96,18 @@ pub struct BucketEntryInner { /// Statistics gathered for the peer peer_stats: PeerStats, /// The accounting for the latency statistics - #[serde(skip)] + #[with(Skip)] latency_stats_accounting: LatencyStatsAccounting, /// The accounting for the transfer statistics - #[serde(skip)] + #[with(Skip)] transfer_stats_accounting: TransferStatsAccounting, /// Tracking identifier for NodeRef debugging #[cfg(feature = "tracking")] - #[serde(skip)] + #[with(Skip)] next_track_id: usize, /// Backtraces for NodeRef debugging #[cfg(feature = "tracking")] - #[serde(skip)] + #[with(Skip)] node_ref_tracks: HashMap, } diff --git a/veilid-core/src/routing_table/debug.rs b/veilid-core/src/routing_table/debug.rs index 43af8b78..3170fae6 100644 --- a/veilid-core/src/routing_table/debug.rs +++ b/veilid-core/src/routing_table/debug.rs @@ -1,7 +1,7 @@ use super::*; impl RoutingTable { - pub fn debug_info_nodeinfo(&self) -> String { + pub(crate) fn debug_info_nodeinfo(&self) -> String { let mut out = String::new(); let inner = self.inner.read(); out += "Routing Table Info:\n"; @@ -23,7 +23,7 @@ impl RoutingTable { out } - pub async fn debug_info_txtrecord(&self) -> String { + pub(crate) async fn debug_info_txtrecord(&self) -> String { let mut out = String::new(); let gdis = self.dial_info_details(RoutingDomain::PublicInternet); @@ -71,7 +71,7 @@ impl RoutingTable { out } - pub fn debug_info_dialinfo(&self) -> String { + pub(crate) fn debug_info_dialinfo(&self) -> String { let ldis = self.dial_info_details(RoutingDomain::LocalNetwork); let gdis = self.dial_info_details(RoutingDomain::PublicInternet); let mut out = String::new(); @@ -100,7 +100,7 @@ impl RoutingTable { out } - pub fn debug_info_entries(&self, limit: usize, min_state: BucketEntryState) -> String { + pub(crate) fn debug_info_entries(&self, limit: usize, min_state: BucketEntryState) -> String { let inner = self.inner.read(); let inner = &*inner; let cur_ts = intf::get_timestamp(); @@ -148,7 +148,7 @@ impl RoutingTable { out } - pub fn debug_info_entry(&self, node_id: DHTKey) -> String { + pub(crate) fn debug_info_entry(&self, node_id: DHTKey) -> String { let mut out = String::new(); out += &format!("Entry {:?}:\n", node_id); if let Some(nr) = self.lookup_node_ref(node_id) { @@ -160,7 +160,7 @@ impl RoutingTable { out } - pub fn debug_info_buckets(&self, min_state: BucketEntryState) -> String { + pub(crate) fn debug_info_buckets(&self, min_state: BucketEntryState) -> String { let inner = self.inner.read(); let inner = &*inner; let cur_ts = intf::get_timestamp(); diff --git a/veilid-core/src/routing_table/mod.rs b/veilid-core/src/routing_table/mod.rs index 6f585960..0fcb7304 100644 --- a/veilid-core/src/routing_table/mod.rs +++ b/veilid-core/src/routing_table/mod.rs @@ -239,7 +239,7 @@ impl RoutingTable { let tdb = table_store.open("routing_table", 1).await?; let bucket_count = bucketvec.len(); let mut dbx = tdb.transact(); - if let Err(e) = dbx.store_frozen(0, b"bucket_count", &bucket_count) { + if let Err(e) = dbx.store_rkyv(0, b"bucket_count", &bucket_count) { dbx.rollback(); return Err(e); } @@ -845,8 +845,8 @@ impl RoutingTable { } // node can not be its own relay - if let Some(rpi) = &p.signed_node_info.node_info.relay_peer_info { - if rpi.node_id == p.node_id { + if let Some(rid) = &p.signed_node_info.relay_id() { + if rid.key == p.node_id.key { continue; } } diff --git a/veilid-core/src/routing_table/route_spec_store.rs b/veilid-core/src/routing_table/route_spec_store.rs index a03c0614..e1230214 100644 --- a/veilid-core/src/routing_table/route_spec_store.rs +++ b/veilid-core/src/routing_table/route_spec_store.rs @@ -1,6 +1,6 @@ use super::*; use crate::veilid_api::*; -use serde::*; +use rkyv::with::Skip; /// Compiled route (safety route + private route) #[derive(Clone, Debug)] @@ -13,32 +13,40 @@ pub struct CompiledRoute { pub first_hop: NodeRef, } -#[derive(Clone, Debug, Serialize, Deserialize)] -struct RouteSpecDetail { +#[derive(Clone, Debug, RkyvArchive, RkyvSerialize, RkyvDeserialize)] +#[archive_attr(repr(C), derive(CheckBytes))] +pub struct KeyPair { + key: DHTKey, + secret: DHTKeySecret, +} + +#[derive(Clone, Debug, RkyvArchive, RkyvSerialize, RkyvDeserialize)] +#[archive_attr(repr(C), derive(CheckBytes))] +pub struct RouteSpecDetail { /// Secret key - #[serde(skip)] + #[with(Skip)] pub secret_key: DHTKeySecret, /// Route hops pub hops: Vec, /// Route noderefs - #[serde(skip)] + #[with(Skip)] hop_node_refs: Vec, /// Transfers up and down transfer_stats_down_up: TransferStatsDownUp, /// Latency stats latency_stats: LatencyStats, /// Accounting mechanism for this route's RPC latency - #[serde(skip)] + #[with(Skip)] latency_stats_accounting: LatencyStatsAccounting, /// Accounting mechanism for the bandwidth across this route - #[serde(skip)] + #[with(Skip)] transfer_stats_accounting: TransferStatsAccounting, /// Published private route, do not reuse for ephemeral routes /// Not serialized because all routes should be re-published when restarting - #[serde(skip)] + #[with(Skip)] published: bool, // Can optimize the rendering of this route, using node ids only instead of full peer info - #[serde(skip)] + #[with(Skip)] reachable: bool, /// Timestamp of when the route was created created_ts: u64, @@ -47,6 +55,7 @@ struct RouteSpecDetail { /// Timestamp of when the route was last used for anything last_used_ts: Option, /// Directions this route is guaranteed to work in + #[with(RkyvEnumSet)] directions: DirectionSet, /// Stability preference (prefer reliable nodes over faster) pub stability: Stability, @@ -55,7 +64,8 @@ struct RouteSpecDetail { } /// The core representation of the RouteSpecStore that can be serialized -#[derive(Debug, Clone, Default, Serialize, Deserialize)] +#[derive(Debug, Clone, Default, RkyvArchive, RkyvSerialize, RkyvDeserialize)] +#[archive_attr(repr(C), derive(CheckBytes))] pub struct RouteSpecStoreContent { /// All of the routes we have allocated so far details: HashMap, @@ -225,7 +235,7 @@ impl RouteSpecStore { let table_store = routing_table.network_manager().table_store(); let rsstdb = table_store.open("RouteSpecStore", 1).await?; let mut content: RouteSpecStoreContent = - rsstdb.load_json(0, b"content")?.unwrap_or_default(); + rsstdb.load_rkyv(0, b"content")?.unwrap_or_default(); // Look up all route hop noderefs since we can't serialize those let mut dead_keys = Vec::new(); @@ -245,17 +255,17 @@ impl RouteSpecStore { // Load secrets from pstore let pstore = routing_table.network_manager().protected_store(); - let out: Vec<(DHTKey, DHTKeySecret)> = pstore + let out: Vec = pstore .load_user_secret_rkyv("RouteSpecStore") .await? .unwrap_or_default(); let mut dead_keys = Vec::new(); - for (k, v) in out { - if let Some(rsd) = content.details.get_mut(&k) { - rsd.secret_key = v; + for KeyPair { key, secret } in out { + if let Some(rsd) = content.details.get_mut(&key) { + rsd.secret_key = secret; } else { - dead_keys.push(k); + dead_keys.push(key); } } for k in dead_keys { @@ -296,7 +306,7 @@ impl RouteSpecStore { .network_manager() .table_store(); let rsstdb = table_store.open("RouteSpecStore", 1).await?; - rsstdb.store_json(0, b"content", &content)?; + rsstdb.store_rkyv(0, b"content", &content)?; // // Keep secrets in protected store as well let pstore = self @@ -305,14 +315,15 @@ impl RouteSpecStore { .network_manager() .protected_store(); - let mut out: Vec<(DHTKey, DHTKeySecret)> = Vec::with_capacity(content.details.len()); + let mut out: Vec = Vec::with_capacity(content.details.len()); for (k, v) in &content.details { - out.push((*k, v.secret_key)); + out.push(KeyPair { + key: *k, + secret: v.secret_key, + }); } - let _ = pstore - .save_user_secret_frozen("RouteSpecStore", &out) - .await?; // ignore if this previously existed or not + let _ = pstore.save_user_secret_rkyv("RouteSpecStore", &out).await?; // ignore if this previously existed or not Ok(()) } diff --git a/veilid-core/src/rpc_processor/mod.rs b/veilid-core/src/rpc_processor/mod.rs index 8b3ccc6a..d74527a4 100644 --- a/veilid-core/src/rpc_processor/mod.rs +++ b/veilid-core/src/rpc_processor/mod.rs @@ -648,7 +648,11 @@ impl RPCProcessor { if target.has_seen_our_node_info(RoutingDomain::PublicInternet) { return None; } - Some(routing_table.get_own_signed_node_info(RoutingDomain::PublicInternet)) + Some( + routing_table + .get_own_peer_info(RoutingDomain::PublicInternet) + .signed_node_info, + ) } Destination::Relay { relay: _, @@ -659,7 +663,11 @@ impl RPCProcessor { if target.has_seen_our_node_info(RoutingDomain::PublicInternet) { return None; } - Some(routing_table.get_own_signed_node_info(RoutingDomain::PublicInternet)) + Some( + routing_table + .get_own_peer_info(RoutingDomain::PublicInternet) + .signed_node_info, + ) } else { None } @@ -929,7 +937,7 @@ impl RPCProcessor { let mut opt_sender_nr: Option = None; if let Some(sender_node_info) = operation.sender_node_info() { // Sender NodeInfo was specified, update our routing table with it - if !self.filter_node_info(routing_domain, &sender_node_info.node_info) { + if !self.filter_node_info(routing_domain, &sender_node_info) { return Err(RPCError::invalid_format( "sender signednodeinfo has invalid peer scope", )); diff --git a/veilid-core/src/veilid_api/mod.rs b/veilid-core/src/veilid_api/mod.rs index caa0435c..93fb47ce 100644 --- a/veilid-core/src/veilid_api/mod.rs +++ b/veilid-core/src/veilid_api/mod.rs @@ -832,9 +832,58 @@ impl NodeInfo { dial_info_detail_list } - pub fn has_direct_dial_info(&self) -> bool { + /// Does this node has some dial info + pub fn has_dial_info(&self) -> bool { !self.dial_info_detail_list.is_empty() } + + /// Is some relay required either for signal or inbound relay or outbound relay? + pub fn requires_relay(&self) -> bool { + match self.network_class { + NetworkClass::InboundCapable => { + for did in &self.dial_info_detail_list { + if did.class.requires_relay() { + return true; + } + } + } + NetworkClass::OutboundOnly => { + return true; + } + NetworkClass::WebApp => { + return true; + } + NetworkClass::Invalid => {} + } + false + } + + /// Can this node assist with signalling? Yes but only if it doesn't require signalling, itself. + pub fn can_signal(&self) -> bool { + // Must be inbound capable + if !matches!(self.network_class, NetworkClass::InboundCapable) { + return false; + } + // Do any of our dial info require signalling? if so, we can't offer signalling + for did in &self.dial_info_detail_list { + if did.class.requires_signal() { + return false; + } + } + true + } + + /// Can this node relay be an inbound relay? + pub fn can_inbound_relay(&self) -> bool { + // For now this is the same + self.can_signal() + } + + /// Is this node capable of validating dial info + pub fn can_validate_dial_info(&self) -> bool { + // For now this is the same + self.can_signal() + } } #[allow(clippy::derive_hash_xor_eq)] @@ -2079,7 +2128,7 @@ impl SignedNodeInfo { pub fn has_valid_signature(&self) -> bool { match self { SignedNodeInfo::Direct(d) => d.has_valid_signature(), - SignedNodeInfo::Relayed(r) => true, + SignedNodeInfo::Relayed(_) => true, } } @@ -2098,19 +2147,19 @@ impl SignedNodeInfo { } pub fn relay_id(&self) -> Option { match self { - SignedNodeInfo::Direct(d) => None, + SignedNodeInfo::Direct(_) => None, SignedNodeInfo::Relayed(r) => Some(r.relay_id.clone()), } } pub fn relay_info(&self) -> Option<&NodeInfo> { match self { - SignedNodeInfo::Direct(d) => None, + SignedNodeInfo::Direct(_) => None, SignedNodeInfo::Relayed(r) => Some(&r.relay_info.node_info), } } pub fn relay_peer_info(&self) -> Option { match self { - SignedNodeInfo::Direct(d) => None, + SignedNodeInfo::Direct(_) => None, SignedNodeInfo::Relayed(r) => Some(PeerInfo::new( r.relay_id.clone(), SignedNodeInfo::Direct(r.relay_info.clone()), @@ -2118,10 +2167,10 @@ impl SignedNodeInfo { } } pub fn has_any_dial_info(&self) -> bool { - self.node_info().has_direct_dial_info() + self.node_info().has_dial_info() || self .relay_info() - .map(|relay_ni| relay_ni.has_direct_dial_info()) + .map(|relay_ni| relay_ni.has_dial_info()) .unwrap_or_default() } @@ -2173,66 +2222,6 @@ impl PeerInfo { } } -impl PeerInfo { - /* - - xxx move these back to NodeInfo - - pub fn has_direct_dial_info(&self) -> bool { - !self.dial_info_detail_list.is_empty() - } - - // Is some relay required either for signal or inbound relay or outbound relay? - pub fn requires_relay(&self) -> bool { - match self.network_class { - NetworkClass::InboundCapable => { - for did in &self.dial_info_detail_list { - if did.class.requires_relay() { - return true; - } - } - } - NetworkClass::OutboundOnly => { - return true; - } - NetworkClass::WebApp => { - return true; - } - NetworkClass::Invalid => {} - } - false - } - - // Can this node assist with signalling? Yes but only if it doesn't require signalling, itself. - pub fn can_signal(&self) -> bool { - // Must be inbound capable - if !matches!(self.network_class, NetworkClass::InboundCapable) { - return false; - } - // Do any of our dial info require signalling? if so, we can't offer signalling - for did in &self.dial_info_detail_list { - if did.class.requires_signal() { - return false; - } - } - true - } - - // Can this node relay be an inbound relay? - pub fn can_inbound_relay(&self) -> bool { - // For now this is the same - self.can_signal() - } - - // Is this node capable of validating dial info - pub fn can_validate_dial_info(&self) -> bool { - // For now this is the same - self.can_signal() - } - - */ -} - #[derive( Copy, Clone, diff --git a/veilid-core/src/veilid_api/serialize_helpers.rs b/veilid-core/src/veilid_api/serialize_helpers.rs index bb8fb045..74e990f9 100644 --- a/veilid-core/src/veilid_api/serialize_helpers.rs +++ b/veilid-core/src/veilid_api/serialize_helpers.rs @@ -199,12 +199,13 @@ where D: rkyv::Fallible + ?Sized, T: EnumSetType + EnumSetTypeWithRepr, ::Repr: rkyv::Archive, - rkyv::Archived<::Repr>: rkyv::Deserialize, D>, + rkyv::Archived<::Repr>: + rkyv::Deserialize<::Repr, D>, { fn deserialize_with( field: &rkyv::Archived<::Repr>, deserializer: &mut D, ) -> Result, D::Error> { - Ok(field.deserialize(deserializer)?.into()) + Ok(EnumSet::::from_repr(field.deserialize(deserializer)?)) } }