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 23:20:30 -04:00
parent 5fb551e53d
commit eed79ce721
16 changed files with 997 additions and 554 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -18,6 +18,7 @@ mod signal_info;
mod signature;
mod signed_node_info;
mod socket_address;
mod tunnel;
mod value_data;
mod value_key;
@@ -41,6 +42,7 @@ pub use signal_info::*;
pub use signature::*;
pub use signed_node_info::*;
pub use socket_address::*;
pub use tunnel::*;
pub use value_data::*;
pub use value_key::*;

136
veilid-core/src/rpc_processor/coders/operations/answer.rs Normal file
View File

@@ -0,0 +1,136 @@
use super::*;
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCAnswer {
detail: RPCAnswerDetail,
}
impl RPCAnswer {
pub fn new(detail: RPCAnswerDetail) -> Self {
Self { detail }
}
pub fn detail(&self) -> &RPCAnswerDetail {
&self.detail
}
pub fn desc(&self) -> &'static str {
self.detail.desc()
}
pub fn decode(reader: &veilid_capnp::answer::Reader) -> Result<RPCAnswer, RPCError> {
let d_reader = reader.get_detail();
let detail = RPCAnswerDetail::decode(&d_reader)?;
Ok(RPCAnswer { detail })
}
pub fn encode(&self, builder: &mut veilid_capnp::answer::Builder) -> Result<(), RPCError> {
self.detail.encode(&mut builder.init_detail())?;
Ok(())
}
}
#[derive(Debug, Clone)]
pub enum RPCAnswerDetail {
StatusA(RPCOperationStatusA),
FindNodeA(RPCOperationFindNodeA),
GetValueA(RPCOperationGetValueA),
SetValueA(RPCOperationSetValueA),
WatchValueA(RPCOperationWatchValueA),
SupplyBlockA(RPCOperationSupplyBlockA),
FindBlockA(RPCOperationFindBlockA),
StartTunnelA(RPCOperationStartTunnelA),
CompleteTunnelA(RPCOperationCompleteTunnelA),
CancelTunnelA(RPCOperationCancelTunnelA),
}
impl RPCAnswerDetail {
pub fn desc(&self) -> &'static str {
match self {
RPCAnswerDetail::StatusA(_) => "StatusA",
RPCAnswerDetail::FindNodeA(_) => "FindNodeA",
RPCAnswerDetail::GetValueA(_) => "GetValueA",
RPCAnswerDetail::SetValueA(_) => "SetValueA",
RPCAnswerDetail::WatchValueA(_) => "WatchValueA",
RPCAnswerDetail::SupplyBlockA(_) => "SupplyBlockA",
RPCAnswerDetail::FindBlockA(_) => "FindBlockA",
RPCAnswerDetail::StartTunnelA(_) => "StartTunnelA",
RPCAnswerDetail::CompleteTunnelA(_) => "CompleteTunnelA",
RPCAnswerDetail::CancelTunnelA(_) => "CancelTunnelA",
}
}
pub fn decode(
reader: &veilid_capnp::answer::detail::Reader,
) -> Result<RPCAnswerDetail, RPCError> {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let out = match which_reader {
veilid_capnp::answer::detail::StatusA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationStatusA::decode(&op_reader)?;
RPCAnswerDetail::StatusA(out)
}
veilid_capnp::answer::detail::FindNodeA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationFindNodeA::decode(&op_reader)?;
RPCAnswerDetail::FindNodeA(out)
}
veilid_capnp::answer::detail::GetValueA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationGetValueA::decode(&op_reader)?;
RPCAnswerDetail::GetValueA(out)
}
veilid_capnp::answer::detail::SetValueA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationSetValueA::decode(&op_reader)?;
RPCAnswerDetail::SetValueA(out)
}
veilid_capnp::answer::detail::WatchValueA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationWatchValueA::decode(&op_reader)?;
RPCAnswerDetail::WatchValueA(out)
}
veilid_capnp::answer::detail::SupplyBlockA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationSupplyBlockA::decode(&op_reader)?;
RPCAnswerDetail::SupplyBlockA(out)
}
veilid_capnp::answer::detail::FindBlockA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationFindBlockA::decode(&op_reader)?;
RPCAnswerDetail::FindBlockA(out)
}
veilid_capnp::answer::detail::StartTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationStartTunnelA::decode(&op_reader)?;
RPCAnswerDetail::StartTunnelA(out)
}
veilid_capnp::answer::detail::CompleteTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationCompleteTunnelA::decode(&op_reader)?;
RPCAnswerDetail::CompleteTunnelA(out)
}
veilid_capnp::answer::detail::CancelTunnelA(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationCancelTunnelA::decode(&op_reader)?;
RPCAnswerDetail::CancelTunnelA(out)
}
};
Ok(out)
}
pub fn encode(
&self,
builder: &mut veilid_capnp::answer::detail::Builder,
) -> Result<(), RPCError> {
match self {
RPCAnswerDetail::StatusA(d) => d.encode(&mut builder.init_status_a()),
RPCAnswerDetail::FindNodeA(d) => d.encode(&mut builder.init_find_node_a()),
RPCAnswerDetail::GetValueA(d) => d.encode(&mut builder.init_get_value_a()),
RPCAnswerDetail::SetValueA(d) => d.encode(&mut builder.init_set_value_a()),
RPCAnswerDetail::WatchValueA(d) => d.encode(&mut builder.init_watch_value_a()),
RPCAnswerDetail::SupplyBlockA(d) => d.encode(&mut builder.init_supply_block_a()),
RPCAnswerDetail::FindBlockA(d) => d.encode(&mut builder.init_find_block_a()),
RPCAnswerDetail::StartTunnelA(d) => d.encode(&mut builder.init_start_tunnel_a()),
RPCAnswerDetail::CompleteTunnelA(d) => d.encode(&mut builder.init_complete_tunnel_a()),
RPCAnswerDetail::CancelTunnelA(d) => d.encode(&mut builder.init_cancel_tunnel_a()),
}
}
}

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

