starpc 0.43.1 → 0.45.0

package/srpc/common-rpc.cpp

@@ -0,0 +1,182 @@
+// go:build deps_only
+
+#include "common-rpc.hpp"
+
+#include "packet.hpp"
+#include "rpcproto.pb.h"
+
+namespace starpc {
+
+CommonRPC::CommonRPC() = default;
+
+CommonRPC::~CommonRPC() = default;
+
+void CommonRPC::Init() {
+  canceled_.store(false);
+  local_completed_.store(false);
+  data_closed_ = false;
+  remote_err_ = Error::OK;
+  data_queue_.clear();
+}
+
+void CommonRPC::Cancel() {
+  canceled_.store(true);
+  cv_.notify_all();
+}
+
+bool CommonRPC::IsCanceled() const { return canceled_.load(); }
+
+void CommonRPC::SetWriter(PacketWriter *writer) {
+  std::lock_guard<std::mutex> lock(mtx_);
+  writer_ = writer;
+}
+
+Error CommonRPC::ReadOne(std::string *out) {
+  bool ctx_done = false;
+
+  while (true) {
+    std::unique_lock<std::mutex> lock(mtx_);
+
+    if (ctx_done && !data_closed_) {
+      CloseLocked();
+      return Error::Canceled;
+    }
+
+    if (!data_queue_.empty()) {
+      *out = std::move(data_queue_.front());
+      data_queue_.pop_front();
+      return Error::OK;
+    }
+
+    if (data_closed_ || remote_err_ != Error::OK) {
+      if (remote_err_ != Error::OK) {
+        return remote_err_;
+      }
+      return Error::EOF_;
+    }
+
+    cv_.wait(lock, [this, &ctx_done]() {
+      if (canceled_.load()) {
+        ctx_done = true;
+        return true;
+      }
+      return !data_queue_.empty() || data_closed_ || remote_err_ != Error::OK;
+    });
+
+    if (canceled_.load()) {
+      ctx_done = true;
+    }
+  }
+}
+
+Error CommonRPC::WriteCallData(const std::string &data, bool data_is_zero,
+                               bool complete, Error err) {
+  // Check if already completed
+  if (local_completed_.load()) {
+    // If we're just marking completion and already completed, allow it (no-op)
+    if (complete && data.empty() && !data_is_zero) {
+      return Error::OK;
+    }
+    // Otherwise, return error for trying to send data after completion
+    return Error::Completed;
+  }
+
+  // Mark as completed if this call completes the RPC
+  if (complete || err != Error::OK) {
+    local_completed_.store(true);
+  }
+
+  std::lock_guard<std::mutex> lock(mtx_);
+  if (writer_ == nullptr) {
+    return Error::NilWriter;
+  }
+
+  auto pkt =
+      NewCallDataPacket(data, data.empty() && data_is_zero, complete, err);
+  return writer_->WritePacket(*pkt);
+}
+
+void CommonRPC::HandleStreamClose(Error close_err) {
+  std::lock_guard<std::mutex> lock(mtx_);
+  if (close_err != Error::OK && remote_err_ == Error::OK) {
+    remote_err_ = close_err;
+  }
+  data_closed_ = true;
+  canceled_.store(true);
+  if (writer_ != nullptr) {
+    writer_->Close();
+  }
+  cv_.notify_all();
+}
+
+Error CommonRPC::HandleCallCancel() {
+  HandleStreamClose(Error::Canceled);
+  return Error::OK;
+}
+
+Error CommonRPC::HandleCallData(const srpc::CallData &pkt) {
+  std::lock_guard<std::mutex> lock(mtx_);
+
+  if (data_closed_) {
+    // If the packet is just indicating the call is complete, ignore it.
+    if (pkt.complete()) {
+      return Error::OK;
+    }
+    // Otherwise, return ErrCompleted (unexpected packet).
+    return Error::Completed;
+  }
+
+  // Queue data if present
+  if (!pkt.data().empty() || pkt.data_is_zero()) {
+    data_queue_.push_back(pkt.data());
+  }
+
+  bool complete = pkt.complete();
+  if (!pkt.error().empty()) {
+    complete = true;
+    // Store remote error - in a full implementation we might parse the error
+    // string
+    remote_err_ = Error::Unimplemented; // Generic remote error
+  }
+
+  if (complete) {
+    data_closed_ = true;
+  }
+
+  cv_.notify_all();
+  return Error::OK;
+}
+
+Error CommonRPC::WriteCallCancel() {
+  std::lock_guard<std::mutex> lock(mtx_);
+  return WriteCallCancelLocked();
+}
+
+Error CommonRPC::WriteCallCancelLocked() {
+  // Use atomic swap to check and set completion atomically
+  if (local_completed_.exchange(true)) {
+    return Error::Completed;
+  }
+
+  if (writer_ == nullptr) {
+    return Error::NilWriter;
+  }
+
+  auto pkt = NewCallCancelPacket();
+  return writer_->WritePacket(*pkt);
+}
+
+void CommonRPC::CloseLocked() {
+  data_closed_ = true;
+  local_completed_.store(true);
+  if (remote_err_ == Error::OK) {
+    remote_err_ = Error::Canceled;
+  }
+  if (writer_ != nullptr) {
+    writer_->Close();
+  }
+  cv_.notify_all();
+  canceled_.store(true);
+}
+
+} // namespace starpc

