starpc 0.44.0 → 0.46.0

package/srpc/message.hpp

@@ -13,18 +13,16 @@ using Message = google::protobuf::MessageLite;
 
 // MarshalVT serializes the message to bytes.
 // (VT suffix matches vtprotobuf convention used in Go)
-inline bool MarshalVT(const Message& msg, std::string* out) {
+inline bool MarshalVT(const Message &msg, std::string *out) {
   return msg.SerializeToString(out);
 }
 
 // UnmarshalVT deserializes the message from bytes.
-inline bool UnmarshalVT(Message* msg, const std::string& data) {
+inline bool UnmarshalVT(Message *msg, const std::string &data) {
   return msg->ParseFromString(data);
 }
 
 // SizeVT returns the serialized size of the message.
-inline size_t SizeVT(const Message& msg) {
-  return msg.ByteSizeLong();
-}
+inline size_t SizeVT(const Message &msg) { return msg.ByteSizeLong(); }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/msg-stream.hpp

@@ -12,15 +12,16 @@ namespace starpc {
 // MsgStreamRw is the read-write interface for MsgStream.
 // Matches Go MsgStreamRw interface in msg-stream.go
 class MsgStreamRw {
- public:
+public:
   virtual ~MsgStreamRw() = default;
 
   // ReadOne reads a single message and returns.
   // Returns EOF_ if the stream ended.
-  virtual Error ReadOne(std::string* out) = 0;
+  virtual Error ReadOne(std::string *out) = 0;
 
   // WriteCallData writes a call data packet.
-  virtual Error WriteCallData(const std::string& data, bool data_is_zero, bool complete, Error err) = 0;
+  virtual Error WriteCallData(const std::string &data, bool data_is_zero,
+                              bool complete, Error err) = 0;
 
   // WriteCallCancel writes a call cancel (close) packet.
   virtual Error WriteCallCancel() = 0;
@@ -29,13 +30,13 @@ class MsgStreamRw {
 // MsgStream implements the stream interface passed to implementations.
 // Matches Go MsgStream struct in msg-stream.go
 class MsgStream : public Stream {
- public:
+public:
   // Constructor matching NewMsgStream in Go
-  MsgStream(MsgStreamRw* rw, std::function<void()> close_cb)
+  MsgStream(MsgStreamRw *rw, std::function<void()> close_cb)
       : rw_(rw), close_cb_(std::move(close_cb)) {}
 
   // MsgSend sends the message to the remote.
-  Error MsgSend(const Message& msg) override {
+  Error MsgSend(const Message &msg) override {
     std::string msg_data;
     if (!msg.SerializeToString(&msg_data)) {
       return Error::InvalidMessage;
@@ -44,7 +45,7 @@ class MsgStream : public Stream {
   }
 
   // MsgRecv receives an incoming message from the remote.
-  Error MsgRecv(Message* msg) override {
+  Error MsgRecv(Message *msg) override {
     std::string data;
     Error err = rw_->ReadOne(&data);
     if (err != Error::OK) {
@@ -70,15 +71,16 @@ class MsgStream : public Stream {
     return err;
   }
 
- private:
-  MsgStreamRw* rw_;
+private:
+  MsgStreamRw *rw_;
   std::function<void()> close_cb_;
 };
 
 // NewMsgStream constructs a new Stream with a MsgStreamRw.
 // Matches Go NewMsgStream function in msg-stream.go
-inline std::unique_ptr<MsgStream> NewMsgStream(MsgStreamRw* rw, std::function<void()> close_cb) {
+inline std::unique_ptr<MsgStream> NewMsgStream(MsgStreamRw *rw,
+                                               std::function<void()> close_cb) {
   return std::make_unique<MsgStream>(rw, std::move(close_cb));
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/mux.cpp

@@ -1,14 +1,15 @@
 //go:build deps_only
 
 #include "mux.hpp"
+#include <mutex>
 
 namespace starpc {
 
-Mux::Mux(std::vector<Invoker*> fallback_invokers)
+Mux::Mux(std::vector<Invoker *> fallback_invokers)
     : fallback_(std::move(fallback_invokers)) {}
 
-Error Mux::Register(Handler* handler) {
-  const std::string& service_id = handler->GetServiceID();
+Error Mux::Register(Handler *handler) {
+  const std::string &service_id = handler->GetServiceID();
   auto method_ids = handler->GetMethodIDs();
 
   if (service_id.empty()) {
@@ -17,8 +18,8 @@ Error Mux::Register(Handler* handler) {
 
   std::unique_lock<std::shared_mutex> lock(mtx_);
 
-  auto& service_methods = services_[service_id];
-  for (const auto& method_id : method_ids) {
+  auto &service_methods = services_[service_id];
+  for (const auto &method_id : method_ids) {
     if (!method_id.empty()) {
       service_methods[method_id] = handler;
     }
@@ -27,7 +28,7 @@ Error Mux::Register(Handler* handler) {
   return Error::OK;
 }
 
-bool Mux::HasService(const std::string& service_id) const {
+bool Mux::HasService(const std::string &service_id) const {
   if (service_id.empty()) {
     return false;
   }
@@ -37,7 +38,8 @@ bool Mux::HasService(const std::string& service_id) const {
   return it != services_.end() && !it->second.empty();
 }
 
-bool Mux::HasServiceMethod(const std::string& service_id, const std::string& method_id) const {
+bool Mux::HasServiceMethod(const std::string &service_id,
+                           const std::string &method_id) const {
   if (service_id.empty() || method_id.empty()) {
     return false;
   }
@@ -48,8 +50,8 @@ bool Mux::HasServiceMethod(const std::string& service_id, const std::string& met
     return false;
   }
 
-  for (const auto& [mid, handler] : svc_it->second) {
-    for (const auto& handler_method : handler->GetMethodIDs()) {
+  for (const auto &[mid, handler] : svc_it->second) {
+    for (const auto &handler_method : handler->GetMethodIDs()) {
       if (handler_method == method_id) {
         return true;
       }
@@ -59,18 +61,17 @@ bool Mux::HasServiceMethod(const std::string& service_id, const std::string& met
   return false;
 }
 
-std::pair<bool, Error> Mux::InvokeMethod(
-    const std::string& service_id,
-    const std::string& method_id,
-    Stream* strm) {
-  Handler* handler = nullptr;
+std::pair<bool, Error> Mux::InvokeMethod(const std::string &service_id,
+                                         const std::string &method_id,
+                                         Stream *strm) {
+  Handler *handler = nullptr;
 
   {
     std::shared_lock<std::shared_mutex> lock(mtx_);
 
     if (service_id.empty()) {
       // If service string is empty, search all services
-      for (const auto& [svc_id, svc_methods] : services_) {
+      for (const auto &[svc_id, svc_methods] : services_) {
         auto it = svc_methods.find(method_id);
         if (it != svc_methods.end()) {
           handler = it->second;
@@ -93,7 +94,7 @@ std::pair<bool, Error> Mux::InvokeMethod(
   }
 
   // Try fallback invokers
-  for (auto* invoker : fallback_) {
+  for (auto *invoker : fallback_) {
     if (invoker != nullptr) {
       auto [handled, err] = invoker->InvokeMethod(service_id, method_id, strm);
       if (err != Error::OK || handled) {
@@ -105,4 +106,4 @@ std::pair<bool, Error> Mux::InvokeMethod(
   return {false, Error::OK};
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/mux.hpp

@@ -14,38 +14,38 @@ namespace starpc {
 // Mux contains a set of <service, method> handlers.
 // Matches Go Mux interface in mux.go
 class Mux : public Invoker, public QueryableInvoker {
- public:
+public:
   // Constructor matching NewMux in Go
-  explicit Mux(std::vector<Invoker*> fallback_invokers = {});
+  explicit Mux(std::vector<Invoker *> fallback_invokers = {});
   ~Mux() override = default;
 
   // Register registers a new RPC method handler (service).
   // Matches Go Register in mux.go
-  Error Register(Handler* handler);
+  Error Register(Handler *handler);
 
   // InvokeMethod invokes the method matching the service & method ID.
   // Returns {found, error} - found is false if method not found.
   // If service string is empty, ignore it.
   // Matches Go InvokeMethod in mux.go
-  std::pair<bool, Error> InvokeMethod(
-      const std::string& service_id,
-      const std::string& method_id,
-      Stream* strm) override;
+  std::pair<bool, Error> InvokeMethod(const std::string &service_id,
+                                      const std::string &method_id,
+                                      Stream *strm) override;
 
   // HasService checks if the service ID exists in the handlers.
   // Matches Go HasService in mux.go
-  bool HasService(const std::string& service_id) const override;
+  bool HasService(const std::string &service_id) const override;
 
   // HasServiceMethod checks if <service-id, method-id> exists in the handlers.
   // Matches Go HasServiceMethod in mux.go
-  bool HasServiceMethod(const std::string& service_id, const std::string& method_id) const override;
+  bool HasServiceMethod(const std::string &service_id,
+                        const std::string &method_id) const override;
 
- private:
+private:
   // Mapping from method id to handler
-  using MuxMethods = std::unordered_map<std::string, Handler*>;
+  using MuxMethods = std::unordered_map<std::string, Handler *>;
 
   // Fallback invokers
-  std::vector<Invoker*> fallback_;
+  std::vector<Invoker *> fallback_;
 
   // Read-write mutex guards services_
   mutable std::shared_mutex mtx_;
@@ -56,8 +56,9 @@ class Mux : public Invoker, public QueryableInvoker {
 
 // NewMux constructs a new Mux.
 // Matches Go NewMux function in mux.go
-inline std::unique_ptr<Mux> NewMux(std::vector<Invoker*> fallback_invokers = {}) {
+inline std::unique_ptr<Mux>
+NewMux(std::vector<Invoker *> fallback_invokers = {}) {
   return std::make_unique<Mux>(std::move(fallback_invokers));
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/packet.cpp

@@ -7,7 +7,7 @@
 namespace starpc {
 
 PacketDataHandler NewPacketDataHandler(PacketHandler handler) {
-  return [handler](const std::string& data) -> Error {
+  return [handler](const std::string &data) -> Error {
     srpc::Packet pkt;
     if (!pkt.ParseFromString(data)) {
       return Error::InvalidMessage;
@@ -16,20 +16,20 @@ PacketDataHandler NewPacketDataHandler(PacketHandler handler) {
   };
 }
 
-Error ValidatePacket(const srpc::Packet& pkt) {
+Error ValidatePacket(const srpc::Packet &pkt) {
   switch (pkt.body_case()) {
-    case srpc::Packet::kCallStart:
-      return ValidateCallStart(pkt.call_start());
-    case srpc::Packet::kCallData:
-      return ValidateCallData(pkt.call_data());
-    case srpc::Packet::kCallCancel:
-      return Error::OK;
-    default:
-      return Error::UnrecognizedPacket;
+  case srpc::Packet::kCallStart:
+    return ValidateCallStart(pkt.call_start());
+  case srpc::Packet::kCallData:
+    return ValidateCallData(pkt.call_data());
+  case srpc::Packet::kCallCancel:
+    return Error::OK;
+  default:
+    return Error::UnrecognizedPacket;
   }
 }
 
-Error ValidateCallStart(const srpc::CallStart& pkt) {
+Error ValidateCallStart(const srpc::CallStart &pkt) {
   if (pkt.rpc_method().empty()) {
     return Error::EmptyMethodID;
   }
@@ -39,20 +39,20 @@ Error ValidateCallStart(const srpc::CallStart& pkt) {
   return Error::OK;
 }
 
-Error ValidateCallData(const srpc::CallData& pkt) {
-  if (pkt.data().empty() && !pkt.complete() && pkt.error().empty() && !pkt.data_is_zero()) {
+Error ValidateCallData(const srpc::CallData &pkt) {
+  if (pkt.data().empty() && !pkt.complete() && pkt.error().empty() &&
+      !pkt.data_is_zero()) {
     return Error::EmptyPacket;
   }
   return Error::OK;
 }
 
-std::unique_ptr<srpc::Packet> NewCallStartPacket(
-    const std::string& service,
-    const std::string& method,
-    const std::string& data,
-    bool data_is_zero) {
+std::unique_ptr<srpc::Packet> NewCallStartPacket(const std::string &service,
+                                                 const std::string &method,
+                                                 const std::string &data,
+                                                 bool data_is_zero) {
   auto pkt = std::make_unique<srpc::Packet>();
-  auto* call_start = pkt->mutable_call_start();
+  auto *call_start = pkt->mutable_call_start();
   call_start->set_rpc_service(service);
   call_start->set_rpc_method(method);
   call_start->set_data(data);
@@ -60,13 +60,11 @@ std::unique_ptr<srpc::Packet> NewCallStartPacket(
   return pkt;
 }
 
-std::unique_ptr<srpc::Packet> NewCallDataPacket(
-    const std::string& data,
-    bool data_is_zero,
-    bool complete,
-    Error err) {
+std::unique_ptr<srpc::Packet> NewCallDataPacket(const std::string &data,
+                                                bool data_is_zero,
+                                                bool complete, Error err) {
   auto pkt = std::make_unique<srpc::Packet>();
-  auto* call_data = pkt->mutable_call_data();
+  auto *call_data = pkt->mutable_call_data();
   call_data->set_data(data);
   call_data->set_data_is_zero(data_is_zero);
   call_data->set_complete(err != Error::OK || complete);
@@ -82,4 +80,4 @@ std::unique_ptr<srpc::Packet> NewCallCancelPacket() {
   return pkt;
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/packet.hpp

@@ -11,7 +11,7 @@ namespace srpc {
 class Packet;
 class CallStart;
 class CallData;
-}  // namespace srpc
+} // namespace srpc
 
 namespace starpc {
 
@@ -21,39 +21,36 @@ using CloseHandler = std::function<void(Error close_err)>;
 
 // PacketHandler handles a packet.
 // Matches Go PacketHandler in packet.go
-using PacketHandler = std::function<Error(const srpc::Packet& pkt)>;
+using PacketHandler = std::function<Error(const srpc::Packet &pkt)>;
 
 // PacketDataHandler handles a packet before it is parsed.
 // Matches Go PacketDataHandler in packet.go
-using PacketDataHandler = std::function<Error(const std::string& data)>;
+using PacketDataHandler = std::function<Error(const std::string &data)>;
 
 // NewPacketDataHandler wraps a PacketHandler with a decoding step.
 PacketDataHandler NewPacketDataHandler(PacketHandler handler);
 
 // Validate performs cursory validation of a Packet.
-Error ValidatePacket(const srpc::Packet& pkt);
+Error ValidatePacket(const srpc::Packet &pkt);
 
 // Validate performs cursory validation of a CallStart.
-Error ValidateCallStart(const srpc::CallStart& pkt);
+Error ValidateCallStart(const srpc::CallStart &pkt);
 
 // Validate performs cursory validation of a CallData.
-Error ValidateCallData(const srpc::CallData& pkt);
+Error ValidateCallData(const srpc::CallData &pkt);
 
 // NewCallStartPacket constructs a new CallStart packet.
-std::unique_ptr<srpc::Packet> NewCallStartPacket(
-    const std::string& service,
-    const std::string& method,
-    const std::string& data,
-    bool data_is_zero);
+std::unique_ptr<srpc::Packet> NewCallStartPacket(const std::string &service,
+                                                 const std::string &method,
+                                                 const std::string &data,
+                                                 bool data_is_zero);
 
 // NewCallDataPacket constructs a new CallData packet.
-std::unique_ptr<srpc::Packet> NewCallDataPacket(
-    const std::string& data,
-    bool data_is_zero,
-    bool complete,
-    Error err);
+std::unique_ptr<srpc::Packet> NewCallDataPacket(const std::string &data,
+                                                bool data_is_zero,
+                                                bool complete, Error err);
 
 // NewCallCancelPacket constructs a new CallCancel packet with cancel.
 std::unique_ptr<srpc::Packet> NewCallCancelPacket();
 
-}  // namespace starpc
+} // namespace starpc

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::*;