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

checkpoint

Browse Source
This commit is contained in:
John Smith 2022-07-03 15:52:27 -04:00
parent 6d1198cd92
commit b010c8a61f
17 changed files with 940 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
veilid-core/proto/veilid.capnp
View File

@ -162,10 +162,10 @@ struct ValueKey {
subkey @1 :Text; # the name of the subkey (or empty if the whole key)
}
struct ValueKeySeq {
key @0 :ValueKey; # the location of the value
seq @1 :ValueSeqNum; # the sequence number of the value subkey
}
# struct ValueKeySeq {
# key @0 :ValueKey; # the location of the value
# seq @1 :ValueSeqNum; # the sequence number of the value subkey
# }
struct ValueData {
data @0 :Data; # value or subvalue contents in CBOR format

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

@ -7,6 +7,7 @@ mod node_dial_info;
mod node_info;
mod node_status;
mod nonce;
mod operations;
mod peer_info;
mod private_safety_route;
mod protocol_set;
@ -16,6 +17,8 @@ mod signal_info;
mod signature;
mod signed_node_info;
mod socket_address;
mod value_data;
mod value_key;
pub use address::*;
pub use dial_info::*;
@ -26,6 +29,7 @@ pub use node_dial_info::*;
pub use node_info::*;
pub use node_status::*;
pub use nonce::*;
pub use operations::*;
pub use peer_info::*;
pub use private_safety_route::*;
pub use protocol_set::*;
@ -35,5 +39,7 @@ pub use signal_info::*;
pub use signature::*;
pub use signed_node_info::*;
pub use socket_address::*;
pub use value_data::*;
pub use value_key::*;
use super::*;

22
veilid-core/src/rpc_processor/coders/operations/mod.rs Normal file
View File

@ -0,0 +1,22 @@
mod operation;
mod operation_detail;
mod operation_find_node;
mod operation_get_value;
mod operation_node_info_update;
mod operation_route;
mod operation_status;
mod operation_validate_dial_info;
mod respond_to;
use super::*;
pub use operation::*;
pub use operation_detail::*;
pub use operation_find_node::*;
pub use operation_get_value::*;
pub use operation_node_info_update::*;
pub use operation_route::*;
pub use operation_status::*;
pub use operation_validate_dial_info::*;
pub use respond_to::*;

98
veilid-core/src/rpc_processor/coders/operations/operation.rs Normal file
View File

@ -0,0 +1,98 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
struct RPCOperation {
op_id: u64,
// index: u32,
// is_q: bool,
// wants_answer: bool,
respond_to: RespondTo,
detail: RPCOperationDetail,
}
impl RPCOperation {
pub fn decode(
operation_reader: &veilid_capnp::operation::Reader,
sender_node_id: &DHTKey,
) -> Result<Self, RPCError> {
let op_id = operation_reader.get_op_id();
let respond_to_reader = operation_reader.get_respond_to();
let respond_to = RespondTo::decode(&respond_to_reader, sender_node_id)?;
let detail_reader = operation_reader.get_detail();
let detail = RPCOperationDetail::decode(&detail_reader, sender_node_id)?;
Ok(RPCOperation {
op_id,
respond_to,
detail,
})
}
pub fn encode(&self, builder: &mut veilid_capnp::operation::Builder) -> Result<(), RPCError> {
builder.set_op_id(self.op_id);
let rt_builder = builder.init_respond_to();
self.respond_to.encode(&mut rt_builder)?;
let d_builder = builder.init_detail();
self.detail.encode(&mut d_builder)?;
Ok(())
}
}
// let out = match which_reader {
// veilid_capnp::operation::detail::StatusQ(_) => Self { name: "StatusQ", op_id, index: 0, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::StatusA(_) => Self { name: "StatusA", op_id, index: 1, is_q: false, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::ValidateDialInfo(_) => Self { name: "ValidateDialInfo", op_id, index: 2, is_q: true, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::FindNodeQ(_) => Self { name: "FindNodeQ", op_id, index: 3, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::FindNodeA(_) => Self { name: "FindNodeA", op_id, index: 4, is_q: false, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::Route(_) => Self { name: "Route", op_id, index: 5, is_q: true, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::NodeInfoUpdate(_) => Self { name: "NodeInfoUpdate", op_id, index: 6, is_q: true, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::GetValueQ(_) => Self { name: "GetValueQ", op_id, index: 7, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::GetValueA(_) => Self { name: "GetValueA", op_id, index: 8, is_q: false, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::SetValueQ(_) => Self { name: "SetValueQ", op_id, index: 9, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::SetValueA(_) => Self { name: "SetValueA", op_id, index: 10, is_q: false, wants_answer: false, respond_to},
// veilid_capnp::operation::detail::WatchValueQ(_) => Self { name: "WatchValueQ", op_id, index: 11, is_q: true, wants_answer: true, respond_to},
// veilid_capnp::operation::detail::WatchValueA(_) => Self { name: "WatchValueA", op_id, index: 12, is_q: false, wants_answer: false, respond_to},
// veilid_capnp::operation::detail::ValueChanged(_) => Self { name: "ValueChanged", op_id, index: 13, is_q: true, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::SupplyBlockQ(_) => Self { name: "SupplyBlockQ", op_id, index: 14, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::SupplyBlockA(_) => Self { name: "SupplyBlockA", op_id, index: 15, is_q: false, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::FindBlockQ(_) => Self { name: "FindBlockQ", op_id, index: 16, is_q: true, wants_answer: true, respond_to},
// veilid_capnp::operation::detail::FindBlockA(_) =>Self { name: "FindBlockA", op_id, index: 17, is_q: false, wants_answer: false, respond_to},
// veilid_capnp::operation::detail::Signal(_) => Self { name: "Signal", op_id, index: 18, is_q: true, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::ReturnReceipt(_) => Self { name: "ReturnReceipt", op_id, index: 19, is_q: true, wants_answer: false, respond_to},
// veilid_capnp::operation::detail::StartTunnelQ(_) => Self { name: "StartTunnelQ", op_id, index: 20, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::StartTunnelA(_) => Self { name: "StartTunnelA", op_id, index: 21, is_q: false, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::CompleteTunnelQ(_) =>Self { name: "CompleteTunnelQ", op_id, index: 22, is_q: true, wants_answer: true, respond_to},
// veilid_capnp::operation::detail::CompleteTunnelA(_) => Self { name: "CompleteTunnelA", op_id, index: 23, is_q: false, wants_answer: false, respond_to},
// veilid_capnp::operation::detail::CancelTunnelQ(_) => Self { name: "CancelTunnelQ", op_id, index: 24, is_q: true, wants_answer: true, respond_to},
// veilid_capnp::operation::detail::CancelTunnelA(_) => Self { name: "CancelTunnelA", op_id, index: 25, is_q: false, wants_answer: false, respond_to},
// };
// veilid_capnp::operation::detail::StatusQ(_) => Self { name: "StatusQ", op_id, index: 0, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::StatusA(_) => Self { name: "StatusA", op_id, index: 1, is_q: false, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::ValidateDialInfo(_) => Self { name: "ValidateDialInfo", op_id, index: 2, is_q: true, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::FindNodeQ(_) => Self { name: "FindNodeQ", op_id, index: 3, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::FindNodeA(_) => Self { name: "FindNodeA", op_id, index: 4, is_q: false, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::Route(_) => Self { name: "Route", op_id, index: 5, is_q: true, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::NodeInfoUpdate(_) => Self { name: "NodeInfoUpdate", op_id, index: 6, is_q: true, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::GetValueQ(_) => Self { name: "GetValueQ", op_id, index: 7, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::GetValueA(_) => Self { name: "GetValueA", op_id, index: 8, is_q: false, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::SetValueQ(_) => Self { name: "SetValueQ", op_id, index: 9, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::SetValueA(_) => Self { name: "SetValueA", op_id, index: 10, is_q: false, wants_answer: false, respond_to},
// veilid_capnp::operation::detail::WatchValueQ(_) => Self { name: "WatchValueQ", op_id, index: 11, is_q: true, wants_answer: true, respond_to},
// veilid_capnp::operation::detail::WatchValueA(_) => Self { name: "WatchValueA", op_id, index: 12, is_q: false, wants_answer: false, respond_to},
// veilid_capnp::operation::detail::ValueChanged(_) => Self { name: "ValueChanged", op_id, index: 13, is_q: true, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::SupplyBlockQ(_) => Self { name: "SupplyBlockQ", op_id, index: 14, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::SupplyBlockA(_) => Self { name: "SupplyBlockA", op_id, index: 15, is_q: false, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::FindBlockQ(_) => Self { name: "FindBlockQ", op_id, index: 16, is_q: true, wants_answer: true, respond_to},
// veilid_capnp::operation::detail::FindBlockA(_) =>Self { name: "FindBlockA", op_id, index: 17, is_q: false, wants_answer: false, respond_to},
// veilid_capnp::operation::detail::Signal(_) => Self { name: "Signal", op_id, index: 18, is_q: true, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::ReturnReceipt(_) => Self { name: "ReturnReceipt", op_id, index: 19, is_q: true, wants_answer: false, respond_to},
// veilid_capnp::operation::detail::StartTunnelQ(_) => Self { name: "StartTunnelQ", op_id, index: 20, is_q: true, wants_answer: true, respond_to },
// veilid_capnp::operation::detail::StartTunnelA(_) => Self { name: "StartTunnelA", op_id, index: 21, is_q: false, wants_answer: false, respond_to },
// veilid_capnp::operation::detail::CompleteTunnelQ(_) =>Self { name: "CompleteTunnelQ", op_id, index: 22, is_q: true, wants_answer: true, respond_to},
// veilid_capnp::operation::detail::CompleteTunnelA(_) => Self { name: "CompleteTunnelA", op_id, index: 23, is_q: false, wants_answer: false, respond_to},
// veilid_capnp::operation::detail::CancelTunnelQ(_) => Self { name: "CancelTunnelQ", op_id, index: 24, is_q: true, wants_answer: true, respond_to},
// veilid_capnp::operation::detail::CancelTunnelA(_) => Self { name: "CancelTunnelA", op_id, index: 25, is_q: false, wants_answer: false, respond_to},

214
veilid-core/src/rpc_processor/coders/operations/operation_detail.rs Normal file
View File

@ -0,0 +1,214 @@
use super::*;
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub enum RPCOperationDetail {
StatusQ(RPCOperationStatusQ),
StatusA(RPCOperationStatusA),
ValidateDialInfo(RPCOperationValidateDialInfo),
FindNodeQ(RPCOperationFindNodeQ),
FindNodeA(RPCOperationFindNodeA),
Route(RPCOperationRoute),
NodeInfoUpdate(RPCOperationNodeInfoUpdate),
GetValueQ(RPCOperationGetValueQ),
GetValueA(RPCOperationGetValueA),
SetValueQ(RPCOperationSetValueQ),
SetValueA(RPCOperationSetValueA),
WatchValueQ(RPCOperationWatchValueQ),
WatchValueA(RPCOperationWatchValueA),
ValueChanged(RPCOperationValueChanged),
SupplyBlockQ(RPCOperationSupplyBlockQ),
SupplyBlockA(RPCOperationSupplyBlockA),
FindBlockQ(RPCOperationFindBlockQ),
FindBlockA(RPCOperationFindBlockA),
Signal(RPCOperationSignal),
ReturnReceipt(RPCOperationReturnReceipt),
StartTunnelQ(RPCOperationStartTunnelQ),
StartTunnelA(RPCOperationStartTunnelA),
CompleteTunnelQ(RPCOperationCompleteTunnelQ),
CompleteTunnelA(RPCOperationCompleteTunnelA),
CancelTunnelQ(CancelTunnelQ),
CancelTunnelA(CancelTunnelA),
}
impl RPCOperationDetail {
pub fn decode(
reader: &veilid_capnp::operation::detail::Reader,
sender_node_id: &DHTKey,
) -> Result<RPCOperationDetail, RPCError> {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let out = match which_reader {
veilid_capnp::operation::detail::StatusQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationStatusQ::decode(&op_reader)?;
RPCOperationDetail::StatusQ(out)
}
veilid_capnp::operation::detail::StatusA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationStatusA::decode(&op_reader)?;
RPCOperationDetail::StatusA(out)
}
veilid_capnp::operation::detail::ValidateDialInfo(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationValidateDialInfo::decode(&op_reader)?;
RPCOperationDetail::ValidateDialInfo(out)
}
veilid_capnp::operation::detail::FindNodeQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationFindNodeQ::decode(&op_reader)?;
RPCOperationDetail::FindNodeQ(out)
}
veilid_capnp::operation::detail::FindNodeA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationFindNodeA::decode(&op_reader)?;
RPCOperationDetail::FindNodeA(out)
}
veilid_capnp::operation::detail::Route(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationRoute::decode(&op_reader)?;
RPCOperationDetail::Route(out)
}
veilid_capnp::operation::detail::NodeInfoUpdate(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationNodeInfoUpdate::decode(&op_reader, sender_node_id)?;
RPCOperationDetail::NodeInfoUpdate(out)
}
veilid_capnp::operation::detail::GetValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationGetValueQ::decode(&op_reader)?;
RPCOperationDetail::GetValueQ(out)
}
veilid_capnp::operation::detail::GetValueA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationGetValueA::decode(&op_reader)?;
RPCOperationDetail::GetValueA(out)
}
veilid_capnp::operation::detail::SetValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationSetValueQ::decode(&op_reader)?;
RPCOperationDetail::SetValueQ(out)
}
veilid_capnp::operation::detail::SetValueA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationSetValueA::decode(&op_reader)?;
RPCOperationDetail::SetValueA(out)
}
veilid_capnp::operation::detail::WatchValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationWatchValueQ::decode(&op_reader)?;
RPCOperationDetail::WatchValueQ(out)
}
veilid_capnp::operation::detail::WatchValueA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationWatchValueA::decode(&op_reader)?;
RPCOperationDetail::WatchValueA(out)
}
veilid_capnp::operation::detail::ValueChanged(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationValueChanged::decode(&op_reader)?;
RPCOperationDetail::ValueChanged(out)
}
veilid_capnp::operation::detail::SupplyBlockQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationSupplyBlockQ::decode(&op_reader)?;
RPCOperationDetail::SupplyBlockQ(out)
}
veilid_capnp::operation::detail::SupplyBlockA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationSupplyBlockA::decode(&op_reader)?;
RPCOperationDetail::SupplyBlockA(out)
}
veilid_capnp::operation::detail::FindBlockQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationFindBlockQ::decode(&op_reader)?;
RPCOperationDetail::FindBlockQ(out)
}
veilid_capnp::operation::detail::FindBlockA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationFindBlockA::decode(&op_reader)?;
RPCOperationDetail::FindBlockA(out)
}
veilid_capnp::operation::detail::Signal(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationSignal::decode(&op_reader)?;
RPCOperationDetail::Signal(out)
}
veilid_capnp::operation::detail::ReturnReceipt(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationReturnReceipt::decode(&op_reader)?;
RPCOperationDetail::ReturnReceipt(out)
}
veilid_capnp::operation::detail::StartTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationStartTunnelQ::decode(&op_reader)?;
RPCOperationDetail::StartTunnelQ(out)
}
veilid_capnp::operation::detail::StartTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationStartTunnelA::decode(&op_reader)?;
RPCOperationDetail::StartTunnelA(out)
}
veilid_capnp::operation::detail::CompleteTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationCompleteTunnelQ::decode(&op_reader)?;
RPCOperationDetail::CompleteTunnelQ(out)
}
veilid_capnp::operation::detail::CompleteTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationCompleteTunnelA::decode(&op_reader)?;
RPCOperationDetail::CompleteTunnelA(out)
}
veilid_capnp::operation::detail::CancelTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationCancelTunnelQ::decode(&op_reader)?;
RPCOperationDetail::CancelTunnelQ(out)
}
veilid_capnp::operation::detail::CancelTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationCancelTunnelA::decode(&op_reader)?;
RPCOperationDetail::CancelTunnelA(out)
}
};
Ok(out)
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation::detail::Builder,
) -> Result<(), RPCError> {
match self {
RPCOperationDetail::StatusQ(d) => d.encode(&mut builder.init_status_q()),
RPCOperationDetail::StatusA(d) => d.encode(&mut builder.init_status_a()),
RPCOperationDetail::ValidateDialInfo(d) => {
d.encode(&mut builder.init_validate_dial_info())
}
RPCOperationDetail::FindNodeQ(d) => d.encode(&mut builder.init_find_node_q()),
RPCOperationDetail::FindNodeA(d) => d.encode(&mut builder.init_find_node_a()),
RPCOperationDetail::Route(d) => d.encode(&mut builder.init_route()),
RPCOperationDetail::NodeInfoUpdate(d) => d.encode(&mut builder.init_node_info_update()),
RPCOperationDetail::GetValueQ(d) => d.encode(&mut builder.init_get_value_q()),
RPCOperationDetail::GetValueA(d) => d.encode(&mut builder.init_get_value_a()),
RPCOperationDetail::SetValueQ(d) => d.encode(&mut builder.init_set_value_q()),
RPCOperationDetail::SetValueA(d) => d.encode(&mut builder.init_set_value_a()),
RPCOperationDetail::WatchValueQ(d) => d.encode(&mut builder.init_watch_value_q()),
RPCOperationDetail::WatchValueA(d) => d.encode(&mut builder.init_watch_value_a()),
RPCOperationDetail::ValueChanged(d) => d.encode(&mut builder.init_value_changed()),
RPCOperationDetail::SupplyBlockQ(d) => d.encode(&mut builder.init_supply_block_q()),
RPCOperationDetail::SupplyBlockA(d) => d.encode(&mut builder.init_supply_block_a()),
RPCOperationDetail::FindBlockQ(d) => d.encode(&mut builder.init_find_block_q()),
RPCOperationDetail::FindBlockA(d) => d.encode(&mut builder.init_find_block_a()),
RPCOperationDetail::Signal(d) => d.encode(&mut builder.init_signal()),
RPCOperationDetail::ReturnReceipt(d) => d.encode(&mut builder.init_return_receipt()),
RPCOperationDetail::StartTunnelQ(d) => d.encode(&mut builder.init_start_tunnel_q()),
RPCOperationDetail::StartTunnelA(d) => d.encode(&mut builder.init_start_tunnel_a()),
RPCOperationDetail::CompleteTunnelQ(d) => {
d.encode(&mut builder.init_complete_tunnel_q())
}
RPCOperationDetail::CompleteTunnelA(d) => {
d.encode(&mut builder.init_complete_tunnel_a())
}
RPCOperationDetail::CancelTunnelQ(d) => d.encode(&mut builder.init_cancel_tunnel_q()),
RPCOperationDetail::CancelTunnelA(d) => d.encode(&mut builder.init_cancel_tunnel_a()),
}
}
}

