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
Download Patch File Download Diff File Expand all files Collapse all files

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 })
}