liz/veilid
1
0
Fork 0
Code Pull Requests Packages Releases Activity

refactor checkpoint

Browse Source
This commit is contained in:
John Smith
2022-10-09 14:59:01 -04:00
parent 1fdcd5ae45
commit 338dc6b39d
24 changed files with 1122 additions and 564 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
veilid-core/src/rpc_processor/destination.rs
View File

@@ -7,8 +7,8 @@ pub enum Destination {
Direct {
/// The node to send to
target: NodeRef,
/// An optional safety route specification to send from for sender privacy
safety_route_spec: Option<Arc<SafetyRouteSpec>>,
/// Require safety route or not
safety: bool,
},
/// Send to node for relay purposes
Relay {
@@ -16,15 +16,17 @@ pub enum Destination {
relay: NodeRef,
/// The final destination the relay should send to
target: DHTKey,
/// An optional safety route specification to send from for sender privacy
safety_route_spec: Option<Arc<SafetyRouteSpec>>,
/// Require safety route or not
safety: bool,
},
/// Send to private route (privateroute)
PrivateRoute {
/// A private route to send to
private_route: PrivateRoute,
/// An optional safety route specification to send from for sender privacy
safety_route_spec: Option<Arc<SafetyRouteSpec>>,
/// Require safety route or not
safety: bool,
/// Prefer reliability or not
reliable: bool,
},
}
@@ -32,115 +34,47 @@ impl Destination {
pub fn direct(target: NodeRef) -> Self {
Self::Direct {
target,
safety_route_spec: None,
safety: false,
}
}
pub fn relay(relay: NodeRef, target: DHTKey) -> Self {
Self::Relay {
relay,
target,
safety_route_spec: None,
safety: false,
}
}
pub fn private_route(private_route: PrivateRoute) -> Self {
pub fn private_route(private_route: PrivateRoute, reliable: bool) -> Self {
Self::PrivateRoute {
private_route,
safety_route_spec: None,
safety: false,
reliable,
}
}
// pub fn target_id(&self) -> DHTKey {
// match self {
// Destination::Direct {
// target,
// safety_route_spec,
// } => target.node_id(),
// Destination::Relay {
// relay,
// target,
// safety_route_spec,
// } => *target,
// Destination::PrivateRoute {
// private_route,
// safety_route_spec,
// } => {}
// }
// }
// pub fn best_routing_domain(&self) -> RoutingDomain {
// match self {
// Destination::Direct {
// target,
// safety_route_spec,
// } => {
// if safety_route_spec.is_some() {
// RoutingDomain::PublicInternet
// } else {
// target
// .best_routing_domain()
// .unwrap_or(RoutingDomain::PublicInternet)
// }
// }
// Destination::Relay {
// relay,
// target,
// safety_route_spec,
// } => {
// if safety_route_spec.is_some() {
// RoutingDomain::PublicInternet
// } else {
// relay
// .best_routing_domain()
// .unwrap_or(RoutingDomain::PublicInternet)
// }
// }
// Destination::PrivateRoute {
// private_route: _,
// safety_route_spec: _,
// } => RoutingDomain::PublicInternet,
// }
// }
pub fn safety_route_spec(&self) -> Option<Arc<SafetyRouteSpec>> {
pub fn with_safety(self) -> Self {
match self {
Destination::Direct {
target: _,
safety_route_spec,
} => safety_route_spec.clone(),
Destination::Relay {
relay: _,
target: _,
safety_route_spec,
} => safety_route_spec.clone(),
Destination::PrivateRoute {
private_route: _,
safety_route_spec,
} => safety_route_spec.clone(),
}
}
pub fn with_safety_route_spec(self, safety_route_spec: Arc<SafetyRouteSpec>) -> Self {
match self {
Destination::Direct {
Destination::Direct { target, safety: _ } => Self::Direct {
target,
safety_route_spec: _,
} => Self::Direct {
target,
safety_route_spec: Some(safety_route_spec),
safety: true,
},
Destination::Relay {
relay,
target,
safety_route_spec: _,
safety: _,
} => Self::Relay {
relay,
target,
safety_route_spec: Some(safety_route_spec),
safety: true,
},
Destination::PrivateRoute {
private_route,
safety_route_spec: _,
safety: _,
reliable,
} => Self::PrivateRoute {
private_route,
safety_route_spec: Some(safety_route_spec),
safety: true,
reliable,
},
}
}
@@ -149,39 +83,29 @@ impl Destination {
impl fmt::Display for Destination {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Destination::Direct {
target,
safety_route_spec,
} => {
let sr = safety_route_spec
.as_ref()
.map(|_sr| "+SR".to_owned())
.unwrap_or_default();
Destination::Direct { target, safety } => {
let sr = if *safety { "+SR" } else { "" };
write!(f, "{:?}{}", target, sr)
write!(f, "{}{}", target, sr)
}
Destination::Relay {
relay,
target,
safety_route_spec,
safety,
} => {
let sr = safety_route_spec
.as_ref()
.map(|_sr| "+SR".to_owned())
.unwrap_or_default();
let sr = if *safety { "+SR" } else { "" };
write!(f, "{:?}@{:?}{}", target.encode(), relay, sr)
write!(f, "{}@{}{}", target.encode(), relay, sr)
}
Destination::PrivateRoute {
private_route,
safety_route_spec,
safety,
reliable,
} => {
let sr = safety_route_spec
.as_ref()
.map(|_sr| "+SR".to_owned())
.unwrap_or_default();
let sr = if *safety { "+SR" } else { "" };
let rl = if *reliable { "+RL" } else { "" };
write!(f, "{}{}", private_route, sr)
write!(f, "{}{}{}", private_route, sr, rl)
}
}
}

3
veilid-core/src/rpc_processor/mod.rs
View File

@@ -544,7 +544,8 @@ impl RPCProcessor {
}
// Don't do this if our own signed node info isn't valid yet
let routing_table = self.routing_table();
if !routing_table.has_valid_own_node_info(RoutingDomain::PublicInternet) {
let network_manager = self.network_manager();
if !RoutingTable::has_valid_own_node_info(network_manager, RoutingDomain::PublicInternet) {
return None;
}

26
veilid-core/src/rpc_processor/rpc_find_node.rs
View File

@@ -62,16 +62,34 @@ impl RPCProcessor {
// add node information for the requesting node to our routing table
let routing_table = self.routing_table();
let rt2 = routing_table.clone();
let rt3 = routing_table.clone();
let network_manager = self.network_manager();
let has_valid_own_node_info =
routing_table.has_valid_own_node_info(RoutingDomain::PublicInternet);
let own_peer_info = routing_table.get_own_peer_info(RoutingDomain::PublicInternet);
// find N nodes closest to the target node in our routing table
let closest_nodes = routing_table.find_closest_nodes(
find_node_q.node_id,
// filter
move |_k, v| rt2.filter_has_valid_signed_node_info(RoutingDomain::PublicInternet, v),
|rti, _k, v| {
RoutingTable::filter_has_valid_signed_node_info_inner(
rti,
RoutingDomain::PublicInternet,
has_valid_own_node_info,
v,
)
},
// transform
move |k, v| rt3.transform_to_peer_info(RoutingDomain::PublicInternet, k, v),
|rti, k, v| {
let own_peer_info = own_peer_info.clone();
RoutingTable::transform_to_peer_info_inner(
rti,
RoutingDomain::PublicInternet,
own_peer_info,
k,
v,
)
},
);
// Make status answer

2
veilid-core/src/rpc_processor/rpc_validate_dial_info.rs
View File

@@ -87,7 +87,7 @@ impl RPCProcessor {
routing_domain,
dial_info.clone(),
);
let will_validate_dial_info_filter = |e: &BucketEntryInner| {
let will_validate_dial_info_filter = |_rti, e: &BucketEntryInner| {
if let Some(status) = &e.node_status(routing_domain) {
status.will_validate_dial_info()
} else {