package/srpc/common-rpc.hpp

@@ -0,0 +1,109 @@
+#pragma once
+
+#include <atomic>
+#include <condition_variable>
+#include <deque>
+#include <mutex>
+#include <string>
+
+#include "errors.hpp"
+#include "writer.hpp"
+
+namespace srpc {
+class CallData;
+}
+
+namespace starpc {
+
+// CommonRPC contains common logic between server/client RPC.
+// Matches Go commonRPC struct in common-rpc.go
+class CommonRPC {
+public:
+  CommonRPC();
+  virtual ~CommonRPC();
+
+  // Init initializes the CommonRPC (matches initCommonRPC in Go).
+  void Init();
+
+  // Cancel cancels the RPC context.
+  void Cancel();
+
+  // IsCanceled returns true if the RPC has been canceled.
+  bool IsCanceled() const;
+
+  // GetService returns the service name.
+  const std::string &GetService() const { return service_; }
+
+  // GetMethod returns the method name.
+  const std::string &GetMethod() const { return method_; }
+
+  // ReadOne reads a single message and returns.
+  // Returns EOF_ if the stream ended without a packet.
+  // Matches Go ReadOne in common-rpc.go
+  Error ReadOne(std::string *out);
+
+  // WriteCallData writes a call data packet.
+  // Matches Go WriteCallData in common-rpc.go
+  Error WriteCallData(const std::string &data, bool data_is_zero, bool complete,
+                      Error err);
+
+  // HandleStreamClose handles the incoming stream closing with optional error.
+  // Matches Go HandleStreamClose in common-rpc.go
+  void HandleStreamClose(Error close_err);
+
+  // HandleCallCancel handles the call cancel packet.
+  // Matches Go HandleCallCancel in common-rpc.go
+  Error HandleCallCancel();
+
+  // HandleCallData handles the call data packet.
+  // Matches Go HandleCallData in common-rpc.go
+  Error HandleCallData(const srpc::CallData &pkt);
+
+  // WriteCallCancel writes a call cancel packet.
+  // Matches Go WriteCallCancel in common-rpc.go
+  Error WriteCallCancel();
+
+  // WriteCallCancelLocked is the same as WriteCallCancel but assumes mtx_ is
+  // held.
+  Error WriteCallCancelLocked();
+
+protected:
+  // CloseLocked releases resources held by the RPC.
+  // Must be called with mutex held.
+  // Matches Go closeLocked in common-rpc.go
+  void CloseLocked();
+
+  // SetWriter sets the packet writer.
+  void SetWriter(PacketWriter *writer);
+
+  // Mutex and condition variable for synchronization (replaces Go broadcast)
+  mutable std::mutex mtx_;
+  std::condition_variable cv_;
+
+  // Service and method names
+  std::string service_;
+  std::string method_;
+
+  // localCompleted tracks if we have sent a completion or cancel locally.
+  // Note: not guarded by mutex (atomic)
+  std::atomic<bool> local_completed_{false};
+
+  // Writer to write messages to
+  PacketWriter *writer_ = nullptr;
+
+  // dataQueue contains incoming data packets.
+  // Note: packets may be empty
+  std::deque<std::string> data_queue_;
+
+  // dataClosed is a flag set after dataQueue is closed.
+  // Controlled by HandlePacket.
+  bool data_closed_ = false;
+
+  // remoteErr is an error set by the remote.
+  Error remote_err_ = Error::OK;
+
+  // canceled tracks if the context has been canceled
+  std::atomic<bool> canceled_{false};
+};
+
+} // namespace starpc