66
veilid-core/src/rpc_processor/coders/operations/operation_find_node.rs Normal file
View File

@ -0,0 +1,66 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCOperationFindNodeQ {
node_id: DHTKey,
}
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 node_id = decode_public_key(&ni_reader);
Ok(RPCOperationFindNodeQ { node_id })
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_find_node_q::Builder,
) -> Result<(), RPCError> {
let ni_builder = builder.init_node_id();
encode_public_key(&self.node_id, &mut ni_builder)?;
Ok(())
}
}
#[derive(Debug, Clone)]
pub struct RPCOperationFindNodeA {
peers: Vec<PeerInfo>,
}
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 mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
peers.push(peer_info);
}
Ok(RPCOperationFindNodeA { peers })
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_find_node_a::Builder,
) -> Result<(), RPCError> {
let mut peers_builder = builder.init_peers(
self.peers
.len()
.try_into()
.map_err(map_error_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);
encode_peer_info(peer, &mut pi_builder)?;
}
Ok(())
}
}

67
veilid-core/src/rpc_processor/coders/operations/operation_get_value.rs Normal file
View File

@ -0,0 +1,67 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCOperationGetValueQ {
key: ValueKey,
}
impl RPCOperationGetValueQ {
pub fn decode(
reader: &veilid_capnp::operation_get_value_q::Reader,
) -> Result<RPCOperationGetValueQ, RPCError> {
let ni_reader = reader.get_node_id().map_err(map_error_capnp_error!())?;
let node_id = decode_public_key(&ni_reader);
Ok(RPCOperationGetValueQ { node_id })
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_get_value_q::Builder,
) -> Result<(), RPCError> {
let ni_builder = builder.init_node_id();
encode_public_key(&self.node_id, &mut ni_builder)?;
Ok(())
}
}
#[derive(Debug, Clone)]
pub enum RPCOperationGetValueA {
Data(ValueData),
Peers(Vec<PeerInfo>),
}
impl RPCOperationGetValueA {
pub fn decode(
reader: &veilid_capnp::operation_get_value_a::Reader,
) -> Result<RPCOperationGetValueA, RPCError> {
let peers_reader = reader.get_peers().map_err(map_error_capnp_error!())?;
let mut peers = Vec::<PeerInfo>::with_capacity(
peers_reader
.len()
.try_into()
.map_err(map_error_internal!("too many peers"))?,
);
for p in peers_reader.iter() {
let peer_info = decode_peer_info(&p, true)?;
peers.push(peer_info);
}
Ok(RPCOperationGetValueA { peers })
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_get_value_a::Builder,
) -> Result<(), RPCError> {
let mut peers_builder = builder.init_peers(
self.peers
.len()
.try_into()
.map_err(map_error_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);
encode_peer_info(peer, &mut pi_builder)?;
}
Ok(())
}
}