@@ -1,5 +1,7 @@
mod answer;
mod operation;
mod operation_detail;
mod operation_cancel_tunnel;
mod operation_complete_tunnel;
mod operation_find_block;
mod operation_find_node;
mod operation_get_value;
@@ -8,16 +10,20 @@ mod operation_return_receipt;
mod operation_route;
mod operation_set_value;
mod operation_signal;
mod operation_start_tunnel;
mod operation_status;
mod operation_supply_block;
mod operation_validate_dial_info;
mod operation_value_changed;
mod operation_watch_value;
mod question;
mod respond_to;
mod statement;
pub use answer::*;
pub use operation::*;
pub use operation_detail::*;
pub use operation_cancel_tunnel::*;
pub use operation_complete_tunnel::*;
pub use operation_find_block::*;
pub use operation_find_node::*;
pub use operation_get_value::*;
@@ -26,10 +32,12 @@ pub use operation_return_receipt::*;
pub use operation_route::*;
pub use operation_set_value::*;
pub use operation_signal::*;
pub use operation_start_tunnel::*;
pub use operation_status::*;
pub use operation_supply_block::*;
pub use operation_validate_dial_info::*;
pub use operation_value_changed::*;
pub use operation_watch_value::*;
pub use question::*;
pub use respond_to::*;
pub use statement::*;

168
veilid-core/src/rpc_processor/coders/operations/operation.rs
View File