package/srpc/errors.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+namespace starpc {
+
+// Error codes matching Go starpc errors (see errors.go)
+enum class Error {
+  OK = 0,
+  Unimplemented, // ErrUnimplemented - RPC method was not implemented
+  Completed,     // ErrCompleted - unexpected packet after rpc was completed
+  UnrecognizedPacket, // ErrUnrecognizedPacket - unrecognized packet type
+  EmptyPacket,        // ErrEmptyPacket - invalid empty packet
+  InvalidMessage,     // ErrInvalidMessage - message failed to parse
+  EmptyMethodID,      // ErrEmptyMethodID - method id empty
+  EmptyServiceID,     // ErrEmptyServiceID - service id empty
+  NoAvailableClients, // ErrNoAvailableClients - no available rpc clients
+  NilWriter,          // ErrNilWriter - writer cannot be nil
+  Canceled,           // context.Canceled equivalent
+  EOF_,               // io.EOF equivalent (named EOF_ to avoid macro collision)
+};
+
+// Convert Error to string (matches Go error messages)
+inline const char *ErrorString(Error err) {
+  switch (err) {
+  case Error::OK:
+    return "ok";
+  case Error::Unimplemented:
+    return "unimplemented";
+  case Error::Completed:
+    return "unexpected packet after rpc was completed";
+  case Error::UnrecognizedPacket:
+    return "unrecognized packet type";
+  case Error::EmptyPacket:
+    return "invalid empty packet";
+  case Error::InvalidMessage:
+    return "invalid message";
+  case Error::EmptyMethodID:
+    return "method id empty";
+  case Error::EmptyServiceID:
+    return "service id empty";
+  case Error::NoAvailableClients:
+    return "no available rpc clients";
+  case Error::NilWriter:
+    return "writer cannot be nil";
+  case Error::Canceled:
+    return "canceled";
+  case Error::EOF_:
+    return "EOF";
+  default:
+    return "unknown error";
+  }
+}
+
+// StarpcError exception for error propagation
+class StarpcError : public std::runtime_error {
+public:
+  explicit StarpcError(Error code)
+      : std::runtime_error(ErrorString(code)), code_(code) {}
+
+  StarpcError(Error code, const std::string &message)
+      : std::runtime_error(message), code_(code) {}
+
+  Error code() const noexcept { return code_; }
+
+private:
+  Error code_;
+};
+
+} // namespace starpc

package/srpc/handler.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "invoker.hpp"
+
+namespace starpc {
+
+// Handler describes a SRPC call handler implementation.
+// Matches Go Handler interface in handler.go
+class Handler : public Invoker {
+public:
+  ~Handler() override = default;
+
+  // GetServiceID returns the ID of the service.
+  virtual const std::string &GetServiceID() const = 0;
+
+  // GetMethodIDs returns the list of methods for the service.
+  virtual std::vector<std::string> GetMethodIDs() const = 0;
+};
+
+} // namespace starpc

package/srpc/invoker.hpp