29
veilid-core/src/rpc_processor/coders/operations/operation_node_info_update.rs Normal file
View File

@ -0,0 +1,29 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCOperationNodeInfoUpdate {
signed_node_info: SignedNodeInfo,
}
impl RPCOperationNodeInfoUpdate {
pub fn decode(
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 signed_node_info = decode_signed_node_info(&sni_reader, sender_node_id, true)?;
Ok(RPCOperationNodeInfoUpdate { signed_node_info })
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_node_info_update::Builder,
) -> Result<(), RPCError> {
let sni_builder = builder.init_signed_node_info();
encode_signed_node_info(&self.signed_node_info, &mut sni_builder)?;
Ok(())
}
}

96
veilid-core/src/rpc_processor/coders/operations/operation_route.rs Normal file
View File

@ -0,0 +1,96 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
struct RoutedOperation {
signatures: Vec<DHTSignature>,
nonce: Nonce,
data: Vec<u8>,
}
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 mut signatures = Vec::<DHTSignature>::with_capacity(
sigs_reader
.len()
.try_into()
.map_err(map_error_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 nonce = decode_nonce(&n_reader);
let data = reader
.get_data()
.map_err(map_error_capnp_error!())?
.to_vec();
Ok(RoutedOperation {
signatures,
nonce,
data,
})
}
pub fn encode(
&self,
builder: &mut veilid_capnp::routed_operation::Builder,
) -> Result<(), RPCError> {
let mut sigs_builder = builder.init_signatures(
self.signatures
.len()
.try_into()
.map_err(map_error_internal!("invalid signatures list length"))?,
);
for (i, sig) in self.signatures.iter().enumerate() {
let mut sig_builder = sigs_builder.reborrow().get(i as u32);
encode_signature(sig, &mut sig_builder);
}
let n_builder = builder.init_nonce();
encode_nonce(&self.nonce, &mut n_builder);
builder.set_data(&self.data);
Ok(())
}
}
#[derive(Debug, Clone)]
pub struct RPCOperationRoute {
safety_route: SafetyRoute,
operation: RoutedOperation,
}
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 safety_route = decode_safety_route(&sr_reader)?;
let o_reader = reader.get_operation().map_err(map_error_capnp_error!())?;
let operation = RoutedOperation::decode(&o_reader)?;
Ok(RPCOperationRoute {
safety_route,
operation,
})
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_route::Builder,
) -> Result<(), RPCError> {
let sr_builder = builder.init_safety_route();
encode_safety_route(&self.safety_route, &mut sr_builder)?;
let o_builder = builder.init_operation();
self.operation.encode(&mut o_builder)?;
Ok(())
}
}

