refactor api to clean up internals

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

@@ -19,11 +19,13 @@ mod signature512;
 mod signed_direct_node_info;
 mod signed_node_info;
 mod signed_relayed_node_info;
+mod signed_value_data;
+mod signed_value_descriptor;
 mod socket_address;
 mod tunnel;
 mod typed_key;
 mod typed_signature;
-mod value_data;
+mod value_detail;
 
 pub use address::*;
 pub use address_type_set::*;
@@ -46,10 +48,12 @@ pub use signature512::*;
 pub use signed_direct_node_info::*;
 pub use signed_node_info::*;
 pub use signed_relayed_node_info::*;
+pub use signed_value_data::*;
+pub use signed_value_descriptor::*;
 pub use socket_address::*;
 pub use tunnel::*;
 pub use typed_key::*;
 pub use typed_signature::*;
-pub use value_data::*;
+pub use value_detail::*;
 
 use super::*;

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

@@ -0,0 +1,31 @@
+use super::*;
+use crate::storage_manager::*;
+
+pub fn encode_signed_value_data(
+    signed_value_data: &SignedValueData,
+    builder: &mut veilid_capnp::signed_value_data::Builder,
+) -> Result<(), RPCError> {
+    builder.set_seq(signed_value_data.value_data().seq());
+    builder.set_data(signed_value_data.value_data().data());
+    let mut wb = builder.reborrow().init_writer();
+    encode_key256(signed_value_data.value_data().writer(), &mut wb);
+    let mut sb = builder.reborrow().init_signature();
+    encode_signature512(signed_value_data.signature(), &mut sb);
+    Ok(())
+}
+
+pub fn decode_signed_value_data(
+    reader: &veilid_capnp::signed_value_data::Reader,
+) -> Result<ValueData, RPCError> {
+    let seq = reader.get_seq();
+    let data = reader.get_data().map_err(RPCError::protocol)?.to_vec();
+    let wr = reader.get_writer().map_err(RPCError::protocol)?;
+    let writer = decode_key256(&wr);
+    let sr = reader.get_signature().map_err(RPCError::protocol)?;
+    let signature = decode_signature512(&sr);
+
+    Ok(SignedValueData {
+        value_data: ValueData { seq, data, writer },
+        signature,
+    })
+}

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

@@ -0,0 +1,26 @@
+use super::*;
+use crate::storage_manager::SignedValueDescriptor;
+
+pub fn encode_signed_value_descriptor(
+    signed_value_descriptor: &SignedValueDescriptor,
+    builder: &mut veilid_capnp::signed_value_descriptor::Builder,
+) -> Result<(), RPCError> {
+    let mut ob = builder.reborrow().init_owner();
+    encode_key256(signed_value_descriptor.owner(), &mut ob);
+    builder.set_data(signed_value_descriptor.data());
+    let mut sb = builder.reborrow().init_signature();
+    encode_signature512(signed_value_descriptor.signature(), &mut sb);
+    Ok(())
+}
+
+pub fn decode_signed_value_descriptor(
+    reader: &veilid_capnp::signed_value_descriptor::Reader,
+    vcrypto: CryptoSystemVersion,
+) -> Result<SignedValueDescriptor, RPCError> {
+    let or = reader.get_owner().map_err(RPCError::protocol)?;
+    let owner = decode_key256(&or);
+    let data = reader.get_data().map_err(RPCError::protocol)?.to_vec();
+    let sr = reader.get_signature().map_err(RPCError::protocol)?;
+    let signature = decode_signature512(&sr);
+    Ok(SignedValueDescriptor::new(owner, data, signature, vcrypto).map_err(RPCError::protocol)?)
+}

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

@@ -1,18 +0,0 @@
-use super::*;
-
-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_schema(u32::from_be_bytes(value_data.schema.0));
-    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(RPCError::protocol)?.to_vec();
-    let seq = reader.get_seq();
-    let schema = FourCC::from(reader.get_schema().to_be_bytes());
-    Ok(ValueData { data, schema, seq })
-}

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

@@ -0,0 +1,20 @@
+use super::*;
+use crate::storage_manager::ValueDetail;
+
+pub fn encode_value_detail(
+    value_detail: &ValueDetail,
+    builder: &mut veilid_capnp::value_detail::Builder,
+) -> Result<(), RPCError> {
+    let mut svdb = builder.reborrow().init_signed_value_data();
+
+    Ok(())
+}
+
+pub fn decode_value_detail(
+    reader: &veilid_capnp::value_detail::Reader,
+) -> Result<ValueDetail, RPCError> {
+    Ok(ValueDetail {
+        signed_value_data,
+        descriptor,
+    })
+}

veilid-core/src/rpc_processor/mod.rs

@@ -387,7 +387,7 @@ impl RPCProcessor {
         _node_id: PublicKey,
         _count: u32,
         _fanout: u32,
-        _timeout: Option<u64>,
+        _timeout: TimestampDuration,
     ) -> Result<Option<NodeRef>, RPCError> {
         //let routing_table = self.routing_table();
 
@@ -402,7 +402,7 @@ impl RPCProcessor {
         _node_id: PublicKey,
         _count: u32,
         _fanout: u32,
-        _timeout: Option<u64>,
+        _timeout: TimestampDuration,
     ) -> Result<Vec<NodeRef>, RPCError> {
         // xxx return closest nodes after the timeout
         Err(RPCError::unimplemented("search_dht_multi_key")).map_err(logthru_rpc!(error))
@@ -433,7 +433,7 @@ impl RPCProcessor {
                 (
                     c.network.dht.resolve_node_count,
                     c.network.dht.resolve_node_fanout,
-                    c.network.dht.resolve_node_timeout_ms.map(ms_to_us),
+                    TimestampDuration::from(ms_to_us(c.network.dht.resolve_node_timeout_ms)),
                 )
             };