@@ -2,97 +2,113 @@ use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
struct RPCOperation {
pub enum RPCOperationKind {
Question(RPCQuestion),
Statement(RPCStatement),
Answer(RPCAnswer),
}
impl RPCOperationKind {
pub fn desc(&self) -> &'static str {
match self {
RPCOperationKind::Question(q) => q.desc(),
RPCOperationKind::Statement(s) => s.desc(),
RPCOperationKind::Answer(a) => a.desc(),
}
}
pub fn decode(
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 out = match which_reader {
veilid_capnp::operation::kind::Which::Question(r) => {
let q_reader = r.map_err(map_error_capnp_notinschema!())?;
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_notinschema!())?;
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_notinschema!())?;
let out = RPCAnswer::decode(&q_reader)?;
RPCOperationKind::Answer(out)
}
};
Ok(out)
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation::kind::Builder,
) -> Result<(), RPCError> {
match self {
RPCOperationKind::Question(k) => k.encode(&mut builder.init_question()),
RPCOperationKind::Statement(k) => k.encode(&mut builder.init_statement()),
RPCOperationKind::Answer(k) => k.encode(&mut builder.init_answer()),
};
Ok(())
}
}
#[derive(Debug, Clone)]
pub struct RPCOperation {
op_id: u64,
// index: u32,
// is_q: bool,
// wants_answer: bool,
respond_to: RespondTo,
detail: RPCOperationDetail,
kind: RPCOperationKind,
}
impl RPCOperation {
pub fn new_question(question: RPCQuestion) -> Self {
Self {
op_id: intf::get_random_u64(),
kind: RPCOperationKind::Question(question),
}
}
pub fn new_statement(statement: RPCStatement) -> Self {
Self {
op_id: intf::get_random_u64(),
kind: RPCOperationKind::Statement(statement),
}
}
pub fn new_answer(request: &RPCOperation, answer: RPCAnswer) -> Self {
Self {
op_id: request.op_id,
kind: RPCOperationKind::Answer(answer),
}
}
pub fn op_id(&self) -> u64 {
self.op_id
}
pub fn kind(&self) -> &RPCOperationKind {
&self.kind
}
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 kind_reader = operation_reader.get_kind();
let kind = RPCOperationKind::decode(&kind_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,
})
Ok(RPCOperation { op_id, kind })
}
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)?;
let k_builder = builder.init_kind();
self.kind.encode(&mut k_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},

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

@@ -0,0 +1,62 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCOperationCancelTunnelQ {
id: TunnelId,
}
impl RPCOperationCancelTunnelQ {
pub fn decode(
reader: &veilid_capnp::operation_cancel_tunnel_q::Reader,
) -> Result<RPCOperationCancelTunnelQ, RPCError> {
let id = reader.get_id();
Ok(RPCOperationCancelTunnelQ { id })
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_cancel_tunnel_q::Builder,
) -> Result<(), RPCError> {
builder.set_id(self.id);
Ok(())
}
}
#[derive(Debug, Clone)]
pub enum RPCOperationCancelTunnelA {
Tunnel(TunnelId),
Error(TunnelError),
}
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!())? {
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!())?);
Ok(RPCOperationCancelTunnelA::Error(tunnel_error))
}
}
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_cancel_tunnel_a::Builder,
) -> Result<(), RPCError> {
match self {
RPCOperationCancelTunnelA::Tunnel(p) => {
builder.set_tunnel(*p);
}
RPCOperationCancelTunnelA::Error(e) => {
builder.set_error(encode_tunnel_error(*e));
}
}
Ok(())
}
}

89
veilid-core/src/rpc_processor/coders/operations/operation_complete_tunnel.rs Normal file
View File

@@ -0,0 +1,89 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCOperationCompleteTunnelQ {
id: TunnelId,
local_mode: TunnelMode,
depth: u8,
endpoint: TunnelEndpoint,
}
impl RPCOperationCompleteTunnelQ {
pub fn decode(
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!())?
{
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 endpoint = decode_tunnel_endpoint(&te_reader)?;
Ok(RPCOperationCompleteTunnelQ {
id,
local_mode,
depth,
endpoint,
})
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_complete_tunnel_q::Builder,
) -> Result<(), RPCError> {
builder.set_id(self.id);
builder.set_local_mode(match self.local_mode {
TunnelMode::Raw => veilid_capnp::TunnelEndpointMode::Raw,
TunnelMode::Turn => veilid_capnp::TunnelEndpointMode::Turn,
});
builder.set_depth(self.depth);
let te_builder = builder.init_endpoint();
encode_tunnel_endpoint(&self.endpoint, &mut te_builder)?;
Ok(())
}
}
#[derive(Debug, Clone)]
pub enum RPCOperationCompleteTunnelA {
Tunnel(FullTunnel),
Error(TunnelError),
}
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!())? {
veilid_capnp::operation_complete_tunnel_a::Which::Tunnel(r) => {
let ft_reader = r.map_err(map_error_capnp_error!())?;
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!())?);
Ok(RPCOperationCompleteTunnelA::Error(tunnel_error))
}
}
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_complete_tunnel_a::Builder,
) -> Result<(), RPCError> {
match self {
RPCOperationCompleteTunnelA::Tunnel(p) => {
encode_full_tunnel(p, &mut builder.init_tunnel())?;
}
RPCOperationCompleteTunnelA::Error(e) => {
builder.set_error(encode_tunnel_error(*e));
}
}
Ok(())
}
}

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