60
veilid-core/src/rpc_processor/coders/operations/operation_status.rs Normal file
View File

@ -0,0 +1,60 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCOperationStatusQ {
node_status: NodeStatus,
}
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 node_status = decode_node_status(&ns_reader)?;
Ok(RPCOperationStatusQ { node_status })
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_status_q::Builder,
) -> Result<(), RPCError> {
let ns_builder = builder.init_node_status();
encode_node_status(&self.node_status, &mut ns_builder)?;
Ok(())
}
}
#[derive(Debug, Clone)]
pub struct RPCOperationStatusA {
node_status: NodeStatus,
sender_info: SenderInfo,
}
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 node_status = decode_node_status(&ns_reader)?;
let si_reader = reader
.get_sender_info()
.map_err(map_error_capnp_notinschema!())?;
let sender_info = decode_sender_info(&si_reader)?;
Ok(RPCOperationStatusA {
node_status,
sender_info,
})
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_status_a::Builder,
) -> Result<(), RPCError> {
let ns_builder = builder.init_node_status();
encode_node_status(&self.node_status, &mut ns_builder)?;
let si_builder = builder.init_sender_info();
encode_sender_info(&self.sender_info, &mut si_builder)?;
Ok(())
}
}

37
veilid-core/src/rpc_processor/coders/operations/operation_validate_dial_info.rs Normal file
View File

