starpc 0.45.0 → 0.46.0

package/mock/mock_srpc.pb.rs

@@ -0,0 +1,103 @@
+// Code generated by protoc-gen-starpc-rust. DO NOT EDIT.
+// protoc-gen-starpc-rust version: v0.45.1-0.20260203090429-3e915608d4e8
+// source: github.com/aperturerobotics/starpc/mock/mock.proto
+
+#[allow(unused_imports)]
+use starpc::StreamExt;
+
+/// Service ID for Mock.
+pub const MOCK_SERVICE_ID: &str = "e2e.mock.Mock";
+
+/// Client trait for Mock.
+#[starpc::async_trait]
+pub trait MockClient: Send + Sync {
+    /// MockRequest.
+    async fn mock_request(&self, request: &MockMsg) -> starpc::Result<MockMsg>;
+}
+
+/// Client implementation for Mock.
+pub struct MockClientImpl<C> {
+    client: C,
+}
+
+impl<C: starpc::Client> MockClientImpl<C> {
+    /// Creates a new client.
+    pub fn new(client: C) -> Self {
+        Self { client }
+    }
+}
+
+#[starpc::async_trait]
+impl<C: starpc::Client + 'static> MockClient for MockClientImpl<C> {
+    async fn mock_request(&self, request: &MockMsg) -> starpc::Result<MockMsg> {
+        self.client.exec_call("e2e.mock.Mock", "MockRequest", request).await
+    }
+}
+
+/// Server trait for Mock.
+#[starpc::async_trait]
+pub trait MockServer: Send + Sync {
+    /// MockRequest.
+    async fn mock_request(&self, request: MockMsg) -> starpc::Result<MockMsg>;
+}
+
+const MOCK_METHOD_IDS: &[&str] = &[
+    "MockRequest",
+];
+
+/// Handler for Mock.
+pub struct MockHandler<S: MockServer> {
+    server: std::sync::Arc<S>,
+}
+
+impl<S: MockServer + 'static> MockHandler<S> {
+    /// Creates a new handler wrapping the server implementation.
+    pub fn new(server: S) -> Self {
+        Self { server: std::sync::Arc::new(server) }
+    }
+
+    /// Creates a new handler with a shared server.
+    pub fn with_arc(server: std::sync::Arc<S>) -> Self {
+        Self { server }
+    }
+}
+
+#[starpc::async_trait]
+impl<S: MockServer + 'static> starpc::Invoker for MockHandler<S> {
+    async fn invoke_method(
+        &self,
+        _service_id: &str,
+        method_id: &str,
+        stream: Box<dyn starpc::Stream>,
+    ) -> (bool, starpc::Result<()>) {
+        match method_id {
+            "MockRequest" => {
+                let request: MockMsg = match stream.msg_recv().await {
+                    Ok(r) => r,
+                    Err(e) => return (true, Err(e)),
+                };
+                match self.server.mock_request(request).await {
+                    Ok(response) => {
+                        if let Err(e) = stream.msg_send(&response).await {
+                            return (true, Err(e));
+                        }
+                        (true, Ok(()))
+                    }
+                    Err(e) => (true, Err(e)),
+                }
+            }
+            _ => (false, Err(starpc::Error::Unimplemented)),
+        }
+    }
+}
+
+impl<S: MockServer + 'static> starpc::Handler for MockHandler<S> {
+    fn service_id(&self) -> &'static str {
+        "e2e.mock.Mock"
+    }
+
+    fn method_ids(&self) -> &'static [&'static str] {
+        MOCK_METHOD_IDS
+    }
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.45.0",
+  "version": "0.46.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/Cargo.toml

@@ -21,6 +21,5 @@ futures = { workspace = true }
 thiserror = { workspace = true }
 async-trait = { workspace = true }
 pin-project-lite = { workspace = true }
+scopeguard = { workspace = true }
 
-[build-dependencies]
-prost-build = { workspace = true }

package/srpc/client-rpc.cpp

@@ -1,4 +1,4 @@
-// go:build deps_only
+//go:build deps_only
 
 #include "client-rpc.hpp"
 

package/srpc/client.cpp

@@ -1,4 +1,4 @@
-// go:build deps_only
+//go:build deps_only
 
 #include "client.hpp"
 

package/srpc/common-rpc.cpp

@@ -1,4 +1,4 @@
-// go:build deps_only
+//go:build deps_only
 
 #include "common-rpc.hpp"
 

package/srpc/lib.rs

@@ -66,6 +66,7 @@ pub mod mux;
 pub mod packet;
 pub mod proto;
 pub mod rpc;
+pub mod rpcstream;
 pub mod server;
 pub mod stream;
 pub mod testing;

package/srpc/mux.cpp