@@ -1,214 +0,0 @@
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()),
}
}
}

83
veilid-core/src/rpc_processor/coders/operations/operation_start_tunnel.rs Normal file
View File

@@ -0,0 +1,83 @@
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCOperationStartTunnelQ {
id: TunnelId,
local_mode: TunnelMode,
depth: u8,
}
impl RPCOperationStartTunnelQ {
pub fn decode(
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!())?
{
veilid_capnp::TunnelEndpointMode::Raw => TunnelMode::Raw,
veilid_capnp::TunnelEndpointMode::Turn => TunnelMode::Turn,
};
let depth = reader.get_depth();
Ok(RPCOperationStartTunnelQ {
id,
local_mode,
depth,
})
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_start_tunnel_q::Builder,
) -> Result<(), RPCError> {
builder.set_id(self.id);
builder.set_local_mode(match self.local_mode {
TunnelMode::Raw => veilid_capnp::TunnelEndpointMode::Raw,
TunnelMode::Turn => veilid_capnp::TunnelEndpointMode::Turn,
});
builder.set_depth(self.depth);
Ok(())
}
}
#[derive(Debug, Clone)]
pub enum RPCOperationStartTunnelA {
Partial(PartialTunnel),
Error(TunnelError),
}
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!())? {
veilid_capnp::operation_start_tunnel_a::Which::Partial(r) => {
let pt_reader = r.map_err(map_error_capnp_error!())?;
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!())?);
Ok(RPCOperationStartTunnelA::Error(tunnel_error))
}
}
}
pub fn encode(
&self,
builder: &mut veilid_capnp::operation_start_tunnel_a::Builder,
) -> Result<(), RPCError> {
match self {
RPCOperationStartTunnelA::Partial(p) => {
encode_partial_tunnel(p, &mut builder.init_partial())?;
}
RPCOperationStartTunnelA::Error(e) => {
builder.set_error(encode_tunnel_error(*e));
}
}
Ok(())
}
}

148
veilid-core/src/rpc_processor/coders/operations/question.rs Normal file
View File