@ -0,0 +1,37 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCOperationValidateDialInfo {
dial_info: DialInfo,
receipt: Vec<u8>,
redirect: bool,
}
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 dial_info = decode_dial_info(&di_reader)?;
let rcpt_reader = reader.get_receipt().map_err(map_error_capnp_error!())?;
let receipt = rcpt_reader.to_vec();
let redirect = reader.get_redirect();
Ok(RPCOperationValidateDialInfo {
dial_info,
receipt,
redirect,
})
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_validate_dial_info::Builder,
) -> Result<(), RPCError> {
let di_builder = builder.init_dial_info();
encode_dial_info(&self.dial_info, &mut di_builder)?;
builder.set_receipt(&self.receipt);
builder.set_redirect(self.redirect);
Ok(())
}
}

62
veilid-core/src/rpc_processor/coders/operations/respond_to.rs Normal file
View File

@ -0,0 +1,62 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub enum RespondTo {
None,
Sender(Option<SignedNodeInfo>),
PrivateRoute(PrivateRoute),
}
impl RespondTo {
pub fn encode(
&self,
builder: &mut veilid_capnp::operation::respond_to::Builder,
) -> Result<(), RPCError> {
match self {
Self::None => {
builder.set_none(());
}
Self::Sender(Some(sni)) => {
let mut sni_builder = builder.reborrow().init_sender_with_info();
encode_signed_node_info(sni, &mut sni_builder)?;
}
Self::Sender(None) => {
builder.reborrow().set_sender(());
}
Self::PrivateRoute(pr) => {
let mut pr_builder = builder.reborrow().init_private_route();
encode_private_route(pr, &mut pr_builder)?;
}
};
Ok(())
}
pub fn decode(
reader: &veilid_capnp::operation::respond_to::Reader,
sender_node_id: &DHTKey,
) -> Result<Self, RPCError> {
let respond_to = match reader.which().map_err(map_error_capnp_notinschema!())? {
veilid_capnp::operation::respond_to::None(_) => RespondTo::None,
veilid_capnp::operation::respond_to::Sender(_) => RespondTo::Sender(None),
veilid_capnp::operation::respond_to::SenderWithInfo(Ok(sender_ni_reader)) => {
let sni = decode_signed_node_info(&sender_ni_reader, sender_node_id, true)?;
RespondTo::Sender(Some(sni))
}
veilid_capnp::operation::respond_to::SenderWithInfo(Err(e)) => {
return Err(rpc_error_protocol(format!(
"invalid signed node info: {}",
e
)))
}
veilid_capnp::operation::respond_to::PrivateRoute(Ok(pr_reader)) => {
let pr = decode_private_route(&pr_reader)?;
RespondTo::PrivateRoute(pr)
}
veilid_capnp::operation::respond_to::PrivateRoute(Err(e)) => {
return Err(rpc_error_protocol(format!("invalid private route: {}", e)));
}
};
Ok(respond_to)
}
}

20
veilid-core/src/rpc_processor/coders/value_data.rs Normal file
View File

@ -0,0 +1,20 @@
use crate::*;
use rpc_processor::*;
pub fn encode_value_data(
value_data: &ValueData,
builder: &mut veilid_capnp::value_data::Builder,
) -> Result<(), RPCError> {
builder.set_data(&value_data.data);
builder.set_seq(value_data.seq);
Ok(())
}
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 seq = reader.get_seq();
Ok(ValueData { data, seq })
}

