starpc 0.44.0 → 0.46.0

package/srpc/server-rpc.cpp

@@ -7,7 +7,7 @@
 
 namespace starpc {
 
-ServerRPC::ServerRPC(Invoker* invoker, PacketWriter* writer)
+ServerRPC::ServerRPC(Invoker *invoker, PacketWriter *writer)
     : invoker_(invoker) {
   Init();
   writer_ = writer;
@@ -19,7 +19,7 @@ ServerRPC::~ServerRPC() {
   }
 }
 
-Error ServerRPC::HandlePacketData(const std::string& data) {
+Error ServerRPC::HandlePacketData(const std::string &data) {
   srpc::Packet msg;
   if (!msg.ParseFromString(data)) {
     return Error::InvalidMessage;
@@ -27,33 +27,33 @@ Error ServerRPC::HandlePacketData(const std::string& data) {
   return HandlePacket(msg);
 }
 
-Error ServerRPC::HandlePacket(const srpc::Packet& msg) {
+Error ServerRPC::HandlePacket(const srpc::Packet &msg) {
   Error err = ValidatePacket(msg);
   if (err != Error::OK) {
     return err;
   }
 
   switch (msg.body_case()) {
-    case srpc::Packet::kCallStart:
-      return HandleCallStart(msg.call_start());
-    case srpc::Packet::kCallData:
-      return HandleCallData(msg.call_data());
-    case srpc::Packet::kCallCancel:
-      if (msg.call_cancel()) {
-        return HandleCallCancel();
-      }
-      return Error::OK;
-    default:
-      return Error::OK;
+  case srpc::Packet::kCallStart:
+    return HandleCallStart(msg.call_start());
+  case srpc::Packet::kCallData:
+    return HandleCallData(msg.call_data());
+  case srpc::Packet::kCallCancel:
+    if (msg.call_cancel()) {
+      return HandleCallCancel();
+    }
+    return Error::OK;
+  default:
+    return Error::OK;
   }
 }
 
-Error ServerRPC::HandleCallStart(const srpc::CallStart& pkt) {
+Error ServerRPC::HandleCallStart(const srpc::CallStart &pkt) {
   std::lock_guard<std::mutex> lock(mtx_);
 
   // process start: method and service
   if (!method_.empty() || !service_.empty()) {
-    return Error::Completed;  // call start must be sent only once
+    return Error::Completed; // call start must be sent only once
   }
   if (data_closed_) {
     return Error::Completed;
@@ -72,14 +72,14 @@ Error ServerRPC::HandleCallStart(const srpc::CallStart& pkt) {
   std::string method_id = method_;
   cv_.notify_all();
 
-  invoke_thread_ = std::thread([this, service_id, method_id]() {
-    InvokeRPC(service_id, method_id);
-  });
+  invoke_thread_ = std::thread(
+      [this, service_id, method_id]() { InvokeRPC(service_id, method_id); });
 
   return Error::OK;
 }
 
-void ServerRPC::InvokeRPC(const std::string& service_id, const std::string& method_id) {
+void ServerRPC::InvokeRPC(const std::string &service_id,
+                          const std::string &method_id) {
   // On the server side, the writer is closed by invokeRPC.
   auto strm = NewMsgStream(this, [this]() { Cancel(); });
 
@@ -94,4 +94,4 @@ void ServerRPC::InvokeRPC(const std::string& service_id, const std::string& meth
   Cancel();
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/server-rpc.hpp

@@ -12,50 +12,52 @@
 namespace srpc {
 class Packet;
 class CallStart;
-}  // namespace srpc
+} // namespace srpc
 
 namespace starpc {
 
 // ServerRPC represents the server side of an on-going RPC call message stream.
 // Matches Go ServerRPC struct in server-rpc.go
 class ServerRPC : public CommonRPC, public MsgStreamRw {
- public:
+public:
   // Constructor matching NewServerRPC in Go
-  ServerRPC(Invoker* invoker, PacketWriter* writer);
+  ServerRPC(Invoker *invoker, PacketWriter *writer);
   ~ServerRPC() override;
 
   // HandlePacketData handles an incoming unparsed message packet.
   // Matches Go HandlePacketData in server-rpc.go
-  Error HandlePacketData(const std::string& data);
+  Error HandlePacketData(const std::string &data);
 
   // HandlePacket handles an incoming parsed message packet.
   // Matches Go HandlePacket in server-rpc.go
-  Error HandlePacket(const srpc::Packet& msg);
+  Error HandlePacket(const srpc::Packet &msg);
 
   // HandleCallStart handles the call start packet.
   // Matches Go HandleCallStart in server-rpc.go
-  Error HandleCallStart(const srpc::CallStart& pkt);
+  Error HandleCallStart(const srpc::CallStart &pkt);
 
   // MsgStreamRw interface implementation
-  Error ReadOne(std::string* out) override { return CommonRPC::ReadOne(out); }
-  Error WriteCallData(const std::string& data, bool data_is_zero, bool complete, Error err) override {
+  Error ReadOne(std::string *out) override { return CommonRPC::ReadOne(out); }
+  Error WriteCallData(const std::string &data, bool data_is_zero, bool complete,
+                      Error err) override {
     return CommonRPC::WriteCallData(data, data_is_zero, complete, err);
   }
   Error WriteCallCancel() override { return CommonRPC::WriteCallCancel(); }
 
- private:
+private:
   // InvokeRPC invokes the RPC after CallStart is received.
   // Matches Go invokeRPC in server-rpc.go
-  void InvokeRPC(const std::string& service_id, const std::string& method_id);
+  void InvokeRPC(const std::string &service_id, const std::string &method_id);
 
-  Invoker* invoker_;
+  Invoker *invoker_;
   std::thread invoke_thread_;
 };
 
 // NewServerRPC constructs a new ServerRPC session.
 // Matches Go NewServerRPC function in server-rpc.go
-inline std::unique_ptr<ServerRPC> NewServerRPC(Invoker* invoker, PacketWriter* writer) {
+inline std::unique_ptr<ServerRPC> NewServerRPC(Invoker *invoker,
+                                               PacketWriter *writer) {
   return std::make_unique<ServerRPC>(invoker, writer);
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/starpc.hpp

@@ -3,8 +3,8 @@
 // Main header for starpc C++ library
 // Include this to get all starpc functionality
 
-#include "client.hpp"
 #include "client-rpc.hpp"
+#include "client.hpp"
 #include "common-rpc.hpp"
 #include "errors.hpp"
 #include "handler.hpp"

package/srpc/stream.hpp

@@ -8,18 +8,18 @@
 
 namespace starpc {
 
-// Stream is a handle to an on-going bi-directional or one-directional stream RPC handle.
-// Matches Go Stream interface in stream.go
+// Stream is a handle to an on-going bi-directional or one-directional stream
+// RPC handle. Matches Go Stream interface in stream.go
 class Stream {
- public:
+public:
   virtual ~Stream() = default;
 
   // MsgSend sends the message to the remote.
-  virtual Error MsgSend(const Message& msg) = 0;
+  virtual Error MsgSend(const Message &msg) = 0;
 
   // MsgRecv receives an incoming message from the remote.
   // Parses the message into the object at msg.
-  virtual Error MsgRecv(Message* msg) = 0;
+  virtual Error MsgRecv(Message *msg) = 0;
 
   // CloseSend signals to the remote that we will no longer send any messages.
   virtual Error CloseSend() = 0;
@@ -28,32 +28,34 @@ class Stream {
   virtual Error Close() = 0;
 };
 
-// StreamWithClose wraps a Stream with a close function to call when Close is called.
-// Matches streamWithClose in stream.go
+// StreamWithClose wraps a Stream with a close function to call when Close is
+// called. Matches streamWithClose in stream.go
 class StreamWithClose : public Stream {
- public:
-  StreamWithClose(Stream* inner, std::function<Error()> close_fn)
+public:
+  StreamWithClose(Stream *inner, std::function<Error()> close_fn)
       : inner_(inner), close_fn_(std::move(close_fn)) {}
 
-  Error MsgSend(const Message& msg) override { return inner_->MsgSend(msg); }
-  Error MsgRecv(Message* msg) override { return inner_->MsgRecv(msg); }
+  Error MsgSend(const Message &msg) override { return inner_->MsgSend(msg); }
+  Error MsgRecv(Message *msg) override { return inner_->MsgRecv(msg); }
   Error CloseSend() override { return inner_->CloseSend(); }
 
   Error Close() override {
     Error err = inner_->Close();
     Error err2 = close_fn_();
-    if (err != Error::OK) return err;
+    if (err != Error::OK)
+      return err;
     return err2;
   }
 
- private:
-  Stream* inner_;
+private:
+  Stream *inner_;
   std::function<Error()> close_fn_;
 };
 
 // NewStreamWithClose wraps a Stream with a close function.
-inline std::unique_ptr<Stream> NewStreamWithClose(Stream* strm, std::function<Error()> close_fn) {
+inline std::unique_ptr<Stream>
+NewStreamWithClose(Stream *strm, std::function<Error()> close_fn) {
   return std::make_unique<StreamWithClose>(strm, std::move(close_fn));
 }
 
-}  // namespace starpc
+} // namespace starpc

package/srpc/writer.hpp

@@ -14,11 +14,11 @@ namespace starpc {
 // PacketWriter is the interface used to write messages to a PacketStream.
 // Matches Go interface in writer.go
 class PacketWriter {
- public:
+public:
   virtual ~PacketWriter() = default;
 
   // WritePacket writes a packet to the remote.
-  virtual Error WritePacket(const srpc::Packet& pkt) = 0;
+  virtual Error WritePacket(const srpc::Packet &pkt) = 0;
 
   // Close closes the writer.
   virtual Error Close() = 0;
@@ -27,31 +27,34 @@ class PacketWriter {
 // PacketWriterWithClose wraps a PacketWriter with an additional close function.
 // Matches packetWriterWithClose in writer.go
 class PacketWriterWithClose : public PacketWriter {
- public:
-  PacketWriterWithClose(std::unique_ptr<PacketWriter> inner, std::function<Error()> close_fn)
+public:
+  PacketWriterWithClose(std::unique_ptr<PacketWriter> inner,
+                        std::function<Error()> close_fn)
       : inner_(std::move(inner)), close_fn_(std::move(close_fn)) {}
 
-  Error WritePacket(const srpc::Packet& pkt) override {
+  Error WritePacket(const srpc::Packet &pkt) override {
     return inner_->WritePacket(pkt);
   }
 
   Error Close() override {
     Error err = inner_->Close();
     Error err2 = close_fn_();
-    if (err != Error::OK) return err;
+    if (err != Error::OK)
+      return err;
     return err2;
   }
 
- private:
+private:
   std::unique_ptr<PacketWriter> inner_;
   std::function<Error()> close_fn_;
 };
 
 // NewPacketWriterWithClose wraps a PacketWriter with a close function.
-inline std::unique_ptr<PacketWriter> NewPacketWriterWithClose(
-    std::unique_ptr<PacketWriter> prw,
-    std::function<Error()> close_fn) {
-  return std::make_unique<PacketWriterWithClose>(std::move(prw), std::move(close_fn));
+inline std::unique_ptr<PacketWriter>
+NewPacketWriterWithClose(std::unique_ptr<PacketWriter> prw,
+                         std::function<Error()> close_fn) {
+  return std::make_unique<PacketWriterWithClose>(std::move(prw),
+                                                 std::move(close_fn));
 }
 
-}  // namespace starpc
+} // namespace starpc

package/echo/build.rs

@@ -1,15 +0,0 @@
-use std::io::Result;
-use std::path::PathBuf;
-
-fn main() -> Result<()> {
-    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    // Use simplified proto without rpcstream dependency
-    let proto_path = manifest_dir.join("echo_rust.proto");
-
-    println!("cargo:rerun-if-changed={}", proto_path.display());
-
-    starpc_build::configure()
-        .compile_protos(&[proto_path], &[&manifest_dir])?;
-
-    Ok(())
-}

package/srpc/build.rs

@@ -1,15 +0,0 @@
-use std::io::Result;
-use std::path::PathBuf;
-
-fn main() -> Result<()> {
-    // Get the path to the proto file in the same directory.
-    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    let proto_path = manifest_dir.join("rpcproto.proto");
-
-    println!("cargo:rerun-if-changed={}", proto_path.display());
-
-    prost_build::Config::new()
-        .compile_protos(&[proto_path], &[&manifest_dir])?;
-
-    Ok(())
-}

package/srpc/proto/mod.rs

@@ -1,10 +0,0 @@
-//! Generated protocol buffer types for starpc.
-//!
-//! This module contains the Packet, CallStart, CallData types generated from
-//! rpcproto.proto. These types define the wire protocol for starpc.
-
-// Include the generated protobuf types.
-include!(concat!(env!("OUT_DIR"), "/srpc.rs"));
-
-// Re-export commonly used items.
-pub use self::packet::Body;