starpc 0.43.1 → 0.45.0

package/srpc/mux.hpp

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <shared_mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "errors.hpp"
+#include "handler.hpp"
+#include "invoker.hpp"
+
+namespace starpc {
+
+// Mux contains a set of <service, method> handlers.
+// Matches Go Mux interface in mux.go
+class Mux : public Invoker, public QueryableInvoker {
+public:
+  // Constructor matching NewMux in Go
+  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);
+
+  // 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;
+
+  // 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;
+
+  // 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;
+
+private:
+  // Mapping from method id to handler
+  using MuxMethods = std::unordered_map<std::string, Handler *>;
+
+  // Fallback invokers
+  std::vector<Invoker *> fallback_;
+
+  // Read-write mutex guards services_
+  mutable std::shared_mutex mtx_;
+
+  // Services contains a mapping from services to handlers
+  std::unordered_map<std::string, MuxMethods> services_;
+};
+
+// NewMux constructs a new Mux.
+// Matches Go NewMux function in mux.go
+inline std::unique_ptr<Mux>
+NewMux(std::vector<Invoker *> fallback_invokers = {}) {
+  return std::make_unique<Mux>(std::move(fallback_invokers));
+}
+
+} // namespace starpc

package/srpc/packet.cpp

@@ -0,0 +1,83 @@
+// go:build deps_only
+
+#include "packet.hpp"
+
+#include "rpcproto.pb.h"
+
+namespace starpc {
+
+PacketDataHandler NewPacketDataHandler(PacketHandler handler) {
+  return [handler](const std::string &data) -> Error {
+    srpc::Packet pkt;
+    if (!pkt.ParseFromString(data)) {
+      return Error::InvalidMessage;
+    }
+    return handler(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;
+  }
+}
+
+Error ValidateCallStart(const srpc::CallStart &pkt) {
+  if (pkt.rpc_method().empty()) {
+    return Error::EmptyMethodID;
+  }
+  if (pkt.rpc_service().empty()) {
+    return Error::EmptyServiceID;
+  }
+  return Error::OK;
+}
+
+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) {
+  auto pkt = std::make_unique<srpc::Packet>();
+  auto *call_start = pkt->mutable_call_start();
+  call_start->set_rpc_service(service);
+  call_start->set_rpc_method(method);
+  call_start->set_data(data);
+  call_start->set_data_is_zero(data_is_zero);
+  return pkt;
+}
+
+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();
+  call_data->set_data(data);
+  call_data->set_data_is_zero(data_is_zero);
+  call_data->set_complete(err != Error::OK || complete);
+  if (err != Error::OK) {
+    call_data->set_error(ErrorString(err));
+  }
+  return pkt;
+}
+
+std::unique_ptr<srpc::Packet> NewCallCancelPacket() {
+  auto pkt = std::make_unique<srpc::Packet>();
+  pkt->set_call_cancel(true);
+  return pkt;
+}
+
+} // namespace starpc

package/srpc/packet.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+
+#include "errors.hpp"
+
+namespace srpc {
+class Packet;
+class CallStart;
+class CallData;
+} // namespace srpc
+
+namespace starpc {
+
+// CloseHandler handles the stream closing with an optional error.
+// Matches Go CloseHandler in packet.go
+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)>;
+
+// PacketDataHandler handles a packet before it is parsed.
+// Matches Go PacketDataHandler in packet.go
+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);
+
+// Validate performs cursory validation of a CallStart.
+Error ValidateCallStart(const srpc::CallStart &pkt);
+
+// Validate performs cursory validation of a CallData.
+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);
+
+// NewCallDataPacket constructs a new CallData packet.
+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

package/srpc/rpcproto.pb.ts

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

package/srpc/server-rpc.cpp