@@ -1,4 +1,4 @@
-// go:build deps_only
+//go:build deps_only
 
 #include "mux.hpp"
 #include <mutex>

package/srpc/packet.cpp

@@ -1,4 +1,4 @@
-// go:build deps_only
+//go:build deps_only
 
 #include "packet.hpp"
 

package/srpc/proto.rs

@@ -0,0 +1,5 @@
+//! Protocol buffer definitions for starpc.
+//!
+//! This module contains the generated protobuf types from rpcproto.proto.
+
+include!("rpcproto.pb.rs");

package/srpc/rpcproto.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-lite. DO NOT EDIT.
-// protoc-gen-go-lite version: v0.12.0
+// protoc-gen-go-lite version: v0.12.1
 // source: github.com/aperturerobotics/starpc/srpc/rpcproto.proto
 
 package srpc

package/srpc/rpcproto.pb.rs

@@ -0,0 +1,62 @@
+// @generated
+// This file is @generated by prost-build.
+/// Packet is a message sent over a srpc packet connection.
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct Packet {
+    /// Body is the packet body.
+    #[prost(oneof="packet::Body", tags="1, 2, 3")]
+    pub body: ::core::option::Option<packet::Body>,
+}
+/// Nested message and enum types in `Packet`.
+pub mod packet {
+    /// Body is the packet body.
+    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
+    pub enum Body {
+        /// CallStart initiates a new call.
+        #[prost(message, tag="1")]
+        CallStart(super::CallStart),
+        /// CallData is a message in a streaming RPC sequence.
+        #[prost(message, tag="2")]
+        CallData(super::CallData),
+        /// CallCancel cancels the call.
+        #[prost(bool, tag="3")]
+        CallCancel(bool),
+    }
+}
+/// CallStart requests starting a new RPC call.
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct CallStart {
+    /// RpcService is the service to contact.
+    /// Must be set.
+    #[prost(string, tag="1")]
+    pub rpc_service: ::prost::alloc::string::String,
+    /// RpcMethod is the RPC method to call.
+    /// Must be set.
+    #[prost(string, tag="2")]
+    pub rpc_method: ::prost::alloc::string::String,
+    /// Data contains the request or the first message in the stream.
+    /// Optional if streaming.
+    #[prost(bytes="vec", tag="3")]
+    pub data: ::prost::alloc::vec::Vec<u8>,
+    /// DataIsZero indicates Data is set with an empty message.
+    #[prost(bool, tag="4")]
+    pub data_is_zero: bool,
+}
+/// CallData contains a message in a streaming RPC sequence.
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct CallData {
+    /// Data contains the packet in the sequence.
+    #[prost(bytes="vec", tag="1")]
+    pub data: ::prost::alloc::vec::Vec<u8>,
+    /// DataIsZero indicates Data is set with an empty message.
+    #[prost(bool, tag="2")]
+    pub data_is_zero: bool,
+    /// Complete indicates the RPC call is completed.
+    #[prost(bool, tag="3")]
+    pub complete: bool,
+    /// Error contains any error that caused the RPC to fail.
+    /// If set, implies complete=true.
+    #[prost(string, tag="4")]
+    pub error: ::prost::alloc::string::String,
+}
+// @@protoc_insertion_point(module)

package/srpc/rpcproto.pb.ts

@@ -1,4 +1,4 @@
-// @generated by protoc-gen-es-lite unknown with parameter "ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
 // @generated from file github.com/aperturerobotics/starpc/srpc/rpcproto.proto (package srpc, syntax proto3)
 /* eslint-disable */
 

package/srpc/rpcstream/mod.rs

@@ -0,0 +1,38 @@
+//! RpcStream module for nested RPC calls.
+//!
+//! This module enables nesting RPC calls within RPC calls, supporting
+//! component-based architectures where different components expose different
+//! services via sub-streams.
+//!
+//! # Overview
+//!
+//! The rpcstream protocol works as follows:
+//! 1. Client opens a bidirectional stream to the server
+//! 2. Client sends `RpcStreamInit` with the target component ID
+//! 3. Server looks up the component and sends `RpcAck`
+//! 4. Both sides exchange `RpcStreamPacket::Data` containing nested RPC packets
+//!
+//! # Example
+//!
+//! ```rust,ignore
+//! use starpc::rpcstream::{open_rpc_stream, RpcStreamGetter};
+//!
+//! // Client side: open a stream to a component
+//! let stream = my_service.rpc_stream().await?;
+//! let rpc_stream = open_rpc_stream(stream, "my-component", true).await?;
+//!
+//! // Server side: handle incoming rpc stream
+//! let getter: RpcStreamGetter = Arc::new(|ctx, component_id, released| {
+//!     // Look up the invoker for this component
+//!     Some((invoker, release_fn))
+//! });
+//! handle_rpc_stream(stream, getter).await?;
+//! ```
+
+mod proto;
+mod stream;
+mod writer;
+
+pub use proto::*;
+pub use stream::*;
+pub use writer::*;

