private routing

veilid-core/src/rpc_processor/coders/operations/operation_status.rs

@@ -3,42 +3,59 @@ use rpc_processor::*;
 
 #[derive(Debug, Clone)]
 pub struct RPCOperationStatusQ {
-    pub node_status: NodeStatus,
+    pub node_status: Option<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(RPCError::protocol)?;
-        let node_status = decode_node_status(&ns_reader)?;
+        let node_status = if reader.has_node_status() {
+            let ns_reader = reader.get_node_status().map_err(RPCError::protocol)?;
+            let node_status = decode_node_status(&ns_reader)?;
+            Some(node_status)
+        } else {
+            None
+        };
         Ok(RPCOperationStatusQ { node_status })
     }
     pub fn encode(
         &self,
         builder: &mut veilid_capnp::operation_status_q::Builder,
     ) -> Result<(), RPCError> {
-        let mut ns_builder = builder.reborrow().init_node_status();
-        encode_node_status(&self.node_status, &mut ns_builder)?;
+        if let Some(ns) = &self.node_status {
+            let mut ns_builder = builder.reborrow().init_node_status();
+            encode_node_status(&ns, &mut ns_builder)?;
+        }
         Ok(())
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct RPCOperationStatusA {
-    pub node_status: NodeStatus,
-    pub sender_info: SenderInfo,
+    pub node_status: Option<NodeStatus>,
+    pub sender_info: Option<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(RPCError::protocol)?;
-        let node_status = decode_node_status(&ns_reader)?;
+        let node_status = if reader.has_node_status() {
+            let ns_reader = reader.get_node_status().map_err(RPCError::protocol)?;
+            let node_status = decode_node_status(&ns_reader)?;
+            Some(node_status)
+        } else {
+            None
+        };
 
-        let si_reader = reader.get_sender_info().map_err(RPCError::protocol)?;
-        let sender_info = decode_sender_info(&si_reader)?;
+        let sender_info = if reader.has_sender_info() {
+            let si_reader = reader.get_sender_info().map_err(RPCError::protocol)?;
+            let sender_info = decode_sender_info(&si_reader)?;
+            Some(sender_info)
+        } else {
+            None
+        };
 
         Ok(RPCOperationStatusA {
             node_status,
@@ -49,10 +66,14 @@ impl RPCOperationStatusA {
         &self,
         builder: &mut veilid_capnp::operation_status_a::Builder,
     ) -> Result<(), RPCError> {
-        let mut ns_builder = builder.reborrow().init_node_status();
-        encode_node_status(&self.node_status, &mut ns_builder)?;
-        let mut si_builder = builder.reborrow().init_sender_info();
-        encode_sender_info(&self.sender_info, &mut si_builder)?;
+        if let Some(ns) = &self.node_status {
+            let mut ns_builder = builder.reborrow().init_node_status();
+            encode_node_status(&ns, &mut ns_builder)?;
+        }
+        if let Some(si) = &self.sender_info {
+            let mut si_builder = builder.reborrow().init_sender_info();
+            encode_sender_info(&si, &mut si_builder)?;
+        }
         Ok(())
     }
 }

veilid-core/src/rpc_processor/coders/sender_info.rs

@@ -5,30 +5,21 @@ pub fn encode_sender_info(
     sender_info: &SenderInfo,
     builder: &mut veilid_capnp::sender_info::Builder,
 ) -> Result<(), RPCError> {
-    if let Some(socket_address) = &sender_info.socket_address {
-        let mut sab = builder.reborrow().init_socket_address();
-        encode_socket_address(socket_address, &mut sab)?;
-    }
+    let mut sab = builder.reborrow().init_socket_address();
+    encode_socket_address(&sender_info.socket_address, &mut sab)?;
     Ok(())
 }
 
 pub fn decode_sender_info(
     reader: &veilid_capnp::sender_info::Reader,
 ) -> Result<SenderInfo, RPCError> {
-    if !reader.has_socket_address() {
-        return Err(RPCError::internal("invalid socket address type"));
-    }
-    let socket_address = if reader.has_socket_address() {
-        Some(decode_socket_address(
-            &reader
-                .reborrow()
-                .get_socket_address()
-                .map_err(RPCError::map_internal(
-                    "invalid socket address in sender_info",
-                ))?,
-        )?)
-    } else {
-        None
-    };
+    let sa_reader = reader
+        .reborrow()
+        .get_socket_address()
+        .map_err(RPCError::map_internal(
+            "invalid socket address in sender_info",
+        ))?;
+    let socket_address = decode_socket_address(&sa_reader)?;
+
     Ok(SenderInfo { socket_address })
 }