@@ -0,0 +1,91 @@
+#pragma once
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "errors.hpp"
+#include "stream.hpp"
+
+namespace starpc {
+
+// Invoker is a function for invoking SRPC service methods.
+// Matches Go Invoker interface in invoker.go
+class Invoker {
+public:
+  virtual ~Invoker() = default;
+
+  // 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.
+  virtual std::pair<bool, Error> InvokeMethod(const std::string &service_id,
+                                              const std::string &method_id,
+                                              Stream *strm) = 0;
+};
+
+// QueryableInvoker can be used to check if a service and method is implemented.
+// Matches Go QueryableInvoker interface in invoker.go
+class QueryableInvoker {
+public:
+  virtual ~QueryableInvoker() = default;
+
+  // HasService checks if the service ID exists in the handlers.
+  virtual bool HasService(const std::string &service_id) const = 0;
+
+  // HasServiceMethod checks if <service-id, method-id> exists in the handlers.
+  virtual bool HasServiceMethod(const std::string &service_id,
+                                const std::string &method_id) const = 0;
+};
+
+// InvokerSlice is a list of invokers.
+// Matches Go InvokerSlice in invoker.go
+class InvokerSlice : public Invoker {
+public:
+  InvokerSlice() = default;
+  explicit InvokerSlice(std::vector<Invoker *> invokers)
+      : invokers_(std::move(invokers)) {}
+
+  void Add(Invoker *invoker) { invokers_.push_back(invoker); }
+
+  std::pair<bool, Error> InvokeMethod(const std::string &service_id,
+                                      const std::string &method_id,
+                                      Stream *strm) override {
+    for (auto *invoker : invokers_) {
+      if (invoker == nullptr)
+        continue;
+      auto [found, err] = invoker->InvokeMethod(service_id, method_id, strm);
+      if (found || err != Error::OK) {
+        return {true, err};
+      }
+    }
+    return {false, Error::OK};
+  }
+
+private:
+  std::vector<Invoker *> invokers_;
+};
+
+// InvokerFunc is a function implementing InvokeMethod.
+// Matches Go InvokerFunc in invoker.go
+using InvokerFunc = std::function<std::pair<bool, Error>(
+    const std::string &service_id, const std::string &method_id, Stream *strm)>;
+
+// InvokerFuncWrapper wraps an InvokerFunc as an Invoker.
+class InvokerFuncWrapper : public Invoker {
+public:
+  explicit InvokerFuncWrapper(InvokerFunc fn) : fn_(std::move(fn)) {}
+
+  std::pair<bool, Error> InvokeMethod(const std::string &service_id,
+                                      const std::string &method_id,
+                                      Stream *strm) override {
+    if (!fn_) {
+      return {false, Error::OK};
+    }
+    return fn_(service_id, method_id, strm);
+  }
+
+private:
+  InvokerFunc fn_;
+};
+
+} // namespace starpc

package/srpc/message.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <string>
+
+#include "google/protobuf/message_lite.h"
+
+namespace starpc {
+
+// Message is the interface for protobuf messages.
+// Matches Go Message interface in message.go
+// In C++, we use google::protobuf::MessageLite as the base.
+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) {
+  return msg.SerializeToString(out);
+}
+
+// UnmarshalVT deserializes the message from bytes.
+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(); }
+
+} // namespace starpc

