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

checkpoint

Browse Source
This commit is contained in:
John Smith
2022-07-04 17:58:26 -04:00
parent 6a87e32836
commit 9214bcf9a4
17 changed files with 276 additions and 476 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
veilid-core/src/rpc_processor/coders/operations/answer.rs
View File

@@ -67,52 +67,52 @@ impl RPCAnswerDetail {
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationCancelTunnelA::decode(&op_reader)?;
RPCAnswerDetail::CancelTunnelA(out)
}

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

@@ -26,17 +26,17 @@ impl RPCOperationKind {
.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 q_reader = r.map_err(map_error_capnp_error!())?;
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 q_reader = r.map_err(map_error_capnp_error!())?;
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 q_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCAnswer::decode(&q_reader)?;
RPCOperationKind::Answer(out)
}

4
veilid-core/src/rpc_processor/coders/operations/operation_status.rs
View File

@@ -37,9 +37,7 @@ impl RPCOperationStatusA {
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 si_reader = reader.get_sender_info().map_err(map_error_capnp_error!())?;
let sender_info = decode_sender_info(&si_reader)?;
Ok(RPCOperationStatusA {

20
veilid-core/src/rpc_processor/coders/operations/question.rs
View File

@@ -80,52 +80,52 @@ impl RPCQuestionDetail {
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationCancelTunnelQ::decode(&op_reader)?;
RPCQuestionDetail::CancelTunnelQ(out)
}

14
veilid-core/src/rpc_processor/coders/operations/statement.rs
View File

@@ -14,7 +14,7 @@ impl RPCStatement {
pub fn detail(&self) -> &RPCStatementDetail {
&self.detail
}
pub fn into_detail(self) -> RPCQuestionDetail {
pub fn into_detail(self) -> RPCStatementDetail {
self.detail
}
pub fn desc(&self) -> &'static str {
@@ -62,32 +62,32 @@ impl RPCStatementDetail {
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
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 op_reader = r.map_err(map_error_capnp_error!())?;
let out = RPCOperationReturnReceipt::decode(&op_reader)?;
RPCStatementDetail::ReturnReceipt(out)
}

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

@@ -21,6 +21,16 @@ pub struct PrivateRoute {
pub hops: Option<RouteHop>,
}
impl PrivateRoute {
pub fn new_stub(public_key: DHTKey) -> Self {
Self {
public_key,
hop_count: 0,
hops: None,
}
}
}
impl fmt::Display for PrivateRoute {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(

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

@@ -74,9 +74,9 @@ pub fn decode_full_tunnel(
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 local = decode_tunnel_endpoint(&l_reader)?;
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!())?;
let remote = decode_tunnel_endpoint(&r_reader)?;
Ok(FullTunnel {
id,
@@ -103,7 +103,7 @@ pub fn decode_partial_tunnel(
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 local = decode_tunnel_endpoint(&l_reader)?;
Ok(PartialTunnel { id, timeout, local })
}