@@ -0,0 +1,148 @@
use super::*;
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCQuestion {
respond_to: RespondTo,
detail: RPCQuestionDetail,
}
impl RPCQuestion {
pub fn new(respond_to: RespondTo, detail: RPCQuestionDetail) -> Self {
Self { respond_to, detail }
}
pub fn respond_to(&self) -> &RespondTo {
&self.respond_to
}
pub fn detail(&self) -> &RPCQuestionDetail {
&self.detail
}
pub fn desc(&self) -> &'static str {
self.detail.desc()
}
pub fn decode(
reader: &veilid_capnp::question::Reader,
sender_node_id: &DHTKey,
) -> Result<RPCQuestion, RPCError> {
let rt_reader = reader.get_respond_to();
let respond_to = RespondTo::decode(&rt_reader, sender_node_id)?;
let d_reader = reader.get_detail();
let detail = RPCQuestionDetail::decode(&d_reader)?;
Ok(RPCQuestion { respond_to, detail })
}
pub fn encode(&self, builder: &mut veilid_capnp::question::Builder) -> Result<(), RPCError> {
self.respond_to.encode(&mut builder.init_respond_to())?;
self.detail.encode(&mut builder.init_detail())?;
Ok(())
}
}
#[derive(Debug, Clone)]
pub enum RPCQuestionDetail {
StatusQ(RPCOperationStatusQ),
FindNodeQ(RPCOperationFindNodeQ),
GetValueQ(RPCOperationGetValueQ),
SetValueQ(RPCOperationSetValueQ),
WatchValueQ(RPCOperationWatchValueQ),
SupplyBlockQ(RPCOperationSupplyBlockQ),
FindBlockQ(RPCOperationFindBlockQ),
StartTunnelQ(RPCOperationStartTunnelQ),
CompleteTunnelQ(RPCOperationCompleteTunnelQ),
CancelTunnelQ(RPCOperationCancelTunnelQ),
}
impl RPCQuestionDetail {
pub fn desc(&self) -> &'static str {
match self {
RPCQuestionDetail::StatusQ(_) => "StatusQ",
RPCQuestionDetail::FindNodeQ(_) => "FindNodeQ",
RPCQuestionDetail::GetValueQ(_) => "GetValueQ",
RPCQuestionDetail::SetValueQ(_) => "SetValueQ",
RPCQuestionDetail::WatchValueQ(_) => "WatchValueQ",
RPCQuestionDetail::SupplyBlockQ(_) => "SupplyBlockQ",
RPCQuestionDetail::FindBlockQ(_) => "FindBlockQ",
RPCQuestionDetail::StartTunnelQ(_) => "StartTunnelQ",
RPCQuestionDetail::CompleteTunnelQ(_) => "CompleteTunnelQ",
RPCQuestionDetail::CancelTunnelQ(_) => "CancelTunnelQ",
}
}
pub fn decode(
reader: &veilid_capnp::question::detail::Reader,
) -> Result<RPCQuestionDetail, RPCError> {
let which_reader = reader.which().map_err(map_error_capnp_notinschema!())?;
let out = match which_reader {
veilid_capnp::question::detail::StatusQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationStatusQ::decode(&op_reader)?;
RPCQuestionDetail::StatusQ(out)
}
veilid_capnp::question::detail::FindNodeQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationFindNodeQ::decode(&op_reader)?;
RPCQuestionDetail::FindNodeQ(out)
}
veilid_capnp::question::detail::GetValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationGetValueQ::decode(&op_reader)?;
RPCQuestionDetail::GetValueQ(out)
}
veilid_capnp::question::detail::SetValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationSetValueQ::decode(&op_reader)?;
RPCQuestionDetail::SetValueQ(out)
}
veilid_capnp::question::detail::WatchValueQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationWatchValueQ::decode(&op_reader)?;
RPCQuestionDetail::WatchValueQ(out)
}
veilid_capnp::question::detail::SupplyBlockQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationSupplyBlockQ::decode(&op_reader)?;
RPCQuestionDetail::SupplyBlockQ(out)
}
veilid_capnp::question::detail::FindBlockQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationFindBlockQ::decode(&op_reader)?;
RPCQuestionDetail::FindBlockQ(out)
}
veilid_capnp::question::detail::StartTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationStartTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::StartTunnelQ(out)
}
veilid_capnp::question::detail::CompleteTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationCompleteTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::CompleteTunnelQ(out)
}
veilid_capnp::question::detail::CancelTunnelQ(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationCancelTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::CancelTunnelQ(out)
}
};
Ok(out)
}
pub fn encode(
&self,
builder: &mut veilid_capnp::question::detail::Builder,
) -> Result<(), RPCError> {
match self {
RPCQuestionDetail::StatusQ(d) => d.encode(&mut builder.init_status_q()),
RPCQuestionDetail::FindNodeQ(d) => d.encode(&mut builder.init_find_node_q()),
RPCQuestionDetail::GetValueQ(d) => d.encode(&mut builder.init_get_value_q()),
RPCQuestionDetail::SetValueQ(d) => d.encode(&mut builder.init_set_value_q()),
RPCQuestionDetail::WatchValueQ(d) => d.encode(&mut builder.init_watch_value_q()),
RPCQuestionDetail::SupplyBlockQ(d) => d.encode(&mut builder.init_supply_block_q()),
RPCQuestionDetail::FindBlockQ(d) => d.encode(&mut builder.init_find_block_q()),
RPCQuestionDetail::StartTunnelQ(d) => d.encode(&mut builder.init_start_tunnel_q()),
RPCQuestionDetail::CompleteTunnelQ(d) => {
d.encode(&mut builder.init_complete_tunnel_q())
}
RPCQuestionDetail::CancelTunnelQ(d) => d.encode(&mut builder.init_cancel_tunnel_q()),
}
}
}

19
veilid-core/src/rpc_processor/coders/operations/respond_to.rs
View File

