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

refactor

Browse Source
This commit is contained in:
John Smith
2022-07-10 17:36:50 -04:00
parent cd0cd78e30
commit 7e0d7dad06
108 changed files with 1378 additions and 1535 deletions
Download Patch File Download Diff File Expand all files Collapse all files
veilid-core/src/rpc_processor/coders/address.rs
+7 -1
View File
@@ -55,6 +55,12 @@ pub fn decode_address(reader: &veilid_capnp::address::Reader) -> Result<Address,
v6b2[1], v6b2[2], v6b2[3], v6b3[0], v6b3[1], v6b3[2], v6b3[3],
])))
}
_ => Err(rpc_error_protocol("invalid address type")),
Ok(veilid_capnp::address::Which::Ipv4(Err(_))) => {
Err(RPCError::protocol("invalid ipv4 address"))
}
Ok(veilid_capnp::address::Which::Ipv6(Err(_))) => {
Err(RPCError::protocol("invalid ipv6 address"))
}
Err(_) => Err(RPCError::protocol("invalid address type")),
}
}
veilid-core/src/rpc_processor/coders/block_id.rs
+5 -13
View File
@@ -23,27 +23,19 @@ pub fn encode_block_id(
builder: &mut veilid_capnp::b_l_a_k_e3_hash::Builder,
) -> Result<(), RPCError> {
if !key.valid {
return Err(rpc_error_protocol("invalid key"));
return Err(RPCError::protocol("invalid key"));
}
builder.set_u0(u64::from_be_bytes(
key.bytes[0..8]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
key.bytes[0..8].try_into().map_err(RPCError::internal)?,
));
builder.set_u1(u64::from_be_bytes(
key.bytes[8..16]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
key.bytes[8..16].try_into().map_err(RPCError::internal)?,
));
builder.set_u2(u64::from_be_bytes(
key.bytes[16..24]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
key.bytes[16..24].try_into().map_err(RPCError::internal)?,
));
builder.set_u3(u64::from_be_bytes(
key.bytes[24..32]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
key.bytes[24..32].try_into().map_err(RPCError::internal)?,
));
Ok(())
}
veilid-core/src/rpc_processor/coders/dial_info.rs
+25 -18
View File
@@ -4,44 +4,51 @@ use core::convert::TryInto;
use rpc_processor::*;
pub fn decode_dial_info(reader: &veilid_capnp::dial_info::Reader) -> Result<DialInfo, RPCError> {
match reader.reborrow().which() {
Ok(veilid_capnp::dial_info::Which::Udp(Ok(udp))) => {
match reader
.reborrow()
.which()
.map_err(RPCError::map_protocol("Missing dial info type"))?
{
veilid_capnp::dial_info::Which::Udp(udp) => {
let socket_address_reader = udp
.map_err(RPCError::protocol)?
.get_socket_address()
.map_err(map_error_protocol!("missing UDP socketAddress"))?;
.map_err(RPCError::map_protocol("missing UDP socketAddress"))?;
let socket_address = decode_socket_address(&socket_address_reader)?;
Ok(DialInfo::udp(socket_address))
}
Ok(veilid_capnp::dial_info::Which::Tcp(Ok(tcp))) => {
veilid_capnp::dial_info::Which::Tcp(tcp) => {
let socket_address_reader = tcp
.map_err(RPCError::protocol)?
.get_socket_address()
.map_err(map_error_protocol!("missing TCP socketAddress"))?;
.map_err(RPCError::map_protocol("missing TCP socketAddress"))?;
let socket_address = decode_socket_address(&socket_address_reader)?;
Ok(DialInfo::tcp(socket_address))
}
Ok(veilid_capnp::dial_info::Which::Ws(Ok(ws))) => {
veilid_capnp::dial_info::Which::Ws(ws) => {
let ws = ws.map_err(RPCError::protocol)?;
let socket_address_reader = ws
.get_socket_address()
.map_err(map_error_protocol!("missing WS socketAddress"))?;
.map_err(RPCError::map_protocol("missing WS socketAddress"))?;
let socket_address = decode_socket_address(&socket_address_reader)?;
let request = ws
.get_request()
.map_err(map_error_protocol!("missing WS request"))?;
.map_err(RPCError::map_protocol("missing WS request"))?;
DialInfo::try_ws(socket_address, request.to_owned())
.map_err(map_error_protocol!("invalid WS dial info"))
.map_err(RPCError::map_protocol("invalid WS dial info"))
}
Ok(veilid_capnp::dial_info::Which::Wss(Ok(wss))) => {
veilid_capnp::dial_info::Which::Wss(wss) => {
let wss = wss.map_err(RPCError::protocol)?;
let socket_address_reader = wss
.get_socket_address()
.map_err(map_error_protocol!("missing WSS socketAddress"))?;
.map_err(RPCError::map_protocol("missing WSS socketAddress"))?;
let socket_address = decode_socket_address(&socket_address_reader)?;
let request = wss
.get_request()
.map_err(map_error_protocol!("missing WSS request"))?;
.map_err(RPCError::map_protocol("missing WSS request"))?;
DialInfo::try_wss(socket_address, request.to_owned())
.map_err(map_error_protocol!("invalid WSS dial info"))
.map_err(RPCError::map_protocol("invalid WSS dial info"))
}
_ => Err(rpc_error_internal("invalid dial info type")),
}
}
@@ -72,13 +79,13 @@ pub fn encode_dial_info(
)?;
let request = dial_info
.request()
.ok_or_else(|| rpc_error_internal("no request for WS dialinfo"))?;
.ok_or_else(RPCError::else_internal("no request for WS dialinfo"))?;
let mut requestb = di_ws_builder.init_request(
request
.len()
.try_into()
.map_err(map_error_protocol!("request too long"))?,
.map_err(RPCError::map_protocol("request too long"))?,
);
requestb.push_str(request.as_str());
}
@@ -90,13 +97,13 @@ pub fn encode_dial_info(
)?;
let request = dial_info
.request()
.ok_or_else(|| rpc_error_internal("no request for WSS dialinfo"))?;
.ok_or_else(RPCError::else_internal("no request for WSS dialinfo"))?;
let mut requestb = di_wss_builder.init_request(
request
.len()
.try_into()
.map_err(map_error_protocol!("request too long"))?,
.map_err(RPCError::map_protocol("request too long"))?,
);
requestb.push_str(request.as_str());
}
veilid-core/src/rpc_processor/coders/dial_info_detail.rs
+2 -7
View File
@@ -19,15 +19,10 @@ pub fn decode_dial_info_detail(
&reader
.reborrow()
.get_dial_info()
.map_err(map_error_capnp_error!())?,
.map_err(RPCError::protocol)?,
)?;
let class = decode_dial_info_class(
reader
.reborrow()
.get_class()
.map_err(map_error_capnp_notinschema!())?,
);
let class = decode_dial_info_class(reader.reborrow().get_class().map_err(RPCError::protocol)?);
Ok(DialInfoDetail { dial_info, class })
}
veilid-core/src/rpc_processor/coders/node_dial_info.rs
+6 -10
View File
@@ -15,16 +15,12 @@ pub fn encode_node_dial_info(
pub fn decode_node_dial_info(
reader: &veilid_capnp::node_dial_info::Reader,
) -> Result<NodeDialInfo, RPCError> {
let node_id = decode_public_key(
&reader
.get_node_id()
.map_err(map_error_protocol!("invalid public key in node_dial_info"))?,
);
let dial_info = decode_dial_info(
&reader
.get_dial_info()
.map_err(map_error_protocol!("invalid dial_info in node_dial_info"))?,
)?;
let node_id = decode_public_key(&reader.get_node_id().map_err(RPCError::map_protocol(
"invalid public key in node_dial_info",
))?);
let dial_info = decode_dial_info(&reader.get_dial_info().map_err(RPCError::map_protocol(
"invalid dial_info in node_dial_info",
))?)?;
Ok(NodeDialInfo {
node_id: NodeId::new(node_id),
veilid-core/src/rpc_processor/coders/node_info.rs
+7 -7
View File
@@ -18,8 +18,8 @@ pub fn encode_node_info(
.dial_info_detail_list
.len()
.try_into()
.map_err(map_error_protocol!(
"too many dial info details in node info"
.map_err(RPCError::map_protocol(
"too many dial info details in node info",
))?,
);
@@ -44,14 +44,14 @@ pub fn decode_node_info(
reader
.reborrow()
.get_network_class()
.map_err(map_error_capnp_notinschema!())?,
.map_err(RPCError::protocol)?,
);
let outbound_protocols = decode_protocol_set(
&reader
.reborrow()
.get_outbound_protocols()
.map_err(map_error_capnp_error!())?,
.map_err(RPCError::protocol)?,
)?;
let min_version = reader.reborrow().get_min_version();
@@ -60,12 +60,12 @@ pub fn decode_node_info(
let didl_reader = reader
.reborrow()
.get_dial_info_detail_list()
.map_err(map_error_capnp_error!())?;
.map_err(RPCError::protocol)?;
let mut dial_info_detail_list = Vec::<DialInfoDetail>::with_capacity(
didl_reader
.len()
.try_into()
.map_err(map_error_protocol!("too many dial info details"))?,
.map_err(RPCError::map_protocol("too many dial info details"))?,
);
for did in didl_reader.iter() {
dial_info_detail_list.push(decode_dial_info_detail(&did)?)
@@ -77,7 +77,7 @@ pub fn decode_node_info(
&reader
.reborrow()
.get_relay_peer_info()
.map_err(map_error_capnp_error!())?,
.map_err(RPCError::protocol)?,
false,
)?))
} else {
veilid-core/src/rpc_processor/coders/operations/answer.rs
+11 -11
View File
@@ -64,55 +64,55 @@ impl RPCAnswerDetail {
pub fn decode(
reader: &veilid_capnp::answer::detail::Reader,
) -> Result<RPCAnswerDetail, RPCError> {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let which_reader = reader.which().map_err(RPCError::protocol)?;
let out = match which_reader {
veilid_capnp::answer::detail::StatusA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationStatusA::decode(&op_reader)?;
RPCAnswerDetail::StatusA(out)
}
veilid_capnp::answer::detail::FindNodeA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationFindNodeA::decode(&op_reader)?;
RPCAnswerDetail::FindNodeA(out)
}
veilid_capnp::answer::detail::GetValueA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationGetValueA::decode(&op_reader)?;
RPCAnswerDetail::GetValueA(out)
}
veilid_capnp::answer::detail::SetValueA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationSetValueA::decode(&op_reader)?;
RPCAnswerDetail::SetValueA(out)
}
veilid_capnp::answer::detail::WatchValueA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationWatchValueA::decode(&op_reader)?;
RPCAnswerDetail::WatchValueA(out)
}
veilid_capnp::answer::detail::SupplyBlockA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationSupplyBlockA::decode(&op_reader)?;
RPCAnswerDetail::SupplyBlockA(out)
}
veilid_capnp::answer::detail::FindBlockA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationFindBlockA::decode(&op_reader)?;
RPCAnswerDetail::FindBlockA(out)
}
veilid_capnp::answer::detail::StartTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationStartTunnelA::decode(&op_reader)?;
RPCAnswerDetail::StartTunnelA(out)
}
veilid_capnp::answer::detail::CompleteTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationCompleteTunnelA::decode(&op_reader)?;
RPCAnswerDetail::CompleteTunnelA(out)
}
veilid_capnp::answer::detail::CancelTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationCancelTunnelA::decode(&op_reader)?;
RPCAnswerDetail::CancelTunnelA(out)
}
veilid-core/src/rpc_processor/coders/operations/operation.rs
+4 -6
View File
@@ -21,22 +21,20 @@ impl RPCOperationKind {
kind_reader: &veilid_capnp::operation::kind::Reader,
sender_node_id: &DHTKey,
) -> Result<Self, RPCError> {
let which_reader = kind_reader
.which()
.map_err(map_error_capnp_notinschema!())?;
let which_reader = kind_reader.which().map_err(RPCError::protocol)?;
let out = match which_reader {
veilid_capnp::operation::kind::Which::Question(r) => {
let q_reader = r.map_err(map_error_capnp_error!())?;
let q_reader = r.map_err(RPCError::protocol)?;
let out = RPCQuestion::decode(&q_reader, sender_node_id)?;
RPCOperationKind::Question(out)
}
veilid_capnp::operation::kind::Which::Statement(r) => {
let q_reader = r.map_err(map_error_capnp_error!())?;
let q_reader = r.map_err(RPCError::protocol)?;
let out = RPCStatement::decode(&q_reader, sender_node_id)?;
RPCOperationKind::Statement(out)
}
veilid_capnp::operation::kind::Which::Answer(r) => {
let q_reader = r.map_err(map_error_capnp_error!())?;
let q_reader = r.map_err(RPCError::protocol)?;
let out = RPCAnswer::decode(&q_reader)?;
RPCOperationKind::Answer(out)
}
veilid-core/src/rpc_processor/coders/operations/operation_cancel_tunnel.rs
+2 -2
View File
@@ -34,12 +34,12 @@ impl RPCOperationCancelTunnelA {
pub fn decode(
reader: &veilid_capnp::operation_cancel_tunnel_a::Reader,
) -> Result<RPCOperationCancelTunnelA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_cancel_tunnel_a::Which::Tunnel(r) => {
Ok(RPCOperationCancelTunnelA::Tunnel(r))
}
veilid_capnp::operation_cancel_tunnel_a::Which::Error(r) => {
let tunnel_error = decode_tunnel_error(r.map_err(map_error_capnp_notinschema!())?);
let tunnel_error = decode_tunnel_error(r.map_err(RPCError::protocol)?);
Ok(RPCOperationCancelTunnelA::Error(tunnel_error))
}
}
veilid-core/src/rpc_processor/coders/operations/operation_complete_tunnel.rs
+5 -8
View File
@@ -14,15 +14,12 @@ impl RPCOperationCompleteTunnelQ {
reader: &veilid_capnp::operation_complete_tunnel_q::Reader,
) -> Result<RPCOperationCompleteTunnelQ, RPCError> {
let id = reader.get_id();
let local_mode = match reader
.get_local_mode()
.map_err(map_error_capnp_notinschema!())?
{
let local_mode = match reader.get_local_mode().map_err(RPCError::protocol)? {
veilid_capnp::TunnelEndpointMode::Raw => TunnelMode::Raw,
veilid_capnp::TunnelEndpointMode::Turn => TunnelMode::Turn,
};
let depth = reader.get_depth();
let te_reader = reader.get_endpoint().map_err(map_error_capnp_error!())?;
let te_reader = reader.get_endpoint().map_err(RPCError::protocol)?;
let endpoint = decode_tunnel_endpoint(&te_reader)?;
Ok(RPCOperationCompleteTunnelQ {
@@ -59,14 +56,14 @@ impl RPCOperationCompleteTunnelA {
pub fn decode(
reader: &veilid_capnp::operation_complete_tunnel_a::Reader,
) -> Result<RPCOperationCompleteTunnelA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_complete_tunnel_a::Which::Tunnel(r) => {
let ft_reader = r.map_err(map_error_capnp_error!())?;
let ft_reader = r.map_err(RPCError::protocol)?;
let full_tunnel = decode_full_tunnel(&ft_reader)?;
Ok(RPCOperationCompleteTunnelA::Tunnel(full_tunnel))
}
veilid_capnp::operation_complete_tunnel_a::Which::Error(r) => {
let tunnel_error = decode_tunnel_error(r.map_err(map_error_capnp_notinschema!())?);
let tunnel_error = decode_tunnel_error(r.map_err(RPCError::protocol)?);
Ok(RPCOperationCompleteTunnelA::Error(tunnel_error))
}
}
veilid-core/src/rpc_processor/coders/operations/operation_find_block.rs
+8 -11
View File
@@ -10,7 +10,7 @@ impl RPCOperationFindBlockQ {
pub fn decode(
reader: &veilid_capnp::operation_find_block_q::Reader,
) -> Result<RPCOperationFindBlockQ, RPCError> {
let bi_reader = reader.get_block_id().map_err(map_error_capnp_error!())?;
let bi_reader = reader.get_block_id().map_err(RPCError::protocol)?;
let block_id = decode_block_id(&bi_reader);
Ok(RPCOperationFindBlockQ { block_id })
@@ -37,29 +37,26 @@ impl RPCOperationFindBlockA {
pub fn decode(
reader: &veilid_capnp::operation_find_block_a::Reader,
) -> Result<RPCOperationFindBlockA, RPCError> {
let data = reader
.get_data()
.map_err(map_error_capnp_error!())?
.to_vec();
let data = reader.get_data().map_err(RPCError::protocol)?.to_vec();
let suppliers_reader = reader.get_suppliers().map_err(map_error_capnp_error!())?;
let suppliers_reader = reader.get_suppliers().map_err(RPCError::protocol)?;
let mut suppliers = Vec::<PeerInfo>::with_capacity(
suppliers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many suppliers"))?,
.map_err(RPCError::map_internal("too many suppliers"))?,
);
for s in suppliers_reader.iter() {
let peer_info = decode_peer_info(&s, true)?;
suppliers.push(peer_info);
}
let peers_reader = reader.get_peers().map_err(map_error_capnp_error!())?;
let peers_reader = reader.get_peers().map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -83,7 +80,7 @@ impl RPCOperationFindBlockA {
self.suppliers
.len()
.try_into()
.map_err(map_error_internal!("invalid suppliers list length"))?,
.map_err(RPCError::map_internal("invalid suppliers list length"))?,
);
for (i, peer) in self.suppliers.iter().enumerate() {
let mut pi_builder = suppliers_builder.reborrow().get(i as u32);
@@ -94,7 +91,7 @@ impl RPCOperationFindBlockA {
self.peers
.len()
.try_into()
.map_err(map_error_internal!("invalid peers list length"))?,
.map_err(RPCError::map_internal("invalid peers list length"))?,
);
for (i, peer) in self.peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/operation_find_node.rs
+4 -4
View File
@@ -10,7 +10,7 @@ impl RPCOperationFindNodeQ {
pub fn decode(
reader: &veilid_capnp::operation_find_node_q::Reader,
) -> Result<RPCOperationFindNodeQ, RPCError> {
let ni_reader = reader.get_node_id().map_err(map_error_capnp_error!())?;
let ni_reader = reader.get_node_id().map_err(RPCError::protocol)?;
let node_id = decode_public_key(&ni_reader);
Ok(RPCOperationFindNodeQ { node_id })
}
@@ -33,12 +33,12 @@ impl RPCOperationFindNodeA {
pub fn decode(
reader: &veilid_capnp::operation_find_node_a::Reader,
) -> Result<RPCOperationFindNodeA, RPCError> {
let peers_reader = reader.get_peers().map_err(map_error_capnp_error!())?;
let peers_reader = reader.get_peers().map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -55,7 +55,7 @@ impl RPCOperationFindNodeA {
self.peers
.len()
.try_into()
.map_err(map_error_internal!("invalid closest nodes list length"))?,
.map_err(RPCError::map_internal("invalid closest nodes list length"))?,
);
for (i, peer) in self.peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/operation_get_value.rs
+6 -6
View File
@@ -10,7 +10,7 @@ impl RPCOperationGetValueQ {
pub fn decode(
reader: &veilid_capnp::operation_get_value_q::Reader,
) -> Result<RPCOperationGetValueQ, RPCError> {
let k_reader = reader.get_key().map_err(map_error_capnp_error!())?;
let k_reader = reader.get_key().map_err(RPCError::protocol)?;
let key = decode_value_key(&k_reader)?;
Ok(RPCOperationGetValueQ { key })
}
@@ -34,18 +34,18 @@ impl RPCOperationGetValueA {
pub fn decode(
reader: &veilid_capnp::operation_get_value_a::Reader,
) -> Result<RPCOperationGetValueA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_get_value_a::Which::Data(r) => {
let data = decode_value_data(&r.map_err(map_error_capnp_error!())?)?;
let data = decode_value_data(&r.map_err(RPCError::protocol)?)?;
Ok(RPCOperationGetValueA::Data(data))
}
veilid_capnp::operation_get_value_a::Which::Peers(r) => {
let peers_reader = r.map_err(map_error_capnp_error!())?;
let peers_reader = r.map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -70,7 +70,7 @@ impl RPCOperationGetValueA {
peers
.len()
.try_into()
.map_err(map_error_internal!("invalid peers list length"))?,
.map_err(RPCError::map_internal("invalid peers list length"))?,
);
for (i, peer) in peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/operation_node_info_update.rs
+1 -3
View File
@@ -11,9 +11,7 @@ impl RPCOperationNodeInfoUpdate {
reader: &veilid_capnp::operation_node_info_update::Reader,
sender_node_id: &DHTKey,
) -> Result<RPCOperationNodeInfoUpdate, RPCError> {
let sni_reader = reader
.get_signed_node_info()
.map_err(map_error_capnp_error!())?;
let sni_reader = reader.get_signed_node_info().map_err(RPCError::protocol)?;
let signed_node_info = decode_signed_node_info(&sni_reader, sender_node_id, true)?;
Ok(RPCOperationNodeInfoUpdate { signed_node_info })
veilid-core/src/rpc_processor/coders/operations/operation_return_receipt.rs
+1 -1
View File
@@ -10,7 +10,7 @@ impl RPCOperationReturnReceipt {
pub fn decode(
reader: &veilid_capnp::operation_return_receipt::Reader,
) -> Result<RPCOperationReturnReceipt, RPCError> {
let rcpt_reader = reader.get_receipt().map_err(map_error_capnp_error!())?;
let rcpt_reader = reader.get_receipt().map_err(RPCError::protocol)?;
let receipt = rcpt_reader.to_vec();
Ok(RPCOperationReturnReceipt { receipt })
veilid-core/src/rpc_processor/coders/operations/operation_route.rs
+7 -12
View File
@@ -20,24 +20,21 @@ impl RoutedOperation {
pub fn decode(
reader: &veilid_capnp::routed_operation::Reader,
) -> Result<RoutedOperation, RPCError> {
let sigs_reader = reader.get_signatures().map_err(map_error_capnp_error!())?;
let sigs_reader = reader.get_signatures().map_err(RPCError::protocol)?;
let mut signatures = Vec::<DHTSignature>::with_capacity(
sigs_reader
.len()
.try_into()
.map_err(map_error_internal!("too many signatures"))?,
.map_err(RPCError::map_internal("too many signatures"))?,
);
for s in sigs_reader.iter() {
let sig = decode_signature(&s);
signatures.push(sig);
}
let n_reader = reader.get_nonce().map_err(map_error_capnp_error!())?;
let n_reader = reader.get_nonce().map_err(RPCError::protocol)?;
let nonce = decode_nonce(&n_reader);
let data = reader
.get_data()
.map_err(map_error_capnp_error!())?
.to_vec();
let data = reader.get_data().map_err(RPCError::protocol)?.to_vec();
Ok(RoutedOperation {
signatures,
@@ -54,7 +51,7 @@ impl RoutedOperation {
self.signatures
.len()
.try_into()
.map_err(map_error_internal!("invalid signatures list length"))?,
.map_err(RPCError::map_internal("invalid signatures list length"))?,
);
for (i, sig) in self.signatures.iter().enumerate() {
let mut sig_builder = sigs_builder.reborrow().get(i as u32);
@@ -78,12 +75,10 @@ impl RPCOperationRoute {
pub fn decode(
reader: &veilid_capnp::operation_route::Reader,
) -> Result<RPCOperationRoute, RPCError> {
let sr_reader = reader
.get_safety_route()
.map_err(map_error_capnp_error!())?;
let sr_reader = reader.get_safety_route().map_err(RPCError::protocol)?;
let safety_route = decode_safety_route(&sr_reader)?;
let o_reader = reader.get_operation().map_err(map_error_capnp_error!())?;
let o_reader = reader.get_operation().map_err(RPCError::protocol)?;
let operation = RoutedOperation::decode(&o_reader)?;
Ok(RPCOperationRoute {
veilid-core/src/rpc_processor/coders/operations/operation_set_value.rs
+7 -7
View File
@@ -11,9 +11,9 @@ impl RPCOperationSetValueQ {
pub fn decode(
reader: &veilid_capnp::operation_set_value_q::Reader,
) -> Result<RPCOperationSetValueQ, RPCError> {
let k_reader = reader.get_key().map_err(map_error_capnp_error!())?;
let k_reader = reader.get_key().map_err(RPCError::protocol)?;
let key = decode_value_key(&k_reader)?;
let v_reader = reader.get_value().map_err(map_error_capnp_error!())?;
let v_reader = reader.get_value().map_err(RPCError::protocol)?;
let value = decode_value_data(&v_reader)?;
Ok(RPCOperationSetValueQ { key, value })
}
@@ -39,18 +39,18 @@ impl RPCOperationSetValueA {
pub fn decode(
reader: &veilid_capnp::operation_set_value_a::Reader,
) -> Result<RPCOperationSetValueA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_set_value_a::Which::Data(r) => {
let data = decode_value_data(&r.map_err(map_error_capnp_error!())?)?;
let data = decode_value_data(&r.map_err(RPCError::protocol)?)?;
Ok(RPCOperationSetValueA::Data(data))
}
veilid_capnp::operation_set_value_a::Which::Peers(r) => {
let peers_reader = r.map_err(map_error_capnp_error!())?;
let peers_reader = r.map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -75,7 +75,7 @@ impl RPCOperationSetValueA {
peers
.len()
.try_into()
.map_err(map_error_internal!("invalid peers list length"))?,
.map_err(RPCError::map_internal("invalid peers list length"))?,
);
for (i, peer) in peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/operation_start_tunnel.rs
+4 -7
View File
@@ -13,10 +13,7 @@ impl RPCOperationStartTunnelQ {
reader: &veilid_capnp::operation_start_tunnel_q::Reader,
) -> Result<RPCOperationStartTunnelQ, RPCError> {
let id = reader.get_id();
let local_mode = match reader
.get_local_mode()
.map_err(map_error_capnp_notinschema!())?
{
let local_mode = match reader.get_local_mode().map_err(RPCError::protocol)? {
veilid_capnp::TunnelEndpointMode::Raw => TunnelMode::Raw,
veilid_capnp::TunnelEndpointMode::Turn => TunnelMode::Turn,
};
@@ -53,14 +50,14 @@ impl RPCOperationStartTunnelA {
pub fn decode(
reader: &veilid_capnp::operation_start_tunnel_a::Reader,
) -> Result<RPCOperationStartTunnelA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_start_tunnel_a::Which::Partial(r) => {
let pt_reader = r.map_err(map_error_capnp_error!())?;
let pt_reader = r.map_err(RPCError::protocol)?;
let partial_tunnel = decode_partial_tunnel(&pt_reader)?;
Ok(RPCOperationStartTunnelA::Partial(partial_tunnel))
}
veilid_capnp::operation_start_tunnel_a::Which::Error(r) => {
let tunnel_error = decode_tunnel_error(r.map_err(map_error_capnp_notinschema!())?);
let tunnel_error = decode_tunnel_error(r.map_err(RPCError::protocol)?);
Ok(RPCOperationStartTunnelA::Error(tunnel_error))
}
}
veilid-core/src/rpc_processor/coders/operations/operation_status.rs
+3 -3
View File
@@ -10,7 +10,7 @@ impl RPCOperationStatusQ {
pub fn decode(
reader: &veilid_capnp::operation_status_q::Reader,
) -> Result<RPCOperationStatusQ, RPCError> {
let ns_reader = reader.get_node_status().map_err(map_error_capnp_error!())?;
let ns_reader = reader.get_node_status().map_err(RPCError::protocol)?;
let node_status = decode_node_status(&ns_reader)?;
Ok(RPCOperationStatusQ { node_status })
}
@@ -34,10 +34,10 @@ impl RPCOperationStatusA {
pub fn decode(
reader: &veilid_capnp::operation_status_a::Reader,
) -> Result<RPCOperationStatusA, RPCError> {
let ns_reader = reader.get_node_status().map_err(map_error_capnp_error!())?;
let ns_reader = reader.get_node_status().map_err(RPCError::protocol)?;
let node_status = decode_node_status(&ns_reader)?;
let si_reader = reader.get_sender_info().map_err(map_error_capnp_error!())?;
let si_reader = reader.get_sender_info().map_err(RPCError::protocol)?;
let sender_info = decode_sender_info(&si_reader)?;
Ok(RPCOperationStatusA {
veilid-core/src/rpc_processor/coders/operations/operation_supply_block.rs
+5 -5
View File
@@ -10,7 +10,7 @@ impl RPCOperationSupplyBlockQ {
pub fn decode(
reader: &veilid_capnp::operation_supply_block_q::Reader,
) -> Result<RPCOperationSupplyBlockQ, RPCError> {
let bi_reader = reader.get_block_id().map_err(map_error_capnp_error!())?;
let bi_reader = reader.get_block_id().map_err(RPCError::protocol)?;
let block_id = decode_block_id(&bi_reader);
Ok(RPCOperationSupplyBlockQ { block_id })
@@ -36,17 +36,17 @@ impl RPCOperationSupplyBlockA {
pub fn decode(
reader: &veilid_capnp::operation_supply_block_a::Reader,
) -> Result<RPCOperationSupplyBlockA, RPCError> {
match reader.which().map_err(map_error_capnp_notinschema!())? {
match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::operation_supply_block_a::Which::Expiration(r) => {
Ok(RPCOperationSupplyBlockA::Expiration(r))
}
veilid_capnp::operation_supply_block_a::Which::Peers(r) => {
let peers_reader = r.map_err(map_error_capnp_error!())?;
let peers_reader = r.map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -70,7 +70,7 @@ impl RPCOperationSupplyBlockA {
peers
.len()
.try_into()
.map_err(map_error_internal!("invalid peers list length"))?,
.map_err(RPCError::map_internal("invalid peers list length"))?,
);
for (i, peer) in peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/operation_validate_dial_info.rs
+2 -2
View File
@@ -12,9 +12,9 @@ impl RPCOperationValidateDialInfo {
pub fn decode(
reader: &veilid_capnp::operation_validate_dial_info::Reader,
) -> Result<RPCOperationValidateDialInfo, RPCError> {
let di_reader = reader.get_dial_info().map_err(map_error_capnp_error!())?;
let di_reader = reader.get_dial_info().map_err(RPCError::protocol)?;
let dial_info = decode_dial_info(&di_reader)?;
let rcpt_reader = reader.get_receipt().map_err(map_error_capnp_error!())?;
let rcpt_reader = reader.get_receipt().map_err(RPCError::protocol)?;
let receipt = rcpt_reader.to_vec();
let redirect = reader.get_redirect();
veilid-core/src/rpc_processor/coders/operations/operation_value_changed.rs
+2 -2
View File
@@ -11,9 +11,9 @@ impl RPCOperationValueChanged {
pub fn decode(
reader: &veilid_capnp::operation_value_changed::Reader,
) -> Result<RPCOperationValueChanged, RPCError> {
let k_reader = reader.get_key().map_err(map_error_capnp_error!())?;
let k_reader = reader.get_key().map_err(RPCError::protocol)?;
let key = decode_value_key(&k_reader)?;
let v_reader = reader.get_value().map_err(map_error_capnp_error!())?;
let v_reader = reader.get_value().map_err(RPCError::protocol)?;
let value = decode_value_data(&v_reader)?;
Ok(RPCOperationValueChanged { key, value })
}
veilid-core/src/rpc_processor/coders/operations/operation_watch_value.rs
+4 -4
View File
@@ -10,7 +10,7 @@ impl RPCOperationWatchValueQ {
pub fn decode(
reader: &veilid_capnp::operation_watch_value_q::Reader,
) -> Result<RPCOperationWatchValueQ, RPCError> {
let k_reader = reader.get_key().map_err(map_error_capnp_error!())?;
let k_reader = reader.get_key().map_err(RPCError::protocol)?;
let key = decode_value_key(&k_reader)?;
Ok(RPCOperationWatchValueQ { key })
}
@@ -35,12 +35,12 @@ impl RPCOperationWatchValueA {
reader: &veilid_capnp::operation_watch_value_a::Reader,
) -> Result<RPCOperationWatchValueA, RPCError> {
let expiration = reader.get_expiration();
let peers_reader = reader.get_peers().map_err(map_error_capnp_error!())?;
let peers_reader = reader.get_peers().map_err(RPCError::protocol)?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
.map_err(RPCError::map_internal("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
@@ -59,7 +59,7 @@ impl RPCOperationWatchValueA {
self.peers
.len()
.try_into()
.map_err(map_error_internal!("invalid peers list length"))?,
.map_err(RPCError::map_internal("invalid peers list length"))?,
);
for (i, peer) in self.peers.iter().enumerate() {
let mut pi_builder = peers_builder.reborrow().get(i as u32);
veilid-core/src/rpc_processor/coders/operations/question.rs
+11 -11
View File
@@ -78,55 +78,55 @@ impl RPCQuestionDetail {
pub fn decode(
reader: &veilid_capnp::question::detail::Reader,
) -> Result<RPCQuestionDetail, RPCError> {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let which_reader = reader.which().map_err(RPCError::protocol)?;
let out = match which_reader {
veilid_capnp::question::detail::StatusQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationStatusQ::decode(&op_reader)?;
RPCQuestionDetail::StatusQ(out)
}
veilid_capnp::question::detail::FindNodeQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationFindNodeQ::decode(&op_reader)?;
RPCQuestionDetail::FindNodeQ(out)
}
veilid_capnp::question::detail::GetValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationGetValueQ::decode(&op_reader)?;
RPCQuestionDetail::GetValueQ(out)
}
veilid_capnp::question::detail::SetValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationSetValueQ::decode(&op_reader)?;
RPCQuestionDetail::SetValueQ(out)
}
veilid_capnp::question::detail::WatchValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationWatchValueQ::decode(&op_reader)?;
RPCQuestionDetail::WatchValueQ(out)
}
veilid_capnp::question::detail::SupplyBlockQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationSupplyBlockQ::decode(&op_reader)?;
RPCQuestionDetail::SupplyBlockQ(out)
}
veilid_capnp::question::detail::FindBlockQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationFindBlockQ::decode(&op_reader)?;
RPCQuestionDetail::FindBlockQ(out)
}
veilid_capnp::question::detail::StartTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationStartTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::StartTunnelQ(out)
}
veilid_capnp::question::detail::CompleteTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationCompleteTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::CompleteTunnelQ(out)
}
veilid_capnp::question::detail::CancelTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationCancelTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::CancelTunnelQ(out)
}
veilid-core/src/rpc_processor/coders/operations/respond_to.rs
+6 -13
View File
@@ -32,25 +32,18 @@ impl RespondTo {
reader: &veilid_capnp::question::respond_to::Reader,
sender_node_id: &DHTKey,
) -> Result<Self, RPCError> {
let respond_to = match reader.which().map_err(map_error_capnp_notinschema!())? {
veilid_capnp::question::respond_to::Sender(_) => RespondTo::Sender(None),
veilid_capnp::question::respond_to::SenderWithInfo(Ok(sender_ni_reader)) => {
let respond_to = match reader.which().map_err(RPCError::protocol)? {
veilid_capnp::question::respond_to::Sender(()) => RespondTo::Sender(None),
veilid_capnp::question::respond_to::SenderWithInfo(sender_ni_reader) => {
let sender_ni_reader = sender_ni_reader.map_err(RPCError::protocol)?;
let sni = decode_signed_node_info(&sender_ni_reader, sender_node_id, true)?;
RespondTo::Sender(Some(sni))
}
veilid_capnp::question::respond_to::SenderWithInfo(Err(e)) => {
return Err(rpc_error_protocol(format!(
"invalid signed node info: {}",
e
)))
}
veilid_capnp::question::respond_to::PrivateRoute(Ok(pr_reader)) => {
veilid_capnp::question::respond_to::PrivateRoute(pr_reader) => {
let pr_reader = pr_reader.map_err(RPCError::protocol)?;
let pr = decode_private_route(&pr_reader)?;
RespondTo::PrivateRoute(pr)
}
veilid_capnp::question::respond_to::PrivateRoute(Err(e)) => {
return Err(rpc_error_protocol(format!("invalid private route: {}", e)));
}
};
Ok(respond_to)
}
veilid-core/src/rpc_processor/coders/operations/statement.rs
+7 -7
View File
@@ -59,35 +59,35 @@ impl RPCStatementDetail {
reader: &veilid_capnp::statement::detail::Reader,
sender_node_id: &DHTKey,
) -> Result<RPCStatementDetail, RPCError> {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let which_reader = reader.which().map_err(RPCError::protocol)?;
let out = match which_reader {
veilid_capnp::statement::detail::ValidateDialInfo(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationValidateDialInfo::decode(&op_reader)?;
RPCStatementDetail::ValidateDialInfo(out)
}
veilid_capnp::statement::detail::Route(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationRoute::decode(&op_reader)?;
RPCStatementDetail::Route(out)
}
veilid_capnp::statement::detail::NodeInfoUpdate(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationNodeInfoUpdate::decode(&op_reader, sender_node_id)?;
RPCStatementDetail::NodeInfoUpdate(out)
}
veilid_capnp::statement::detail::ValueChanged(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationValueChanged::decode(&op_reader)?;
RPCStatementDetail::ValueChanged(out)
}
veilid_capnp::statement::detail::Signal(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationSignal::decode(&op_reader)?;
RPCStatementDetail::Signal(out)
}
veilid_capnp::statement::detail::ReturnReceipt(r) => {
let op_reader = r.map_err(map_error_capnp_error!())?;
let op_reader = r.map_err(RPCError::protocol)?;
let out = RPCOperationReturnReceipt::decode(&op_reader)?;
RPCStatementDetail::ReturnReceipt(out)
}
veilid-core/src/rpc_processor/coders/peer_info.rs
+2 -2
View File
@@ -21,11 +21,11 @@ pub fn decode_peer_info(
let nid_reader = reader
.reborrow()
.get_node_id()
.map_err(map_error_capnp_error!())?;
.map_err(RPCError::protocol)?;
let sni_reader = reader
.reborrow()
.get_signed_node_info()
.map_err(map_error_capnp_error!())?;
.map_err(RPCError::protocol)?;
let node_id = NodeId::new(decode_public_key(&nid_reader));
let signed_node_info =
decode_signed_node_info(&sni_reader, &node_id.key, allow_relay_peer_info)?;
veilid-core/src/rpc_processor/coders/private_safety_route.rs
+25 -24
View File
@@ -83,13 +83,17 @@ pub fn encode_route_hop_data(
//
let mut nonce_builder = builder.reborrow().init_nonce();
encode_nonce(&route_hop_data.nonce, &mut nonce_builder);
let blob_builder = builder.reborrow().init_blob(
route_hop_data
.blob
.len()
.try_into()
.map_err(map_error_protocol!("invalid blob length in route hop data"))?,
);
let blob_builder = builder
.reborrow()
.init_blob(
route_hop_data
.blob
.len()
.try_into()
.map_err(RPCError::map_protocol(
"invalid blob length in route hop data",
))?,
);
blob_builder.copy_from_slice(route_hop_data.blob.as_slice());
Ok(())
}
@@ -157,13 +161,13 @@ pub fn decode_route_hop_data(
&reader
.reborrow()
.get_nonce()
.map_err(map_error_protocol!("invalid nonce in route hop data"))?,
.map_err(RPCError::map_protocol("invalid nonce in route hop data"))?,
);
let blob = reader
.reborrow()
.get_blob()
.map_err(map_error_protocol!("invalid blob in route hop data"))?
.map_err(RPCError::map_protocol("invalid blob in route hop data"))?
.to_vec();
Ok(RouteHopData { nonce, blob })
@@ -174,13 +178,13 @@ pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<Rout
&reader
.reborrow()
.get_dial_info()
.map_err(map_error_protocol!("invalid dial info in route hop"))?,
.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(map_error_protocol!("invalid next hop in route hop"))?;
.map_err(RPCError::map_protocol("invalid next hop in route hop"))?;
Some(decode_route_hop_data(&rhd_reader)?)
} else {
None
@@ -195,16 +199,14 @@ pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<Rout
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(map_error_protocol!("invalid public key in private route"))?,
);
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(map_error_protocol!("invalid first hop in private route"))?;
.map_err(RPCError::map_protocol("invalid first hop in private route"))?;
Some(decode_route_hop(&rh_reader)?)
} else {
None
@@ -223,19 +225,18 @@ pub fn decode_safety_route(
let public_key = decode_public_key(
&reader
.get_public_key()
.map_err(map_error_protocol!("invalid public key in safety route"))?,
.map_err(RPCError::map_protocol("invalid public key in safety route"))?,
);
let hop_count = reader.get_hop_count();
let hops = match reader.get_hops().which() {
Ok(veilid_capnp::safety_route::hops::Which::Data(Ok(rhd_reader))) => {
let hops = match reader.get_hops().which().map_err(RPCError::protocol)? {
veilid_capnp::safety_route::hops::Which::Data(rhd_reader) => {
let rhd_reader = rhd_reader.map_err(RPCError::protocol)?;
SafetyRouteHops::Data(decode_route_hop_data(&rhd_reader)?)
}
Ok(veilid_capnp::safety_route::hops::Which::Private(Ok(pr_reader))) => {
veilid_capnp::safety_route::hops::Which::Private(pr_reader) => {
let pr_reader = pr_reader.map_err(RPCError::protocol)?;
SafetyRouteHops::Private(decode_private_route(&pr_reader)?)
}
_ => {
return Err(rpc_error_protocol("invalid hops in safety route"));
}
};
Ok(SafetyRoute {
veilid-core/src/rpc_processor/coders/public_key.rs
+5 -5
View File
@@ -23,27 +23,27 @@ pub fn encode_public_key(
builder: &mut veilid_capnp::curve25519_public_key::Builder,
) -> Result<(), RPCError> {
if !key.valid {
return Err(rpc_error_protocol("invalid key"));
return Err(RPCError::protocol("invalid key"));
}
builder.set_u0(u64::from_be_bytes(
key.bytes[0..8]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
));
builder.set_u1(u64::from_be_bytes(
key.bytes[8..16]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
));
builder.set_u2(u64::from_be_bytes(
key.bytes[16..24]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
));
builder.set_u3(u64::from_be_bytes(
key.bytes[24..32]
.try_into()
.map_err(map_error_protocol!("slice with incorrect length"))?,
.map_err(RPCError::map_protocol("slice with incorrect length"))?,
));
Ok(())
}
veilid-core/src/rpc_processor/coders/sender_info.rs
+4 -2
View File
@@ -16,14 +16,16 @@ pub fn decode_sender_info(
reader: &veilid_capnp::sender_info::Reader,
) -> Result<SenderInfo, RPCError> {
if !reader.has_socket_address() {
return Err(rpc_error_internal("invalid socket address type"));
return Err(RPCError::internal("invalid socket address type"));
}
let socket_address = if reader.has_socket_address() {
Some(decode_socket_address(
&reader
.reborrow()
.get_socket_address()
.map_err(map_error_internal!("invalid socket address in sender_info"))?,
.map_err(RPCError::map_internal(
"invalid socket address in sender_info",
))?,
)?)
} else {
None
veilid-core/src/rpc_processor/coders/signal_info.rs
+15 -21
View File
@@ -10,8 +10,8 @@ pub fn encode_signal_info(
let mut hp_builder = builder.reborrow().init_hole_punch();
let r_builder = hp_builder
.reborrow()
.init_receipt(receipt.len().try_into().map_err(map_error_protocol!(
"invalid receipt length in encode_signal_info"
.init_receipt(receipt.len().try_into().map_err(RPCError::map_protocol(
"invalid receipt length in encode_signal_info",
))?);
r_builder.copy_from_slice(receipt);
let mut pi_builder = hp_builder.init_peer_info();
@@ -21,8 +21,8 @@ pub fn encode_signal_info(
let mut rc_builder = builder.reborrow().init_reverse_connect();
let r_builder = rc_builder
.reborrow()
.init_receipt(receipt.len().try_into().map_err(map_error_protocol!(
"invalid receipt length in encode_signal_info"
.init_receipt(receipt.len().try_into().map_err(RPCError::map_protocol(
"invalid receipt length in encode_signal_info",
))?);
r_builder.copy_from_slice(receipt);
let mut pi_builder = rc_builder.init_peer_info();
@@ -39,22 +39,19 @@ pub fn decode_signal_info(
Ok(
match reader
.which()
.map_err(map_error_internal!("invalid signal operation"))?
.map_err(RPCError::map_internal("invalid signal operation"))?
{
veilid_capnp::operation_signal::HolePunch(r) => {
// Extract hole punch reader
let r = match r {
Ok(r) => r,
Err(_) => return Err(rpc_error_internal("invalid hole punch")),
};
let r = r.map_err(RPCError::protocol)?;
let receipt = r
.get_receipt()
.map_err(map_error_protocol!(
"invalid receipt in hole punch signal info"
.map_err(RPCError::map_protocol(
"invalid receipt in hole punch signal info",
))?
.to_vec();
let pi_reader = r.get_peer_info().map_err(map_error_protocol!(
"invalid peer info in hole punch signal info"
let pi_reader = r.get_peer_info().map_err(RPCError::map_protocol(
"invalid peer info in hole punch signal info",
))?;
let peer_info = decode_peer_info(&pi_reader, true)?;
@@ -62,18 +59,15 @@ pub fn decode_signal_info(
}
veilid_capnp::operation_signal::ReverseConnect(r) => {
// Extract reverse connect reader
let r = match r {
Ok(r) => r,
Err(_) => return Err(rpc_error_internal("invalid reverse connect")),
};
let r = r.map_err(RPCError::protocol)?;
let receipt = r
.get_receipt()
.map_err(map_error_protocol!(
"invalid receipt in hole punch signal info"
.map_err(RPCError::map_protocol(
"invalid receipt in hole punch signal info",
))?
.to_vec();
let pi_reader = r.get_peer_info().map_err(map_error_protocol!(
"invalid peer info in reverse connect signal info"
let pi_reader = r.get_peer_info().map_err(RPCError::map_protocol(
"invalid peer info in reverse connect signal info",
))?;
let peer_info = decode_peer_info(&pi_reader, true)?;
veilid-core/src/rpc_processor/coders/signed_node_info.rs
+3 -3
View File
@@ -25,17 +25,17 @@ pub fn decode_signed_node_info(
let ni_reader = reader
.reborrow()
.get_node_info()
.map_err(map_error_capnp_error!())?;
.map_err(RPCError::protocol)?;
let node_info = decode_node_info(&ni_reader, allow_relay_peer_info)?;
let sig_reader = reader
.reborrow()
.get_signature()
.map_err(map_error_capnp_error!())?;
.map_err(RPCError::protocol)?;
let signature = decode_signature(&sig_reader);
let timestamp = reader.reborrow().get_timestamp();
SignedNodeInfo::new(node_info, NodeId::new(*node_id), signature, timestamp)
.map_err(map_error_string!())
.map_err(RPCError::protocol)
}
veilid-core/src/rpc_processor/coders/socket_address.rs
+1 -1
View File
@@ -17,7 +17,7 @@ pub fn decode_socket_address(
let ar = reader
.reborrow()
.get_address()
.map_err(map_error_internal!("missing socketAddress"))?;
.map_err(RPCError::map_internal("missing socketAddress"))?;
let address = decode_address(&ar)?;
let port = reader.get_port();
veilid-core/src/rpc_processor/coders/tunnel.rs
+5 -5
View File
@@ -46,10 +46,10 @@ pub fn encode_tunnel_endpoint(
pub fn decode_tunnel_endpoint(
reader: &veilid_capnp::tunnel_endpoint::Reader,
) -> Result<TunnelEndpoint, RPCError> {
let mode = decode_tunnel_mode(reader.get_mode().map_err(map_error_capnp_notinschema!())?);
let mode = decode_tunnel_mode(reader.get_mode().map_err(RPCError::protocol)?);
let description = reader
.get_description()
.map_err(map_error_capnp_error!())?
.map_err(RPCError::protocol)?
.to_owned();
Ok(TunnelEndpoint { mode, description })
@@ -73,9 +73,9 @@ pub fn decode_full_tunnel(
) -> Result<FullTunnel, RPCError> {
let id = reader.get_id();
let timeout = reader.get_timeout();
let l_reader = reader.get_local().map_err(map_error_capnp_error!())?;
let l_reader = reader.get_local().map_err(RPCError::protocol)?;
let local = decode_tunnel_endpoint(&l_reader)?;
let r_reader = reader.get_remote().map_err(map_error_capnp_error!())?;
let r_reader = reader.get_remote().map_err(RPCError::protocol)?;
let remote = decode_tunnel_endpoint(&r_reader)?;
Ok(FullTunnel {
@@ -102,7 +102,7 @@ pub fn decode_partial_tunnel(
) -> Result<PartialTunnel, RPCError> {
let id = reader.get_id();
let timeout = reader.get_timeout();
let l_reader = reader.get_local().map_err(map_error_capnp_error!())?;
let l_reader = reader.get_local().map_err(RPCError::protocol)?;
let local = decode_tunnel_endpoint(&l_reader)?;
Ok(PartialTunnel { id, timeout, local })
veilid-core/src/rpc_processor/coders/value_data.rs
+1 -4
View File
@@ -11,10 +11,7 @@ pub fn encode_value_data(
}
pub fn decode_value_data(reader: &veilid_capnp::value_data::Reader) -> Result<ValueData, RPCError> {
let data = reader
.get_data()
.map_err(map_error_capnp_error!())?
.to_vec();
let data = reader.get_data().map_err(RPCError::protocol)?.to_vec();
let seq = reader.get_seq();
Ok(ValueData { data, seq })
}
veilid-core/src/rpc_processor/coders/value_key.rs
+2 -2
View File
@@ -14,12 +14,12 @@ pub fn encode_value_key(
}
pub fn decode_value_key(reader: &veilid_capnp::value_key::Reader) -> Result<ValueKey, RPCError> {
let pk_reader = reader.get_public_key().map_err(map_error_capnp_error!())?;
let pk_reader = reader.get_public_key().map_err(RPCError::protocol)?;
let key = decode_public_key(&pk_reader);
let subkey = if !reader.has_subkey() {
None
} else {
let subkey = reader.get_subkey().map_err(map_error_capnp_error!())?;
let subkey = reader.get_subkey().map_err(RPCError::protocol)?;
Some(subkey.to_owned())
};
Ok(ValueKey { key, subkey })
veilid-core/src/rpc_processor/debug.rs
-92
View File
@@ -1,92 +0,0 @@
use super::*;
#[derive(Debug, Clone, PartialOrd, PartialEq, Eq, Ord)]
pub enum RPCError {
Timeout,
InvalidFormat(String),
Unreachable(DHTKey),
Unimplemented(String),
Protocol(String),
Internal(String),
}
pub fn rpc_error_internal<T: ToString>(x: T) -> RPCError {
let x = x.to_string();
error!("RPCError Internal: {}", x);
RPCError::Internal(x)
}
pub fn rpc_error_invalid_format<T: ToString>(x: T) -> RPCError {
let x = x.to_string();
error!("RPCError Invalid Format: {}", x);
RPCError::InvalidFormat(x)
}
pub fn rpc_error_protocol<T: ToString>(x: T) -> RPCError {
let x = x.to_string();
error!("RPCError Protocol: {}", x);
RPCError::Protocol(x)
}
pub fn rpc_error_capnp_error(e: capnp::Error) -> RPCError {
error!("RPCError Protocol: capnp error: {}", &e.description);
RPCError::Protocol(e.description)
}
pub fn rpc_error_capnp_notinschema(e: capnp::NotInSchema) -> RPCError {
error!("RPCError Protocol: not in schema: {}", &e.0);
RPCError::Protocol(format!("not in schema: {}", &e.0))
}
pub fn rpc_error_unimplemented<T: ToString>(x: T) -> RPCError {
let x = x.to_string();
error!("RPCError Unimplemented: {}", x);
RPCError::Unimplemented(x)
}
impl fmt::Display for RPCError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
RPCError::Timeout => write!(f, "[RPCError: Timeout]"),
RPCError::InvalidFormat(s) => write!(f, "[RPCError: InvalidFormat({})]", s),
RPCError::Unreachable(k) => write!(f, "[RPCError: Unreachable({})]", k),
RPCError::Unimplemented(s) => write!(f, "[RPCError: Unimplemented({})]", s),
RPCError::Protocol(s) => write!(f, "[RPCError: Protocol({})]", s),
RPCError::Internal(s) => write!(f, "[RPCError: Internal({})]", s),
}
}
}
#[macro_export]
macro_rules! map_error_internal {
($x:expr) => {
|_| rpc_error_internal($x)
};
}
#[macro_export]
macro_rules! map_error_protocol {
($x:expr) => {
|_| rpc_error_protocol($x)
};
}
#[macro_export]
macro_rules! map_error_string {
() => {
|s| rpc_error_internal(&s)
};
}
#[macro_export]
macro_rules! map_error_capnp_error {
() => {
|e| rpc_error_capnp_error(e)
};
}
#[macro_export]
macro_rules! map_error_capnp_notinschema {
() => {
|e| rpc_error_capnp_notinschema(e)
};
}
#[macro_export]
macro_rules! map_error_panic {
() => {
|_| panic!("oops")
};
}
veilid-core/src/rpc_processor/mod.rs
+33 -31
View File
@@ -1,8 +1,8 @@
mod coders;
mod debug;
mod private_route;
mod rpc_cancel_tunnel;
mod rpc_complete_tunnel;
mod rpc_error;
mod rpc_find_block;
mod rpc_find_node;
mod rpc_get_value;
@@ -18,8 +18,8 @@ mod rpc_validate_dial_info;
mod rpc_value_changed;
mod rpc_watch_value;
pub use debug::*;
pub use private_route::*;
pub use rpc_error::*;
use super::*;
use crate::dht::*;
@@ -101,21 +101,22 @@ where
let wordvec = builder
.into_reader()
.canonicalize()
.map_err(map_error_capnp_error!())
.map_err(logthru_rpc!())?;
Ok(capnp::Word::words_to_bytes(wordvec.as_slice()).to_vec())
}
fn reader_to_vec<'a, T>(reader: &capnp::message::Reader<T>) -> Result<Vec<u8>, RPCError>
where
T: capnp::message::ReaderSegments + 'a,
{
let wordvec = reader
.canonicalize()
.map_err(map_error_capnp_error!())
.map_err(RPCError::protocol)
.map_err(logthru_rpc!())?;
Ok(capnp::Word::words_to_bytes(wordvec.as_slice()).to_vec())
}
// fn reader_to_vec<'a, T>(reader: &capnp::message::Reader<T>) -> Result<Vec<u8>, RPCError>
// where
// T: capnp::message::ReaderSegments + 'a,
// {
// let wordvec = reader
// .canonicalize()
// .map_err(RPCError::protocol)
// .map_err(logthru_rpc!())?;
// Ok(capnp::Word::words_to_bytes(wordvec.as_slice()).to_vec())
// }
#[derive(Debug)]
struct WaitableReply {
op_id: OperationId,
@@ -243,16 +244,16 @@ 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
pub async fn search_dht_single_key(
&self,
node_id: DHTKey,
_node_id: DHTKey,
_count: u32,
_fanout: u32,
_timeout: Option<u64>,
) -> Result<NodeRef, RPCError> {
let routing_table = self.routing_table();
//let routing_table = self.routing_table();
// xxx find node but stop if we find the exact node we want
// xxx return whatever node is closest after the timeout
Err(rpc_error_unimplemented("search_dht_single_key")).map_err(logthru_rpc!(error))
Err(RPCError::unimplemented("search_dht_single_key")).map_err(logthru_rpc!(error))
}
// Search the DHT for the 'count' closest nodes to a key, adding them all to the routing table if they are not there and returning their node references
@@ -264,7 +265,7 @@ impl RPCProcessor {
_timeout: Option<u64>,
) -> Result<Vec<NodeRef>, RPCError> {
// xxx return closest nodes after the timeout
Err(rpc_error_unimplemented("search_dht_multi_key")).map_err(logthru_rpc!(error))
Err(RPCError::unimplemented("search_dht_multi_key")).map_err(logthru_rpc!(error))
}
// Search the DHT for a specific node corresponding to a key unless we have that node in our routing table already, and return the node reference
@@ -328,7 +329,7 @@ impl RPCProcessor {
inner
.waiting_rpc_table
.remove(&op_id)
.ok_or_else(|| rpc_error_internal("Unmatched operation id"))?
.ok_or_else(RPCError::else_internal("Unmatched operation id"))?
};
eventual.resolve(msg).await;
Ok(())
@@ -340,7 +341,7 @@ impl RPCProcessor {
waitable_reply: &WaitableReply,
) -> Result<(RPCMessage, u64), RPCError> {
let timeout_ms = u32::try_from(waitable_reply.timeout / 1000u64)
.map_err(map_error_internal!("invalid timeout"))?;
.map_err(RPCError::map_internal("invalid timeout"))?;
// wait for eventualvalue
let start_ts = intf::get_timestamp();
let res = intf::timeout(timeout_ms, waitable_reply.eventual.instance())
@@ -459,7 +460,7 @@ impl RPCProcessor {
out_node_id = sr
.hops
.first()
.ok_or_else(|| rpc_error_internal("no hop in safety route"))?
.ok_or_else(RPCError::else_internal("no hop in safety route"))?
.dial_info
.node_id
.key;
@@ -478,7 +479,7 @@ impl RPCProcessor {
out_hop_count = private_route.hop_count as usize;
let out_node_id = match &private_route.hops {
Some(rh) => rh.dial_info.node_id.key,
_ => return Err(rpc_error_internal("private route has no hops")),
_ => return Err(RPCError::internal("private route has no hops")),
};
out_message = self.wrap_with_route(None, private_route, message_vec)?;
out_node_id
@@ -489,7 +490,7 @@ impl RPCProcessor {
let out_node_id = sr
.hops
.first()
.ok_or_else(|| rpc_error_internal("no hop in safety route"))?
.ok_or_else(RPCError::else_internal("no hop in safety route"))?
.dial_info
.node_id
.key;
@@ -502,7 +503,7 @@ impl RPCProcessor {
// Verify hop count isn't larger than out maximum routed hop count
if out_hop_count > self.inner.lock().max_route_hop_count {
return Err(rpc_error_internal("hop count too long for route"))
return Err(RPCError::internal("hop count too long for route"))
.map_err(logthru_rpc!(warn));
}
@@ -565,7 +566,7 @@ impl RPCProcessor {
.network_manager()
.send_envelope(node_ref.clone(), Some(node_id), message)
.await
.map_err(RPCError::Internal)
.map_err(RPCError::internal)
{
Ok(v) => v,
Err(e) => {
@@ -637,7 +638,7 @@ impl RPCProcessor {
.network_manager()
.send_envelope(node_ref.clone(), Some(node_id), message)
.await
.map_err(RPCError::Internal)
.map_err(RPCError::network)
{
Ok(v) => v,
Err(e) => {
@@ -729,7 +730,7 @@ impl RPCProcessor {
self.network_manager()
.send_envelope(node_ref.clone(), Some(node_id), message)
.await
.map_err(RPCError::Internal)
.map_err(RPCError::network)
.map_err(|e| {
self.routing_table()
.stats_failed_to_send(node_ref.clone(), send_ts, false);
@@ -763,7 +764,7 @@ impl RPCProcessor {
let reader = capnp::message::Reader::new(encoded_msg.data, Default::default());
let op_reader = reader
.get_root::<veilid_capnp::operation::Reader>()
.map_err(map_error_capnp_error!())
.map_err(RPCError::protocol)
.map_err(logthru_rpc!())?;
RPCOperation::decode(&op_reader, &sender_node_id)?
};
@@ -776,13 +777,14 @@ impl RPCProcessor {
RespondTo::Sender(Some(sender_ni)) => {
// Sender NodeInfo was specified, update our routing table with it
if !self.filter_peer_scope(&sender_ni.node_info) {
return Err(rpc_error_invalid_format(
return Err(RPCError::invalid_format(
"respond_to_sender_signed_node_info has invalid peer scope",
));
}
let nr = self
.routing_table()
.register_node_with_signed_node_info(sender_node_id, sender_ni.clone())
.map_err(map_to_string)
.map_err(RPCError::Internal)?;
opt_sender_nr = Some(nr);
}
@@ -883,7 +885,7 @@ impl RPCProcessor {
}
#[instrument(level = "debug", skip_all, err)]
pub async fn startup(&self) -> Result<(), String> {
pub async fn startup(&self) -> EyreResult<()> {
trace!("startup rpc processor");
let mut inner = self.inner.lock();
// make local copy of node id for easy access
@@ -966,7 +968,7 @@ impl RPCProcessor {
envelope: Envelope,
body: Vec<u8>,
peer_noderef: NodeRef,
) -> Result<(), String> {
) -> EyreResult<()> {
let msg = RPCMessageEncoded {
header: RPCMessageHeader {
timestamp: intf::get_timestamp(),
@@ -982,7 +984,7 @@ impl RPCProcessor {
};
send_channel
.try_send(msg)
.map_err(|e| format!("failed to enqueue received RPC message: {:?}", e))?;
.wrap_err("failed to enqueue received RPC message")?;
Ok(())
}
}
veilid-core/src/rpc_processor/private_route.rs
+7 -7
View File
@@ -12,7 +12,7 @@ impl RPCProcessor {
let sr_hopcount = safety_route_spec.hops.len();
let hopcount = 1 + sr_hopcount + pr_hopcount;
if hopcount > self.inner.lock().max_route_hop_count {
return Err(rpc_error_internal("hop count too long for route"));
return Err(RPCError::internal("hop count too long for route"));
}
// Create hops
@@ -47,10 +47,10 @@ impl RPCProcessor {
&safety_route_spec.hops[h].dial_info.node_id.key,
&safety_route_spec.secret_key,
)
.map_err(map_error_internal!("dh failed"))?;
.map_err(RPCError::map_internal("dh failed"))?;
let enc_msg_data =
Crypto::encrypt_aead(blob_data.as_slice(), &nonce, &dh_secret, None)
.map_err(map_error_internal!("encryption failed"))?;
.map_err(RPCError::map_internal("encryption failed"))?;
// Make route hop data
let route_hop_data = RouteHopData {
@@ -86,9 +86,9 @@ impl RPCProcessor {
&safety_route_spec.hops[0].dial_info.node_id.key,
&safety_route_spec.secret_key,
)
.map_err(map_error_internal!("dh failed"))?;
.map_err(RPCError::map_internal("dh failed"))?;
let enc_msg_data = Crypto::encrypt_aead(blob_data.as_slice(), &nonce, &dh_secret, None)
.map_err(map_error_internal!("encryption failed"))?;
.map_err(RPCError::map_internal("encryption failed"))?;
let route_hop_data = RouteHopData {
nonce,
@@ -123,9 +123,9 @@ impl RPCProcessor {
let dh_secret = self
.crypto
.cached_dh(&private_route.public_key, &safety_route_spec.secret_key)
.map_err(map_error_internal!("dh failed"))?;
.map_err(RPCError::map_internal("dh failed"))?;
let enc_msg_data = Crypto::encrypt_aead(&message_data, &nonce, &dh_secret, None)
.map_err(map_error_internal!("encryption failed"))?;
.map_err(RPCError::map_internal("encryption failed"))?;
// Compile the safety route with the private route
let safety_route = self.compile_safety_route(safety_route_spec, private_route)?;
veilid-core/src/rpc_processor/rpc_cancel_tunnel.rs
+1 -1
View File
@@ -2,6 +2,6 @@ use super::*;
impl RPCProcessor {
pub(crate) async fn process_cancel_tunnel_q(&self, msg: RPCMessage) -> Result<(), RPCError> {
Err(rpc_error_unimplemented("process_cancel_tunnel_q"))
Err(RPCError::unimplemented("process_cancel_tunnel_q"))
}
}
veilid-core/src/rpc_processor/rpc_complete_tunnel.rs
+1 -1
View File
@@ -2,6 +2,6 @@ use super::*;
impl RPCProcessor {
pub(crate) async fn process_complete_tunnel_q(&self, msg: RPCMessage) -> Result<(), RPCError> {
Err(rpc_error_unimplemented("process_complete_tunnel_q"))
Err(RPCError::unimplemented("process_complete_tunnel_q"))
}
}
veilid-core/src/rpc_processor/rpc_error.rs
+58
View File
@@ -0,0 +1,58 @@
use super::*;
#[derive(ThisError, Debug, Clone, PartialOrd, PartialEq, Eq, Ord)]
pub enum RPCError {
#[error("[RPCError: Timeout]")]
Timeout,
#[error("[RPCError: Unreachable({0})]")]
Unreachable(DHTKey),
#[error("[RPCError: Unimplemented({0})]")]
Unimplemented(String),
#[error("[RPCError: InvalidFormat({0})]")]
InvalidFormat(String),
#[error("[RPCError: Protocol({0})]")]
Protocol(String),
#[error("[RPCError: Internal({0})]")]
Internal(String),
#[error("[RPCError: Network({0})]")]
Network(String),
}
impl RPCError {
pub fn timeout() -> Self {
Self::Timeout
}
pub fn unreachable(key: DHTKey) -> Self {
Self::Unreachable(key)
}
pub fn unimplemented<X: ToString>(x: X) -> Self {
Self::Unimplemented(x.to_string())
}
pub fn invalid_format<X: ToString>(x: X) -> Self {
Self::InvalidFormat(x.to_string())
}
pub fn map_invalid_format<M: ToString, X: ToString>(message: M) -> impl FnOnce(X) -> Self {
move |x| Self::InvalidFormat(format!("{}: {}", message.to_string(), x.to_string()))
}
pub fn protocol<X: ToString>(x: X) -> Self {
Self::Protocol(x.to_string())
}
pub fn map_protocol<M: ToString, X: ToString>(message: M) -> impl FnOnce(X) -> Self {
move |x| Self::Protocol(format!("{}: {}", message.to_string(), x.to_string()))
}
pub fn internal<X: ToString>(x: X) -> Self {
Self::Internal(x.to_string())
}
pub fn map_internal<M: ToString, X: ToString>(message: M) -> impl FnOnce(X) -> Self {
move |x| Self::Internal(format!("{}: {}", message.to_string(), x.to_string()))
}
pub fn else_internal<M: ToString>(message: M) -> impl FnOnce() -> Self {
move || Self::Internal(format!("{}", message.to_string()))
}
pub fn network<X: ToString>(x: X) -> Self {
Self::Network(x.to_string())
}
pub fn map_network<M: ToString, X: ToString>(message: M) -> impl FnOnce(X) -> Self {
move |x| Self::Network(format!("{}: {}", message.to_string(), x.to_string()))
}
}
veilid-core/src/rpc_processor/rpc_find_block.rs
+1 -1
View File
@@ -2,6 +2,6 @@ use super::*;
impl RPCProcessor {
pub(crate) async fn process_find_block_q(&self, msg: RPCMessage) -> Result<(), RPCError> {
Err(rpc_error_unimplemented("process_find_block_q"))
Err(RPCError::unimplemented("process_find_block_q"))
}
}
veilid-core/src/rpc_processor/rpc_find_node.rs
+3 -3
View File
@@ -23,15 +23,15 @@ impl RPCProcessor {
let find_node_a = match msg.operation.into_kind() {
RPCOperationKind::Answer(a) => match a.into_detail() {
RPCAnswerDetail::FindNodeA(a) => a,
_ => return Err(rpc_error_invalid_format("not a find_node answer")),
_ => return Err(RPCError::invalid_format("not a find_node answer")),
},
_ => return Err(rpc_error_invalid_format("not an answer")),
_ => return Err(RPCError::invalid_format("not an answer")),
};
// Verify peers are in the correct peer scope
for peer_info in &find_node_a.peers {
if !self.filter_peer_scope(&peer_info.signed_node_info.node_info) {
return Err(rpc_error_invalid_format(
return Err(RPCError::invalid_format(
"find_node response has invalid peer scope",
));
}
veilid-core/src/rpc_processor/rpc_get_value.rs
+1 -1
View File
@@ -2,6 +2,6 @@ use super::*;
impl RPCProcessor {
pub(crate) async fn process_get_value_q(&self, msg: RPCMessage) -> Result<(), RPCError> {
Err(rpc_error_unimplemented("process_get_value_q"))
Err(RPCError::unimplemented("process_get_value_q"))
}
}
veilid-core/src/rpc_processor/rpc_node_info_update.rs
+2 -1
View File
@@ -32,13 +32,14 @@ impl RPCProcessor {
// Update our routing table with signed node info
if !self.filter_peer_scope(&node_info_update.signed_node_info.node_info) {
return Err(rpc_error_invalid_format(
return Err(RPCError::invalid_format(
"node_info_update has invalid peer scope",
));
}
let _ = self
.routing_table()
.register_node_with_signed_node_info(sender_node_id, node_info_update.signed_node_info)
.map_err(map_to_string)
.map_err(RPCError::Internal)?;
Ok(())
veilid-core/src/rpc_processor/rpc_return_receipt.rs
+1 -1
View File
@@ -35,6 +35,6 @@ impl RPCProcessor {
network_manager
.handle_in_band_receipt(receipt, msg.header.peer_noderef)
.await
.map_err(map_error_string!())
.map_err(RPCError::network)
}
}
veilid-core/src/rpc_processor/rpc_route.rs
+1 -1
View File
@@ -5,6 +5,6 @@ impl RPCProcessor {
pub(crate) async fn process_route(&self, _rpcreader: RPCMessage) -> Result<(), RPCError> {
// xxx do not process latency for routed messages
Err(rpc_error_unimplemented("process_route"))
Err(RPCError::unimplemented("process_route"))
}
}
veilid-core/src/rpc_processor/rpc_set_value.rs
+1 -1
View File
@@ -2,6 +2,6 @@ use super::*;
impl RPCProcessor {
pub(crate) async fn process_set_value_q(&self, msg: RPCMessage) -> Result<(), RPCError> {
Err(rpc_error_unimplemented("process_set_value_q"))
Err(RPCError::unimplemented("process_set_value_q"))
}
}
veilid-core/src/rpc_processor/rpc_signal.rs
+1 -1
View File
@@ -34,6 +34,6 @@ impl RPCProcessor {
network_manager
.handle_signal(signal.signal_info)
.await
.map_err(map_error_string!())
.map_err(RPCError::network)
}
}
veilid-core/src/rpc_processor/rpc_start_tunnel.rs
+1 -1
View File
@@ -2,6 +2,6 @@ use super::*;
impl RPCProcessor {
pub(crate) async fn process_start_tunnel_q(&self, msg: RPCMessage) -> Result<(), RPCError> {
Err(rpc_error_unimplemented("process_start_tunnel_q"))
Err(RPCError::unimplemented("process_start_tunnel_q"))
}
}
veilid-core/src/rpc_processor/rpc_status.rs
+2 -2
View File
@@ -24,9 +24,9 @@ impl RPCProcessor {
let status_a = match msg.operation.into_kind() {
RPCOperationKind::Answer(a) => match a.into_detail() {
RPCAnswerDetail::StatusA(a) => a,
_ => return Err(rpc_error_invalid_format("not a status answer")),
_ => return Err(RPCError::invalid_format("not a status answer")),
},
_ => return Err(rpc_error_invalid_format("not an answer")),
_ => return Err(RPCError::invalid_format("not an answer")),
};
// Update latest node status in routing table
veilid-core/src/rpc_processor/rpc_supply_block.rs
+1 -1
View File
@@ -2,6 +2,6 @@ use super::*;
impl RPCProcessor {
pub(crate) async fn process_supply_block_q(&self, msg: RPCMessage) -> Result<(), RPCError> {
Err(rpc_error_unimplemented("process_supply_block_q"))
Err(RPCError::unimplemented("process_supply_block_q"))
}
}
veilid-core/src/rpc_processor/rpc_validate_dial_info.rs
+5 -8
View File
@@ -20,7 +20,7 @@ impl RPCProcessor {
// Generate receipt and waitable eventual so we can see if we get the receipt back
let (receipt, eventual_value) = network_manager
.generate_single_shot_receipt(receipt_time, [])
.map_err(map_error_string!())?;
.map_err(RPCError::internal)?;
let validate_dial_info = RPCOperationValidateDialInfo {
dial_info,
@@ -36,7 +36,7 @@ impl RPCProcessor {
// Wait for receipt
match eventual_value.await.take_value().unwrap() {
ReceiptEvent::ReturnedInBand { inbound_noderef: _ } => Err(rpc_error_internal(
ReceiptEvent::ReturnedInBand { inbound_noderef: _ } => Err(RPCError::internal(
"validate_dial_info receipt should be returned out-of-band",
)),
ReceiptEvent::ReturnedOutOfBand => {
@@ -48,7 +48,7 @@ impl RPCProcessor {
Ok(false)
}
ReceiptEvent::Cancelled => {
Err(rpc_error_internal("receipt was dropped before expiration"))
Err(RPCError::internal("receipt was dropped before expiration"))
}
}
}
@@ -82,7 +82,7 @@ impl RPCProcessor {
};
let peers = routing_table.find_fast_public_nodes_filtered(node_count, &filter);
if peers.is_empty() {
return Err(rpc_error_internal(format!(
return Err(RPCError::internal(format!(
"no peers matching filter '{:?}'",
filter
)));
@@ -148,10 +148,7 @@ impl RPCProcessor {
network_manager
.send_out_of_band_receipt(dial_info.clone(), receipt)
.await
.map_err(map_error_string!())
.map_err(
logthru_net!(error "failed to send direct receipt to dial info: {}", dial_info),
)?;
.map_err(RPCError::network)?;
Ok(())
}
veilid-core/src/rpc_processor/rpc_value_changed.rs
+1 -1
View File
@@ -2,6 +2,6 @@ use super::*;
impl RPCProcessor {
pub(crate) async fn process_value_changed(&self, msg: RPCMessage) -> Result<(), RPCError> {
Err(rpc_error_unimplemented("process_value_changed"))
Err(RPCError::unimplemented("process_value_changed"))
}
}
veilid-core/src/rpc_processor/rpc_watch_value.rs
+1 -1
View File
@@ -2,6 +2,6 @@ use super::*;
impl RPCProcessor {
pub(crate) async fn process_watch_value_q(&self, msg: RPCMessage) -> Result<(), RPCError> {
Err(rpc_error_unimplemented("process_watch_value_q"))
Err(RPCError::unimplemented("process_watch_value_q"))
}
}