@@ -0,0 +1,97 @@
+// go:build deps_only
+
+#include "server-rpc.hpp"
+
+#include "packet.hpp"
+#include "rpcproto.pb.h"
+
+namespace starpc {
+
+ServerRPC::ServerRPC(Invoker *invoker, PacketWriter *writer)
+    : invoker_(invoker) {
+  Init();
+  writer_ = writer;
+}
+
+ServerRPC::~ServerRPC() {
+  if (invoke_thread_.joinable()) {
+    invoke_thread_.join();
+  }
+}
+
+Error ServerRPC::HandlePacketData(const std::string &data) {
+  srpc::Packet msg;
+  if (!msg.ParseFromString(data)) {
+    return Error::InvalidMessage;
+  }
+  return HandlePacket(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;
+  }
+}
+
+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
+  }
+  if (data_closed_) {
+    return Error::Completed;
+  }
+
+  service_ = pkt.rpc_service();
+  method_ = pkt.rpc_method();
+
+  // process first data packet, if included
+  if (!pkt.data().empty() || pkt.data_is_zero()) {
+    data_queue_.push_back(pkt.data());
+  }
+
+  // invoke the rpc in a separate thread (matches Go goroutine)
+  std::string service_id = service_;
+  std::string method_id = method_;
+  cv_.notify_all();
+
+  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) {
+  // On the server side, the writer is closed by invokeRPC.
+  auto strm = NewMsgStream(this, [this]() { Cancel(); });
+
+  auto [ok, err] = invoker_->InvokeMethod(service_id, method_id, strm.get());
+  if (err == Error::OK && !ok) {
+    err = Error::Unimplemented;
+  }
+
+  auto out_pkt = NewCallDataPacket("", false, true, err);
+  writer_->WritePacket(*out_pkt);
+  writer_->Close();
+  Cancel();
+}
+
+} // namespace starpc

package/srpc/server-rpc.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <string>
+#include <thread>
+
+#include "common-rpc.hpp"
+#include "errors.hpp"
+#include "invoker.hpp"
+#include "msg-stream.hpp"
+#include "writer.hpp"
+
+namespace srpc {
+class Packet;
+class CallStart;
+} // 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:
+  // Constructor matching NewServerRPC in Go
+  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);
+
+  // HandlePacket handles an incoming parsed message packet.
+  // Matches Go HandlePacket in server-rpc.go
+  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);
+
+  // 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 {
+    return CommonRPC::WriteCallData(data, data_is_zero, complete, err);
+  }
+  Error WriteCallCancel() override { return CommonRPC::WriteCallCancel(); }
+
+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);
+
+  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) {
+  return std::make_unique<ServerRPC>(invoker, writer);
+}
+
+} // namespace starpc

package/srpc/starpc.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+// Main header for starpc C++ library
+// Include this to get all starpc functionality
+
+#include "client-rpc.hpp"
+#include "client.hpp"
+#include "common-rpc.hpp"
+#include "errors.hpp"
+#include "handler.hpp"
+#include "invoker.hpp"
+#include "message.hpp"
+#include "msg-stream.hpp"
+#include "mux.hpp"
+#include "packet.hpp"
+#include "server-rpc.hpp"
+#include "stream.hpp"
+#include "writer.hpp"

package/srpc/stream.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+
+#include "errors.hpp"
+#include "message.hpp"
+
+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
+class Stream {
+public:
+  virtual ~Stream() = default;
+
+  // MsgSend sends the message to the remote.
+  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;
+
+  // CloseSend signals to the remote that we will no longer send any messages.
+  virtual Error CloseSend() = 0;
+
+  // Close closes the stream for reading and writing.
+  virtual Error Close() = 0;
+};
+
+// 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)
+      : 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 CloseSend() override { return inner_->CloseSend(); }
+
+  Error Close() override {
+    Error err = inner_->Close();
+    Error err2 = close_fn_();
+    if (err != Error::OK)
+      return err;
+    return err2;
+  }
+
+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) {
+  return std::make_unique<StreamWithClose>(strm, std::move(close_fn));
+}
+
+} // namespace starpc

package/srpc/writer.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+
+#include "errors.hpp"
+
+namespace srpc {
+class Packet;
+}
+
+namespace starpc {
+
+// PacketWriter is the interface used to write messages to a PacketStream.
+// Matches Go interface in writer.go
+class PacketWriter {
+public:
+  virtual ~PacketWriter() = default;
+
+  // WritePacket writes a packet to the remote.
+  virtual Error WritePacket(const srpc::Packet &pkt) = 0;
+
+  // Close closes the writer.
+  virtual Error Close() = 0;
+};
+
+// 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)
+      : inner_(std::move(inner)), close_fn_(std::move(close_fn)) {}
+
+  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;
+    return err2;
+  }
+
+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));
+}
+
+} // namespace starpc