@@ -3,7 +3,6 @@ use rpc_processor::*;
#[derive(Debug, Clone)]
pub enum RespondTo {
None,
Sender(Option<SignedNodeInfo>),
PrivateRoute(PrivateRoute),
}
@@ -11,12 +10,9 @@ pub enum RespondTo {
impl RespondTo {
pub fn encode(
&self,
builder: &mut veilid_capnp::operation::respond_to::Builder,
builder: &mut veilid_capnp::question::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)?;
@@ -33,27 +29,26 @@ impl RespondTo {
}
pub fn decode(
reader: &veilid_capnp::operation::respond_to::Reader,
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::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)) => {
veilid_capnp::question::respond_to::Sender(_) => RespondTo::Sender(None),
veilid_capnp::question::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)) => {
veilid_capnp::question::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)) => {
veilid_capnp::question::respond_to::PrivateRoute(Ok(pr_reader)) => {
let pr = decode_private_route(&pr_reader)?;
RespondTo::PrivateRoute(pr)
}
veilid_capnp::operation::respond_to::PrivateRoute(Err(e)) => {
veilid_capnp::question::respond_to::PrivateRoute(Err(e)) => {
return Err(rpc_error_protocol(format!("invalid private route: {}", e)));
}
};

109
veilid-core/src/rpc_processor/coders/operations/statement.rs Normal file
View File

@@ -0,0 +1,109 @@
use super::*;
use crate::*;
use rpc_processor::*;
#[derive(Debug, Clone)]
pub struct RPCStatement {
detail: RPCStatementDetail,
}
impl RPCStatement {
pub fn new(detail: RPCStatementDetail) -> Self {
Self { detail }
}
pub fn detail(&self) -> &RPCStatementDetail {
&self.detail
}
pub fn desc(&self) -> &'static str {
self.detail.desc()
}
pub fn decode(
reader: &veilid_capnp::statement::Reader,
sender_node_id: &DHTKey,
) -> Result<RPCStatement, RPCError> {
let d_reader = reader.get_detail();
let detail = RPCStatementDetail::decode(&d_reader, sender_node_id)?;
Ok(RPCStatement { detail })
}
pub fn encode(&self, builder: &mut veilid_capnp::statement::Builder) -> Result<(), RPCError> {
self.detail.encode(&mut builder.init_detail())?;
Ok(())
}
}
#[derive(Debug, Clone)]
pub enum RPCStatementDetail {
ValidateDialInfo(RPCOperationValidateDialInfo),
Route(RPCOperationRoute),
NodeInfoUpdate(RPCOperationNodeInfoUpdate),
ValueChanged(RPCOperationValueChanged),
Signal(RPCOperationSignal),
ReturnReceipt(RPCOperationReturnReceipt),
}
impl RPCStatementDetail {
pub fn desc(&self) -> &'static str {
match self {
RPCStatementDetail::ValidateDialInfo(_) => "ValidateDialInfo",
RPCStatementDetail::Route(_) => "Route",
RPCStatementDetail::NodeInfoUpdate(_) => "NodeInfoUpdate",
RPCStatementDetail::ValueChanged(_) => "ValueChanged",
RPCStatementDetail::Signal(_) => "Signal",
RPCStatementDetail::ReturnReceipt(_) => "ReturnReceipt",
}
}
pub fn decode(
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 out = match which_reader {
veilid_capnp::statement::detail::ValidateDialInfo(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationValidateDialInfo::decode(&op_reader)?;
RPCStatementDetail::ValidateDialInfo(out)
}
veilid_capnp::statement::detail::Route(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationRoute::decode(&op_reader)?;
RPCStatementDetail::Route(out)
}
veilid_capnp::statement::detail::NodeInfoUpdate(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
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_notinschema!())?;
let out = RPCOperationValueChanged::decode(&op_reader)?;
RPCStatementDetail::ValueChanged(out)
}
veilid_capnp::statement::detail::Signal(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationSignal::decode(&op_reader)?;
RPCStatementDetail::Signal(out)
}
veilid_capnp::statement::detail::ReturnReceipt(r) => {
let op_reader = r.map_err(map_error_capnp_notinschema!())?;
let out = RPCOperationReturnReceipt::decode(&op_reader)?;
RPCStatementDetail::ReturnReceipt(out)
}
};
Ok(out)
}
pub fn encode(
&self,
builder: &mut veilid_capnp::statement::detail::Builder,
) -> Result<(), RPCError> {
match self {
RPCStatementDetail::ValidateDialInfo(d) => {
d.encode(&mut builder.init_validate_dial_info())
}
RPCStatementDetail::Route(d) => d.encode(&mut builder.init_route()),
RPCStatementDetail::NodeInfoUpdate(d) => d.encode(&mut builder.init_node_info_update()),
RPCStatementDetail::ValueChanged(d) => d.encode(&mut builder.init_value_changed()),
RPCStatementDetail::Signal(d) => d.encode(&mut builder.init_signal()),
RPCStatementDetail::ReturnReceipt(d) => d.encode(&mut builder.init_return_receipt()),
}
}
}