26
veilid-core/src/rpc_processor/coders/value_key.rs Normal file
View File

@ -0,0 +1,26 @@
use crate::*;
use rpc_processor::*;
pub fn encode_value_key(
value_key: &ValueKey,
builder: &mut veilid_capnp::value_key::Builder,
) -> Result<(), RPCError> {
let pk_builder = builder.init_public_key();
encode_public_key(&value_key.key, &mut pk_builder)?;
if let Some(subkey) = value_key.subkey {
builder.set_subkey(&subkey);
}
Ok(())
}
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 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!())?;
Some(subkey.to_owned())
};
Ok(ValueKey { key, subkey })
}

42
veilid-core/src/rpc_processor/debug.rs
View File

@ -108,12 +108,17 @@ impl RPCProcessor {
format!(
"#{} {}",
op_id,
self.get_rpc_operation_detail_debug_info(&detail)
Self::get_rpc_operation_detail_debug_info(&detail)
)
}
pub(super) fn get_rpc_operation_detail_debug_info(
&self,
struct RpcOperationDetailInfo {
name: &'static str,
index: u32,
is_q: bool,
}
pub(super) fn get_rpc_operation_detail_info(
detail: &veilid_capnp::operation::detail::WhichReader,
) -> String {
match detail {
@ -145,4 +150,35 @@ impl RPCProcessor {
veilid_capnp::operation::detail::CancelTunnelA(_) => "CancelTunnelA".to_owned(),
}
}
pub(super) fn get_rpc_operation_detail_d(
let (which, is_q) = match which_reader
{
veilid_capnp::operation::detail::StatusQ(_) => (0u32, true),
veilid_capnp::operation::detail::StatusA(_) => (1u32, false),
veilid_capnp::operation::detail::ValidateDialInfo(_) => (2u32, true),
veilid_capnp::operation::detail::FindNodeQ(_) => (3u32, true),
veilid_capnp::operation::detail::FindNodeA(_) => (4u32, false),
veilid_capnp::operation::detail::Route(_) => (5u32, true),
veilid_capnp::operation::detail::NodeInfoUpdate(_) => (6u32, true),
veilid_capnp::operation::detail::GetValueQ(_) => (7u32, true),
veilid_capnp::operation::detail::GetValueA(_) => (8u32, false),
veilid_capnp::operation::detail::SetValueQ(_) => (9u32, true),
veilid_capnp::operation::detail::SetValueA(_) => (10u32, false),
veilid_capnp::operation::detail::WatchValueQ(_) => (11u32, true),
veilid_capnp::operation::detail::WatchValueA(_) => (12u32, false),
veilid_capnp::operation::detail::ValueChanged(_) => (13u32, true),
veilid_capnp::operation::detail::SupplyBlockQ(_) => (14u32, true),
veilid_capnp::operation::detail::SupplyBlockA(_) => (15u32, false),
veilid_capnp::operation::detail::FindBlockQ(_) => (16u32, true),
veilid_capnp::operation::detail::FindBlockA(_) => (17u32, false),
veilid_capnp::operation::detail::Signal(_) => (18u32, true),
veilid_capnp::operation::detail::ReturnReceipt(_) => (19u32, true),
veilid_capnp::operation::detail::StartTunnelQ(_) => (20u32, true),
veilid_capnp::operation::detail::StartTunnelA(_) => (21u32, false),
veilid_capnp::operation::detail::CompleteTunnelQ(_) => (22u32, true),
veilid_capnp::operation::detail::CompleteTunnelA(_) => (23u32, false),
veilid_capnp::operation::detail::CancelTunnelQ(_) => (24u32, true),
veilid_capnp::operation::detail::CancelTunnelA(_) => (25u32, false),
};
}

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

@ -43,38 +43,6 @@ impl fmt::Display for Destination {
}
}
#[derive(Debug, Clone)]
pub enum RespondTo {
None,
Sender(Option<SignedNodeInfo>),
PrivateRoute(PrivateRoute),
}
impl RespondTo {
pub fn encode(
&self,
builder: &mut veilid_capnp::operation::respond_to::Builder,
) -> Result<(), RPCError> {
match self {
Self::None => {
builder.set_none(());
}
Self::Sender(Some(sni)) => {
let mut sni_builder = builder.reborrow().init_sender_with_info();
encode_signed_node_info(sni, &mut sni_builder)?;
}
Self::Sender(None) => {
builder.reborrow().set_sender(());
}
Self::PrivateRoute(pr) => {
let mut pr_builder = builder.reborrow().init_private_route();
encode_private_route(pr, &mut pr_builder)?;
}
};
Ok(())
}
}
#[derive(Debug, Clone)]
struct RPCMessageHeader {
timestamp: u64, // time the message was received, not sent
@ -142,6 +110,56 @@ struct WaitableReply {
send_data_kind: SendDataKind,
}
struct RPCOperationInfo {
name: &'static str,
op_id: u64,
index: u32,
is_q: bool,
wants_answer: bool,
respond_to: RespondTo
}
impl RPCOperationInfo {
pub fn parse(operation_reader: &veilid_capnp::operation::Reader, sender_node_id: &DHTKey) -> Result<Self, RPCError> {
let which_reader = operation_reader.get_detail().which().expect("missing which operation");
let op_id = operation_reader.get_op_id();
let respond_to_reader = operation_reader.get_respond_to();
let respond_to = RespondTo::decode(&respond_to_reader, sender_node_id)?;
let out = match which_reader {
veilid_capnp::operation::detail::StatusQ(_) => Self { name: "StatusQ", op_id, index: 0, is_q: true, wants_answer: true, respond_to },
veilid_capnp::operation::detail::StatusA(_) => Self { name: "StatusA", op_id, index: 1, is_q: false, wants_answer: false, respond_to},
veilid_capnp::operation::detail::ValidateDialInfo(_) => Self { name: "ValidateDialInfo", op_id, index: 2, is_q: true, wants_answer: false, respond_to },
veilid_capnp::operation::detail::FindNodeQ(_) => Self { name: "FindNodeQ", op_id, index: 3, is_q: true, wants_answer: true, respond_to },
veilid_capnp::operation::detail::FindNodeA(_) => Self { name: "FindNodeA", op_id, index: 4, is_q: false, wants_answer: false, respond_to },
veilid_capnp::operation::detail::Route(_) => Self { name: "Route", op_id, index: 5, is_q: true, wants_answer: false, respond_to },
veilid_capnp::operation::detail::NodeInfoUpdate(_) => Self { name: "NodeInfoUpdate", op_id, index: 6, is_q: true, wants_answer: false, respond_to },
veilid_capnp::operation::detail::GetValueQ(_) => Self { name: "GetValueQ", op_id, index: 7, is_q: true, wants_answer: true, respond_to },
veilid_capnp::operation::detail::GetValueA(_) => Self { name: "GetValueA", op_id, index: 8, is_q: false, wants_answer: false, respond_to },
veilid_capnp::operation::detail::SetValueQ(_) => Self { name: "SetValueQ", op_id, index: 9, is_q: true, wants_answer: true, respond_to },
veilid_capnp::operation::detail::SetValueA(_) => Self { name: "SetValueA", op_id, index: 10, is_q: false, wants_answer: false, respond_to},
veilid_capnp::operation::detail::WatchValueQ(_) => Self { name: "WatchValueQ", op_id, index: 11, is_q: true, wants_answer: true, respond_to},
veilid_capnp::operation::detail::WatchValueA(_) => Self { name: "WatchValueA", op_id, index: 12, is_q: false, wants_answer: false, respond_to},
veilid_capnp::operation::detail::ValueChanged(_) => Self { name: "ValueChanged", op_id, index: 13, is_q: true, wants_answer: false, respond_to },
veilid_capnp::operation::detail::SupplyBlockQ(_) => Self { name: "SupplyBlockQ", op_id, index: 14, is_q: true, wants_answer: true, respond_to },
veilid_capnp::operation::detail::SupplyBlockA(_) => Self { name: "SupplyBlockA", op_id, index: 15, is_q: false, wants_answer: false, respond_to },
veilid_capnp::operation::detail::FindBlockQ(_) => Self { name: "FindBlockQ", op_id, index: 16, is_q: true, wants_answer: true, respond_to},
veilid_capnp::operation::detail::FindBlockA(_) =>Self { name: "FindBlockA", op_id, index: 17, is_q: false, wants_answer: false, respond_to},
veilid_capnp::operation::detail::Signal(_) => Self { name: "Signal", op_id, index: 18, is_q: true, wants_answer: false, respond_to },
veilid_capnp::operation::detail::ReturnReceipt(_) => Self { name: "ReturnReceipt", op_id, index: 19, is_q: true, wants_answer: false, respond_to},
veilid_capnp::operation::detail::StartTunnelQ(_) => Self { name: "StartTunnelQ", op_id, index: 20, is_q: true, wants_answer: true, respond_to },
veilid_capnp::operation::detail::StartTunnelA(_) => Self { name: "StartTunnelA", op_id, index: 21, is_q: false, wants_answer: false, respond_to },
veilid_capnp::operation::detail::CompleteTunnelQ(_) =>Self { name: "CompleteTunnelQ", op_id, index: 22, is_q: true, wants_answer: true, respond_to},
veilid_capnp::operation::detail::CompleteTunnelA(_) => Self { name: "CompleteTunnelA", op_id, index: 23, is_q: false, wants_answer: false, respond_to},
veilid_capnp::operation::detail::CancelTunnelQ(_) => Self { name: "CancelTunnelQ", op_id, index: 24, is_q: true, wants_answer: true, respond_to},
veilid_capnp::operation::detail::CancelTunnelA(_) => Self { name: "CancelTunnelA", op_id, index: 25, is_q: false, wants_answer: false, respond_to},
};
Ok(out)
}
}
/////////////////////////////////////////////////////////////////////
#[derive(Clone, Debug, Default)]
@ -403,6 +421,7 @@ impl RPCProcessor {
}
// Issue a request over the network, possibly using an anonymized route
#[instrument(level = "debug", skip(self, message, safety_route_spec), err)]
async fn request<T: capnp::message::ReaderSegments>(
&self,
dest: Destination,
@ -410,11 +429,15 @@ impl RPCProcessor {
safety_route_spec: Option<&SafetyRouteSpec>,
) -> Result<Option<WaitableReply>, RPCError> {
let (op_id, wants_answer) = {
let info = {
let operation = message
.get_root::<veilid_capnp::operation::Reader>()
.map_err(map_error_internal!("invalid operation"))
.map_err(logthru_rpc!(error))?;
RPCOperationInfo::parse()
}
let (op_id, wants_answer) = {
let op_id = operation.get_op_id();
let wants_answer = self.wants_answer(&operation).map_err(logthru_rpc!())?;
@ -549,9 +572,12 @@ impl RPCProcessor {
None
};
// send question
// Log rpc receive
debug!(target: "rpc_message", dir = "send", is_q, kind = Self::get_rpc_operation_detail_debug_info(&which_reader), op_id = operation.get_op_id(), sender_id = msg.header.envelope.get_sender_id().encode());
log_rpc!(debug "==>> REQUEST({}) -> {:?}", self.get_rpc_message_debug_info(&message), dest);
// send question
let bytes = out.len() as u64;
let send_ts = intf::get_timestamp();
let send_data_kind = match self
@ -597,6 +623,7 @@ impl RPCProcessor {
// Issue a reply over the network, possibly using an anonymized route
// The request must want a response, or this routine fails
#[instrument(level = "debug", skip(self, request_rpcreader, reply_msg, safety_route_spec), err)]
async fn reply<T: capnp::message::ReaderSegments>(
&self,
request_rpcreader: RPCMessageReader,
@ -761,44 +788,9 @@ impl RPCProcessor {
Ok(())
}
fn wants_answer(&self, operation: &veilid_capnp::operation::Reader) -> Result<bool, RPCError> {
match operation
.get_respond_to()
.which()
.map_err(map_error_capnp_notinschema!())?
{
veilid_capnp::operation::respond_to::None(_) => Ok(false),
veilid_capnp::operation::respond_to::Sender(_)
| veilid_capnp::operation::respond_to::SenderWithInfo(_)
| veilid_capnp::operation::respond_to::PrivateRoute(_) => Ok(true),
}
}
fn get_respond_to_sender_signed_node_info(
&self,
operation: &veilid_capnp::operation::Reader,
sender_node_id: &DHTKey,
) -> Result<Option<SignedNodeInfo>, RPCError> {
match operation
.get_respond_to()
.which()
.map_err(map_error_capnp_notinschema!())?
{
veilid_capnp::operation::respond_to::SenderWithInfo(Ok(sender_ni_reader)) => Ok(Some(
decode_signed_node_info(&sender_ni_reader, sender_node_id, true)?,
)),
veilid_capnp::operation::respond_to::SenderWithInfo(Err(e)) => Err(rpc_error_protocol(
format!("invalid sender_with_info signed node info: {}", e),
)),
veilid_capnp::operation::respond_to::None(_)
| veilid_capnp::operation::respond_to::Sender(_)
| veilid_capnp::operation::respond_to::PrivateRoute(_) => Ok(None),
}
}
//////////////////////////////////////////////////////////////////////
async fn generate_sender_info(&self, peer_noderef: NodeRef) -> SenderInfo {
async fn generate_sender_info(peer_noderef: NodeRef) -> SenderInfo {
let socket_address = peer_noderef
.last_connection()
.await
@ -808,7 +800,7 @@ impl RPCProcessor {
async fn process_status_q(&self, rpcreader: RPCMessageReader) -> Result<(), RPCError> {
let peer_noderef = rpcreader.header.peer_noderef.clone();
let sender_info = self.generate_sender_info(peer_noderef).await;
let sender_info = Self::generate_sender_info(peer_noderef).await;
let reply_msg = {
let operation = rpcreader
@ -818,19 +810,20 @@ impl RPCProcessor {
.map_err(logthru_rpc!())?;
// Don't bother unless we are going to answer
if !self.wants_answer(&operation)? {
if !Self::wants_answer(&operation)? {
return Ok(());
}
// get StatusQ reader
let iq_reader = match operation.get_detail().which() {
Ok(veilid_capnp::operation::detail::Which::StatusQ(Ok(x))) => x,
let which_reader = operation.get_detail().which().expect("missing which operation");
let statusq_reader = match which_reader {
veilid_capnp::operation::detail::Which::StatusQ(Ok(x)) => x,
_ => panic!("invalid operation type in process_status_q"),
};
// Parse out fields
let node_status = decode_node_status(
&iq_reader
&statusq_reader
.get_node_status()
.map_err(map_error_internal!("no valid node status"))?,
)?;
@ -1253,11 +1246,12 @@ impl RPCProcessor {
.get_root::<veilid_capnp::operation::Reader>()
.map_err(map_error_capnp_error!())
.map_err(logthru_rpc!())?;
let (which, is_q) = match operation
let which_reader = operation
.get_detail()
.which()
.map_err(map_error_capnp_notinschema!())?
.map_err(map_error_capnp_notinschema!())?;
let (which, is_q) = match which_reader
{
veilid_capnp::operation::detail::StatusQ(_) => (0u32, true),
veilid_capnp::operation::detail::StatusA(_) => (1u32, false),
@ -1287,11 +1281,8 @@ impl RPCProcessor {
veilid_capnp::operation::detail::CancelTunnelA(_) => (25u32, false),
};
log_rpc!(debug "<<== {}({}) <- {:?}",
if is_q { "REQUEST" } else { "REPLY" },
self.get_rpc_message_debug_info(&reader),
msg.header.envelope.get_sender_id()
);
// Log rpc receive
debug!(target: "rpc_message", dir = "recv", is_q, kind = Self::get_rpc_operation_detail_debug_info(&which_reader), op_id = operation.get_op_id(), sender_id = msg.header.envelope.get_sender_id().encode());
// Accounting for questions we receive
if is_q {
@ -1384,6 +1375,7 @@ impl RPCProcessor {
}
}
#[instrument(level = "debug", skip_all, err)]
pub async fn startup(&self) -> Result<(), String> {
trace!("startup rpc processor");
let mut inner = self.inner.lock();
@ -1430,6 +1422,7 @@ impl RPCProcessor {
Ok(())
}
#[instrument(level = "debug", skip_all)]
pub async fn shutdown(&self) {
debug!("starting rpc processor shutdown");

18
veilid-core/src/veilid_api/mod.rs
View File

@ -281,6 +281,24 @@ impl ValueKey {
}
}
#[derive(Clone, Debug, Default, PartialOrd, PartialEq, Eq, Ord, Serialize, Deserialize)]
pub struct ValueData {
pub data: Vec<u8>,
pub seq: u32,
}
impl ValueData {
pub fn new(data: Vec<u8>) -> Self {
Self { data, seq: 0 }
}
pub fn new_with_seq(data: Vec<u8>, seq: u32) -> Self {
Self { data, seq }
}
pub fn change(&mut self, data: Vec<u8>) {
self.data = data;
self.seq += 1;
}
}
#[derive(Clone, Debug, Default, PartialOrd, PartialEq, Eq, Ord, Serialize, Deserialize)]
pub struct BlockId {
pub key: DHTKey,