package/srpc/rpcstream/proto.rs

@@ -0,0 +1,286 @@
+//! Protocol buffer types for rpcstream.
+//!
+//! These types are defined manually to match the rpcstream.proto definitions.
+//! They will be generated via protoc-gen-prost in a future update.
+
+use bytes::{Buf, BufMut, Bytes};
+use prost::{DecodeError, Message};
+
+/// RpcStreamPacket is a packet encapsulating data for a RPC stream.
+#[derive(Clone, PartialEq, Debug, Default)]
+pub struct RpcStreamPacket {
+    /// Body of the packet.
+    pub body: Option<RpcStreamPacketBody>,
+}
+
+/// Body variants for RpcStreamPacket.
+#[derive(Clone, PartialEq, Debug)]
+pub enum RpcStreamPacketBody {
+    /// Init is the first packet in the stream, sent by the initiator.
+    Init(RpcStreamInit),
+    /// Ack is sent in response to Init, by the server.
+    Ack(RpcAck),
+    /// Data is the encapsulated data packet.
+    Data(Bytes),
+}
+
+/// RpcStreamInit is the first message in a RPC stream.
+#[derive(Clone, PartialEq, Debug, Default)]
+pub struct RpcStreamInit {
+    /// ComponentId is the identifier of the component making the request.
+    pub component_id: String,
+}
+
+/// RpcAck is the acknowledgment message in a RPC stream.
+#[derive(Clone, PartialEq, Debug, Default)]
+pub struct RpcAck {
+    /// Error indicates there was some error setting up the stream.
+    pub error: String,
+}
+
+// Manual Message implementation for RpcStreamInit
+impl Message for RpcStreamInit {
+    fn encode_raw(&self, buf: &mut impl BufMut)
+    where
+        Self: Sized,
+    {
+        if !self.component_id.is_empty() {
+            prost::encoding::string::encode(1, &self.component_id, buf);
+        }
+    }
+
+    fn merge_field(
+        &mut self,
+        tag: u32,
+        wire_type: prost::encoding::WireType,
+        buf: &mut impl Buf,
+        ctx: prost::encoding::DecodeContext,
+    ) -> Result<(), DecodeError>
+    where
+        Self: Sized,
+    {
+        match tag {
+            1 => prost::encoding::string::merge(wire_type, &mut self.component_id, buf, ctx),
+            _ => prost::encoding::skip_field(wire_type, tag, buf, ctx),
+        }
+    }
+
+    fn encoded_len(&self) -> usize {
+        let mut len = 0;
+        if !self.component_id.is_empty() {
+            len += prost::encoding::string::encoded_len(1, &self.component_id);
+        }
+        len
+    }
+
+    fn clear(&mut self) {
+        self.component_id.clear();
+    }
+}
+
+// Manual Message implementation for RpcAck
+impl Message for RpcAck {
+    fn encode_raw(&self, buf: &mut impl BufMut)
+    where
+        Self: Sized,
+    {
+        if !self.error.is_empty() {
+            prost::encoding::string::encode(1, &self.error, buf);
+        }
+    }
+
+    fn merge_field(
+        &mut self,
+        tag: u32,
+        wire_type: prost::encoding::WireType,
+        buf: &mut impl Buf,
+        ctx: prost::encoding::DecodeContext,
+    ) -> Result<(), DecodeError>
+    where
+        Self: Sized,
+    {
+        match tag {
+            1 => prost::encoding::string::merge(wire_type, &mut self.error, buf, ctx),
+            _ => prost::encoding::skip_field(wire_type, tag, buf, ctx),
+        }
+    }
+
+    fn encoded_len(&self) -> usize {
+        let mut len = 0;
+        if !self.error.is_empty() {
+            len += prost::encoding::string::encoded_len(1, &self.error);
+        }
+        len
+    }
+
+    fn clear(&mut self) {
+        self.error.clear();
+    }
+}
+
+// Manual Message implementation for RpcStreamPacket
+impl Message for RpcStreamPacket {
+    fn encode_raw(&self, buf: &mut impl BufMut)
+    where
+        Self: Sized,
+    {
+        match &self.body {
+            Some(RpcStreamPacketBody::Init(init)) => {
+                // Tag 1, wire type 2 (length-delimited)
+                prost::encoding::message::encode(1, init, buf);
+            }
+            Some(RpcStreamPacketBody::Ack(ack)) => {
+                // Tag 2, wire type 2 (length-delimited)
+                prost::encoding::message::encode(2, ack, buf);
+            }
+            Some(RpcStreamPacketBody::Data(data)) => {
+                // Tag 3, wire type 2 (length-delimited)
+                prost::encoding::bytes::encode(3, data, buf);
+            }
+            None => {}
+        }
+    }
+
+    fn merge_field(
+        &mut self,
+        tag: u32,
+        wire_type: prost::encoding::WireType,
+        buf: &mut impl Buf,
+        ctx: prost::encoding::DecodeContext,
+    ) -> Result<(), DecodeError>
+    where
+        Self: Sized,
+    {
+        match tag {
+            1 => {
+                let mut init = RpcStreamInit::default();
+                prost::encoding::message::merge(wire_type, &mut init, buf, ctx)?;
+                self.body = Some(RpcStreamPacketBody::Init(init));
+                Ok(())
+            }
+            2 => {
+                let mut ack = RpcAck::default();
+                prost::encoding::message::merge(wire_type, &mut ack, buf, ctx)?;
+                self.body = Some(RpcStreamPacketBody::Ack(ack));
+                Ok(())
+            }
+            3 => {
+                let mut data = Bytes::default();
+                prost::encoding::bytes::merge(wire_type, &mut data, buf, ctx)?;
+                self.body = Some(RpcStreamPacketBody::Data(data));
+                Ok(())
+            }
+            _ => prost::encoding::skip_field(wire_type, tag, buf, ctx),
+        }
+    }
+
+    fn encoded_len(&self) -> usize {
+        match &self.body {
+            Some(RpcStreamPacketBody::Init(init)) => prost::encoding::message::encoded_len(1, init),
+            Some(RpcStreamPacketBody::Ack(ack)) => prost::encoding::message::encoded_len(2, ack),
+            Some(RpcStreamPacketBody::Data(data)) => prost::encoding::bytes::encoded_len(3, data),
+            None => 0,
+        }
+    }
+
+    fn clear(&mut self) {
+        self.body = None;
+    }
+}
+
+impl RpcStreamPacket {
+    /// Creates a new Init packet.
+    pub fn new_init(component_id: String) -> Self {
+        Self {
+            body: Some(RpcStreamPacketBody::Init(RpcStreamInit { component_id })),
+        }
+    }
+
+    /// Creates a new Ack packet.
+    pub fn new_ack(error: String) -> Self {
+        Self {
+            body: Some(RpcStreamPacketBody::Ack(RpcAck { error })),
+        }
+    }
+
+    /// Creates a new Data packet.
+    pub fn new_data(data: Bytes) -> Self {
+        Self {
+            body: Some(RpcStreamPacketBody::Data(data)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_rpc_stream_init_encode_decode() {
+        let init = RpcStreamInit {
+            component_id: "test-component".to_string(),
+        };
+
+        let encoded = init.encode_to_vec();
+        let decoded = RpcStreamInit::decode(&encoded[..]).unwrap();
+
+        assert_eq!(init, decoded);
+    }
+
+    #[test]
+    fn test_rpc_ack_encode_decode() {
+        let ack = RpcAck {
+            error: "test error".to_string(),
+        };
+
+        let encoded = ack.encode_to_vec();
+        let decoded = RpcAck::decode(&encoded[..]).unwrap();
+
+        assert_eq!(ack, decoded);
+    }
+
+    #[test]
+    fn test_rpc_stream_packet_init() {
+        let packet = RpcStreamPacket::new_init("my-component".to_string());
+
+        let encoded = packet.encode_to_vec();
+        let decoded = RpcStreamPacket::decode(&encoded[..]).unwrap();
+
+        match decoded.body {
+            Some(RpcStreamPacketBody::Init(init)) => {
+                assert_eq!(init.component_id, "my-component");
+            }
+            _ => panic!("Expected Init body"),
+        }
+    }
+
+    #[test]
+    fn test_rpc_stream_packet_ack() {
+        let packet = RpcStreamPacket::new_ack("".to_string());
+
+        let encoded = packet.encode_to_vec();
+        let decoded = RpcStreamPacket::decode(&encoded[..]).unwrap();
+
+        match decoded.body {
+            Some(RpcStreamPacketBody::Ack(ack)) => {
+                assert!(ack.error.is_empty());
+            }
+            _ => panic!("Expected Ack body"),
+        }
+    }
+
+    #[test]
+    fn test_rpc_stream_packet_data() {
+        let packet = RpcStreamPacket::new_data(Bytes::from(vec![1, 2, 3, 4]));
+
+        let encoded = packet.encode_to_vec();
+        let decoded = RpcStreamPacket::decode(&encoded[..]).unwrap();
+
+        match decoded.body {
+            Some(RpcStreamPacketBody::Data(data)) => {
+                assert_eq!(&data[..], &[1, 2, 3, 4]);
+            }
+            _ => panic!("Expected Data body"),
+        }
+    }
+}