106
veilid-core/src/rpc_processor/coders/tunnel.rs Normal file
View File

@@ -0,0 +1,106 @@
use crate::*;
use rpc_processor::*;
pub fn encode_tunnel_mode(tunnel_mode: TunnelMode) -> veilid_capnp::TunnelEndpointMode {
match tunnel_mode {
TunnelMode::Raw => veilid_capnp::TunnelEndpointMode::Raw,
TunnelMode::Turn => veilid_capnp::TunnelEndpointMode::Turn,
}
}
pub fn decode_tunnel_mode(tunnel_endpoint_mode: veilid_capnp::TunnelEndpointMode) -> TunnelMode {
match tunnel_endpoint_mode {
veilid_capnp::TunnelEndpointMode::Raw => TunnelMode::Raw,
veilid_capnp::TunnelEndpointMode::Turn => TunnelMode::Turn,
}
}
pub fn encode_tunnel_error(tunnel_error: TunnelError) -> veilid_capnp::TunnelError {
match tunnel_error {
TunnelError::BadId => veilid_capnp::TunnelError::BadId,
TunnelError::NoEndpoint => veilid_capnp::TunnelError::NoEndpoint,
TunnelError::RejectedMode => veilid_capnp::TunnelError::RejectedMode,
TunnelError::NoCapacity => veilid_capnp::TunnelError::NoCapacity,
}
}
pub fn decode_tunnel_error(tunnel_error: veilid_capnp::TunnelError) -> TunnelError {
match tunnel_error {
veilid_capnp::TunnelError::BadId => TunnelError::BadId,
veilid_capnp::TunnelError::NoEndpoint => TunnelError::NoEndpoint,
veilid_capnp::TunnelError::RejectedMode => TunnelError::RejectedMode,
veilid_capnp::TunnelError::NoCapacity => TunnelError::NoCapacity,
}
}
pub fn encode_tunnel_endpoint(
tunnel_endpoint: &TunnelEndpoint,
builder: &mut veilid_capnp::tunnel_endpoint::Builder,
) -> Result<(), RPCError> {
builder.set_mode(encode_tunnel_mode(tunnel_endpoint.mode));
builder.set_description(&tunnel_endpoint.description);
Ok(())
}
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 description = reader.get_description();
Ok(TunnelEndpoint { mode, description })
}
pub fn encode_full_tunnel(
full_tunnel: &FullTunnel,
builder: &mut veilid_capnp::full_tunnel::Builder,
) -> Result<(), RPCError> {
builder.set_id(full_tunnel.id);
builder.set_timeout(full_tunnel.timeout);
let l_builder = builder.init_local();
encode_tunnel_endpoint(&full_tunnel.local, &mut l_builder)?;
let r_builder = builder.init_remote();
encode_tunnel_endpoint(&full_tunnel.remote, &mut r_builder)?;
Ok(())
}
pub fn decode_full_tunnel(
reader: &veilid_capnp::full_tunnel::Reader,
) -> 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 local = decode_tunnel_endpoint(&l_reader).map_err(map_error_capnp_error!())?;
let r_reader = reader.get_remote().map_err(map_error_capnp_error!())?;
let remote = decode_tunnel_endpoint(&r_reader).map_err(map_error_capnp_error!())?;
Ok(FullTunnel {
id,
timeout,
local,
remote,
})
}
pub fn encode_partial_tunnel(
partial_tunnel: &PartialTunnel,
builder: &mut veilid_capnp::partial_tunnel::Builder,
) -> Result<(), RPCError> {
builder.set_id(partial_tunnel.id);
builder.set_timeout(partial_tunnel.timeout);
let l_builder = builder.init_local();
encode_tunnel_endpoint(&partial_tunnel.local, &mut l_builder)?;
Ok(())
}
pub fn decode_partial_tunnel(
reader: &veilid_capnp::partial_tunnel::Reader,
) -> 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 local = decode_tunnel_endpoint(&l_reader).map_err(map_error_capnp_error!())?;
Ok(PartialTunnel { id, timeout, local })
}