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

routing table refactor

Browse Source
This commit is contained in:
John Smith
2022-10-18 21:53:45 -04:00
parent 63768580c6
commit 6d5df71ac1
17 changed files with 1904 additions and 1586 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
veilid-core/src/rpc_processor/coders/private_safety_route.rs
View File

@@ -24,14 +24,42 @@ pub fn encode_route_hop_data(
Ok(())
}
pub fn decode_route_hop_data(
reader: &veilid_capnp::route_hop_data::Reader,
) -> Result<RouteHopData, RPCError> {
let nonce = decode_nonce(
&reader
.reborrow()
.get_nonce()
.map_err(RPCError::map_protocol("invalid nonce in route hop data"))?,
);
let blob = reader
.reborrow()
.get_blob()
.map_err(RPCError::map_protocol("invalid blob in route hop data"))?
.to_vec();
Ok(RouteHopData { nonce, blob })
}
////////////////////////////////////////////////////////////////////////////////////////////////////
pub fn encode_route_hop(
route_hop: &RouteHop,
builder: &mut veilid_capnp::route_hop::Builder,
) -> Result<(), RPCError> {
encode_node_dial_info(
&route_hop.dial_info,
&mut builder.reborrow().init_dial_info(),
)?;
let node_builder = builder.reborrow().init_node();
match &route_hop.node {
RouteNode::NodeId(ni) => {
let ni_builder = node_builder.init_node_id();
encode_public_key(&ni.key, &mut ni_builder)?;
}
RouteNode::PeerInfo(pi) => {
let pi_builder = node_builder.init_peer_info();
encode_peer_info(&pi, &mut pi_builder)?;
}
}
if let Some(rhd) = &route_hop.next_hop {
let mut rhd_builder = builder.reborrow().init_next_hop();
encode_route_hop_data(rhd, &mut rhd_builder)?;
@@ -39,6 +67,36 @@ pub fn encode_route_hop(
Ok(())
}
pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<RouteHop, RPCError> {
let n_reader = reader.reborrow().get_node();
let node = match n_reader.which().map_err(RPCError::protocol)? {
veilid_capnp::route_hop::node::Which::NodeId(ni) => {
let ni_reader = ni.map_err(RPCError::protocol)?;
RouteNode::NodeId(NodeId::new(decode_public_key(&ni_reader)))
}
veilid_capnp::route_hop::node::Which::PeerInfo(pi) => {
let pi_reader = pi.map_err(RPCError::protocol)?;
RouteNode::PeerInfo(
decode_peer_info(&pi_reader, true)
.map_err(RPCError::map_protocol("invalid peer info in route hop"))?,
)
}
};
let next_hop = if reader.has_next_hop() {
let rhd_reader = reader
.get_next_hop()
.map_err(RPCError::map_protocol("invalid next hop in route hop"))?;
Some(decode_route_hop_data(&rhd_reader)?)
} else {
None
};
Ok(RouteHop { node, next_hop })
}
////////////////////////////////////////////////////////////////////////////////////////////////////
pub fn encode_private_route(
private_route: &PrivateRoute,
builder: &mut veilid_capnp::private_route::Builder,
@@ -48,7 +106,7 @@ pub fn encode_private_route(
&mut builder.reborrow().init_public_key(),
)?;
builder.set_hop_count(private_route.hop_count);
if let Some(rh) = &private_route.hops {
if let Some(rh) = &private_route.first_hop {
let mut rh_builder = builder.reborrow().init_first_hop();
encode_route_hop(rh, &mut rh_builder)?;
};
@@ -56,6 +114,31 @@ pub fn encode_private_route(
Ok(())
}
pub fn decode_private_route(
reader: &veilid_capnp::private_route::Reader,
) -> Result<PrivateRoute, RPCError> {
let public_key = decode_public_key(&reader.get_public_key().map_err(
RPCError::map_protocol("invalid public key in private route"),
)?);
let hop_count = reader.get_hop_count();
let first_hop = if reader.has_first_hop() {
let rh_reader = reader
.get_first_hop()
.map_err(RPCError::map_protocol("invalid first hop in private route"))?;
Some(decode_route_hop(&rh_reader)?)
} else {
None
};
Ok(PrivateRoute {
public_key,
hop_count,
first_hop,
})
}
////////////////////////////////////////////////////////////////////////////////////////////////////
pub fn encode_safety_route(
safety_route: &SafetyRoute,
builder: &mut veilid_capnp::safety_route::Builder,
@@ -80,71 +163,6 @@ pub fn encode_safety_route(
Ok(())
}
pub fn decode_route_hop_data(
reader: &veilid_capnp::route_hop_data::Reader,
) -> Result<RouteHopData, RPCError> {
let nonce = decode_nonce(
&reader
.reborrow()
.get_nonce()
.map_err(RPCError::map_protocol("invalid nonce in route hop data"))?,
);
let blob = reader
.reborrow()
.get_blob()
.map_err(RPCError::map_protocol("invalid blob in route hop data"))?
.to_vec();
Ok(RouteHopData { nonce, blob })
}
pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<RouteHop, RPCError> {
let dial_info = decode_node_dial_info(
&reader
.reborrow()
.get_dial_info()
.map_err(RPCError::map_protocol("invalid dial info in route hop"))?,
)?;
let next_hop = if reader.has_next_hop() {
let rhd_reader = reader
.get_next_hop()
.map_err(RPCError::map_protocol("invalid next hop in route hop"))?;
Some(decode_route_hop_data(&rhd_reader)?)
} else {
None
};
Ok(RouteHop {
dial_info,
next_hop,
})
}
pub fn decode_private_route(
reader: &veilid_capnp::private_route::Reader,
) -> Result<PrivateRoute, RPCError> {
let public_key = decode_public_key(&reader.get_public_key().map_err(
RPCError::map_protocol("invalid public key in private route"),
)?);
let hop_count = reader.get_hop_count();
let hops = if reader.has_first_hop() {
let rh_reader = reader
.get_first_hop()
.map_err(RPCError::map_protocol("invalid first hop in private route"))?;
Some(decode_route_hop(&rh_reader)?)
} else {
None
};
Ok(PrivateRoute {
public_key,
hop_count,
hops,
})
}
pub fn decode_safety_route(
reader: &veilid_capnp::safety_route::Reader,
) -> Result<SafetyRoute, RPCError> {

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

@@ -8,7 +8,7 @@ pub enum Destination {
/// The node to send to
target: NodeRef,
/// Require safety route or not
safety: Option<SafetySpec>,
safety_spec: Option<SafetySpec>,
},
/// Send to node for relay purposes
Relay {
@@ -17,14 +17,14 @@ pub enum Destination {
/// The final destination the relay should send to
target: DHTKey,
/// Require safety route or not
safety: Option<SafetySpec>,
safety_spec: Option<SafetySpec>,
},
/// Send to private route (privateroute)
PrivateRoute {
/// A private route to send to
private_route: PrivateRoute,
/// Require safety route or not
safety: Option<SafetySpec>,
safety_spec: Option<SafetySpec>,
/// Prefer reliability or not
reliable: bool,
},
@@ -34,46 +34,49 @@ impl Destination {
pub fn direct(target: NodeRef) -> Self {
Self::Direct {
target,
safety: None,
safety_spec: None,
}
}
pub fn relay(relay: NodeRef, target: DHTKey) -> Self {
Self::Relay {
relay,
target,
safety: None,
safety_spec: None,
}
}
pub fn private_route(private_route: PrivateRoute, reliable: bool) -> Self {
Self::PrivateRoute {
private_route,
safety: None,
safety_spec: None,
reliable,
}
}
pub fn with_safety(self, spec: SafetySpec) -> Self {
pub fn with_safety(self, safety_spec: SafetySpec) -> Self {
match self {
Destination::Direct { target, safety: _ } => Self::Direct {
Destination::Direct {
target,
safety: Some(spec),
safety_spec: _,
} => Self::Direct {
target,
safety_spec: Some(safety_spec),
},
Destination::Relay {
relay,
target,
safety: _,
safety_spec: _,
} => Self::Relay {
relay,
target,
safety: Some(spec),
safety_spec: Some(safety_spec),
},
Destination::PrivateRoute {
private_route,
safety: _,
safety_spec: _,
reliable,
} => Self::PrivateRoute {
private_route,
safety: Some(spec),
safety_spec: Some(safety_spec),
reliable,
},
}
@@ -83,26 +86,29 @@ impl Destination {
impl fmt::Display for Destination {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Destination::Direct { target, safety } => {
let sr = if safety.is_some() { "+SR" } else { "" };
Destination::Direct {
target,
safety_spec,
} => {
let sr = if safety_spec.is_some() { "+SR" } else { "" };
write!(f, "{}{}", target, sr)
}
Destination::Relay {
relay,
target,
safety,
safety_spec,
} => {
let sr = if safety.is_some() { "+SR" } else { "" };
let sr = if safety_spec.is_some() { "+SR" } else { "" };
write!(f, "{}@{}{}", target.encode(), relay, sr)
}
Destination::PrivateRoute {
private_route,
safety,
safety_spec,
reliable,
} => {
let sr = if safety.is_some() { "+SR" } else { "" };
let sr = if safety_spec.is_some() { "+SR" } else { "" };
let rl = if *reliable { "+RL" } else { "" };
write!(f, "{}{}{}", private_route, sr, rl)

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

@@ -1,7 +1,6 @@
mod coders;
mod destination;
mod operation_waiter;
mod private_route;
mod rpc_app_call;
mod rpc_app_message;
mod rpc_cancel_tunnel;
@@ -24,7 +23,6 @@ mod rpc_watch_value;
pub use destination::*;
pub use operation_waiter::*;
pub use private_route::*;
pub use rpc_error::*;
use super::*;
@@ -398,7 +396,7 @@ impl RPCProcessor {
}
// Wrap an operation with a private route inside a safety route
pub(super) fn wrap_with_route(
pub(super) fn wrap_with_route(xxx continue here
&self,
safety_spec: SafetySpec,
private_route: PrivateRoute,
@@ -406,7 +404,7 @@ impl RPCProcessor {
) -> Result<RenderedOperation, RPCError> {
let compiled_route: CompiledRoute = self.routing_table().with_route_spec_store(|rss| {
// Compile the safety route with the private route
rss.compile_safety_route(safety_spec, private_route)
rss.compile_safety_route(self.safety_spec, private_route)
})?;
// Encrypt routed operation

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

@@ -72,8 +72,7 @@ impl RPCProcessor {
find_node_q.node_id,
// filter
|rti, _k, v| {
RoutingTable::filter_has_valid_signed_node_info_inner(
rti,
rti.filter_has_valid_signed_node_info(
RoutingDomain::PublicInternet,
has_valid_own_node_info,
v,
@@ -81,11 +80,9 @@ impl RPCProcessor {
},
// transform
|rti, k, v| {
let own_peer_info = own_peer_info.clone();
RoutingTable::transform_to_peer_info_inner(
rti,
rti.transform_to_peer_info(
RoutingDomain::PublicInternet,
own_peer_info,
own_peer_info.clone(),
k,
v,
)