package/srpc/msg-stream.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <functional>
+#include <string>
+
+#include "errors.hpp"
+#include "message.hpp"
+#include "stream.hpp"
+
+namespace starpc {
+
+// MsgStreamRw is the read-write interface for MsgStream.
+// Matches Go MsgStreamRw interface in msg-stream.go
+class MsgStreamRw {
+public:
+  virtual ~MsgStreamRw() = default;
+
+  // ReadOne reads a single message and returns.
+  // Returns EOF_ if the stream ended.
+  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;
+
+  // WriteCallCancel writes a call cancel (close) packet.
+  virtual Error WriteCallCancel() = 0;
+};
+
+// MsgStream implements the stream interface passed to implementations.
+// Matches Go MsgStream struct in msg-stream.go
+class MsgStream : public Stream {
+public:
+  // Constructor matching NewMsgStream in Go
+  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 {
+    std::string msg_data;
+    if (!msg.SerializeToString(&msg_data)) {
+      return Error::InvalidMessage;
+    }
+    return rw_->WriteCallData(msg_data, msg_data.empty(), false, Error::OK);
+  }
+
+  // MsgRecv receives an incoming message from the remote.
+  Error MsgRecv(Message *msg) override {
+    std::string data;
+    Error err = rw_->ReadOne(&data);
+    if (err != Error::OK) {
+      return err;
+    }
+    if (!msg->ParseFromString(data)) {
+      return Error::InvalidMessage;
+    }
+    return Error::OK;
+  }
+
+  // CloseSend signals to the remote that we will no longer send any messages.
+  Error CloseSend() override {
+    return rw_->WriteCallData("", false, true, Error::OK);
+  }
+
+  // Close closes the stream.
+  Error Close() override {
+    Error err = rw_->WriteCallCancel();
+    if (close_cb_) {
+      close_cb_();
+    }
+    return err;
+  }
+
+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) {
+  return std::make_unique<MsgStream>(rw, std::move(close_cb));
+}
+
+} // namespace starpc

package/srpc/mux.cpp

@@ -0,0 +1,109 @@
+// go:build deps_only
+
+#include "mux.hpp"
+#include <mutex>
+
+namespace starpc {
+
+Mux::Mux(std::vector<Invoker *> fallback_invokers)
+    : fallback_(std::move(fallback_invokers)) {}
+
+Error Mux::Register(Handler *handler) {
+  const std::string &service_id = handler->GetServiceID();
+  auto method_ids = handler->GetMethodIDs();
+
+  if (service_id.empty()) {
+    return Error::EmptyServiceID;
+  }
+
+  std::unique_lock<std::shared_mutex> lock(mtx_);
+
+  auto &service_methods = services_[service_id];
+  for (const auto &method_id : method_ids) {
+    if (!method_id.empty()) {
+      service_methods[method_id] = handler;
+    }
+  }
+
+  return Error::OK;
+}
+
+bool Mux::HasService(const std::string &service_id) const {
+  if (service_id.empty()) {
+    return false;
+  }
+
+  std::shared_lock<std::shared_mutex> lock(mtx_);
+  auto it = services_.find(service_id);
+  return it != services_.end() && !it->second.empty();
+}
+
+bool Mux::HasServiceMethod(const std::string &service_id,
+                           const std::string &method_id) const {
+  if (service_id.empty() || method_id.empty()) {
+    return false;
+  }
+
+  std::shared_lock<std::shared_mutex> lock(mtx_);
+  auto svc_it = services_.find(service_id);
+  if (svc_it == services_.end()) {
+    return false;
+  }
+
+  for (const auto &[mid, handler] : svc_it->second) {
+    for (const auto &handler_method : handler->GetMethodIDs()) {
+      if (handler_method == method_id) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+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_) {
+        auto it = svc_methods.find(method_id);
+        if (it != svc_methods.end()) {
+          handler = it->second;
+          break;
+        }
+      }
+    } else {
+      auto svc_it = services_.find(service_id);
+      if (svc_it != services_.end()) {
+        auto method_it = svc_it->second.find(method_id);
+        if (method_it != svc_it->second.end()) {
+          handler = method_it->second;
+        }
+      }
+    }
+  }
+
+  if (handler != nullptr) {
+    return handler->InvokeMethod(service_id, method_id, strm);
+  }
+
+  // Try fallback invokers
+  for (auto *invoker : fallback_) {
+    if (invoker != nullptr) {
+      auto [handled, err] = invoker->InvokeMethod(service_id, method_id, strm);
+      if (err != Error::OK || handled) {
+        return {handled, err};
+      }
+    }
+  }
+
+  return {false, Error::OK};
+}
+
+} // namespace starpc