starpc 0.52.1 → 0.52.2

package/srpc/common-rpc.cpp

@@ -6,177 +6,217 @@
 #include "rpcproto.pb.h"
 
 namespace starpc {
+namespace {
 
-CommonRPC::CommonRPC() = default;
+/*
+ * These bounds contain an unconsumed stream, including zero-length messages.
+ */
+constexpr size_t maximum_queued_bytes = 4 * 1024 * 1024;
+constexpr size_t maximum_queued_messages = 1024;
+
+} // namespace
 
+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()
+{
+	{
+		std::lock_guard lock(state_mutex);
+		canceled = true;
+		local_completed = true;
+		data_queue.clear();
+		queued_bytes = 0;
+	}
+	state_changed.notify_all();
+	stop_source.request_stop();
+	CloseWriter();
 }
 
-void CommonRPC::Cancel() {
-  canceled_.store(true);
-  cv_.notify_all();
+bool CommonRPC::IsCanceled() const
+{
+	std::lock_guard lock(state_mutex);
+	return canceled;
 }
 
-bool CommonRPC::IsCanceled() const { return canceled_.load(); }
-
-void CommonRPC::SetWriter(PacketWriter *writer) {
-  std::lock_guard<std::mutex> lock(mtx_);
-  writer_ = writer;
+std::string CommonRPC::RemoteErrorMessage() const
+{
+	std::lock_guard lock(state_mutex);
+	return remote_error_message;
 }
 
-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::ReadOne(std::string *out)
+{
+	auto readable = [this] {
+		return canceled || data_closed || !data_queue.empty();
+	};
+
+	/* Wait for a message, the call's end, or cancellation. */
+	std::unique_lock lock(state_mutex);
+	state_changed.wait(lock, readable);
+
+	if (canceled)
+		return remote_error != Error::OK ? remote_error
+						 : Error::Canceled;
+	if (!data_queue.empty()) {
+		*out = std::move(data_queue.front());
+		queued_bytes -= out->size();
+		data_queue.pop_front();
+		return Error::OK;
+	}
+	return remote_error != Error::OK ? remote_error : Error::EOF_;
 }
 
 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);
+			       bool complete, Error err)
+{
+	std::unique_lock writing(write_mutex);
+	PacketWriter *w;
+	{
+		std::lock_guard lock(state_mutex);
+		if (canceled)
+			return Error::Canceled;
+		if (local_completed) {
+			return complete && data.empty() && !data_is_zero
+				       ? Error::OK
+				       : Error::Completed;
+		}
+		if (writer == nullptr)
+			return Error::NilWriter;
+		if (writer_closed)
+			return Error::Completed;
+		if (complete || err != Error::OK)
+			local_completed = true;
+		w = writer;
+	}
+
+	const auto packet = NewCallDataPacket(
+		data, data.empty() && data_is_zero, complete, err);
+	const auto written = w->WritePacket(*packet);
+	writing.unlock();
+
+	/*
+	 * A failed half-close leaves the verdict to the transport close, which
+	 * follows any reply and completion the transport read but has not
+	 * delivered.
+	 */
+	const bool half_close =
+		complete && data.empty() && !data_is_zero && err == Error::OK;
+	if (written != Error::OK && !half_close)
+		HandleStreamClose(written);
+	return written;
 }
 
-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();
+void CommonRPC::HandleStreamClose(Error close_err)
+{
+	{
+		std::lock_guard lock(state_mutex);
+		if (canceled)
+			return;
+		if (close_err == Error::EOF_)
+			close_err = Error::OK;
+		if (remote_error == Error::OK && close_err != Error::OK)
+			remote_error = close_err;
+		if (remote_error == Error::OK && !remote_completed &&
+		    !local_completing)
+			remote_error = Error::ClosedBeforeCompletion;
+		data_closed = true;
+	}
+	state_changed.notify_all();
+	stop_source.request_stop();
+	CloseWriter();
 }
 
-Error CommonRPC::HandleCallCancel() {
-  HandleStreamClose(Error::Canceled);
-  return Error::OK;
+Error CommonRPC::HandleCallCancel()
+{
+	Cancel();
+	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::HandleCallData(const srpc::CallData &pkt)
+{
+	bool overflow = false;
+	{
+		std::lock_guard lock(state_mutex);
+		if (canceled)
+			return Error::Canceled;
+		if (data_closed)
+			return pkt.complete() ? Error::OK : Error::Completed;
+		if (!pkt.data().empty() || pkt.data_is_zero()) {
+			overflow =
+				data_queue.size() >= maximum_queued_messages ||
+				pkt.data().size() >
+					maximum_queued_bytes - queued_bytes;
+			if (!overflow) {
+				data_queue.push_back(pkt.data());
+				queued_bytes += pkt.data().size();
+			}
+		}
+		if (!pkt.error().empty()) {
+			remote_error = Error::RemoteError;
+			remote_error_message = pkt.error();
+		}
+		if (pkt.complete() || remote_error != Error::OK) {
+			data_closed = true;
+			remote_completed = true;
+		}
+	}
+
+	/* Close the transport before reporting an overflowing queue. */
+	if (overflow) {
+		HandleStreamClose(Error::ResourceExhausted);
+		return Error::ResourceExhausted;
+	}
+	state_changed.notify_all();
+	return Error::OK;
 }
 
-Error CommonRPC::WriteCallCancel() {
-  std::lock_guard<std::mutex> lock(mtx_);
-  return WriteCallCancelLocked();
+Error CommonRPC::WriteCallCancel()
+{
+	std::unique_lock writing(write_mutex);
+	PacketWriter *w;
+	{
+		std::lock_guard lock(state_mutex);
+		if (canceled || writer_closed)
+			return Error::Canceled;
+		if (local_completed)
+			return Error::Completed;
+		if (writer == nullptr)
+			return Error::NilWriter;
+		local_completed = true;
+		w = writer;
+	}
+
+	const auto written = w->WritePacket(*NewCallCancelPacket());
+	writing.unlock();
+	if (written != Error::OK)
+		HandleStreamClose(written);
+	return written;
 }
 
-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::CloseWriter()
+{
+	PacketWriter *w;
+	{
+		std::lock_guard lock(state_mutex);
+		if (writer_closed || writer == nullptr)
+			return;
+		writer_closed = true;
+		w = writer;
+	}
+	(void)w->Close();
 }
 
-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);
+void CommonRPC::Finish(Error err)
+{
+	{
+		std::lock_guard lock(state_mutex);
+		local_completing = true;
+	}
+
+	(void)WriteCallData("", false, true, err);
+	CloseWriter();
+	stop_source.request_stop();
 }
 
 } // namespace starpc

package/srpc/common-rpc.go

@@ -288,13 +288,14 @@ func (c *commonRPC) WriteCallCancel() error {
 	return c.writer.WritePacket(NewCallCancelPacket())
 }
 
-// closeLocked releases resources held by the RPC.
+// closeLocked releases resources held by the RPC. A call the remote already
+// settled keeps its result: queued messages and the completion stay readable.
 func (c *commonRPC) closeLocked(locked *broadcast.Locked) PacketWriter {
-	c.dataClosed = true
-	c.localCompleted.Store(true)
-	if c.remoteErr == nil {
+	if !c.dataClosed && c.remoteErr == nil {
 		c.remoteErr = context.Canceled
 	}
+	c.dataClosed = true
+	c.localCompleted.Store(true)
 	writer := c.closeWriterLocked()
 	locked.Broadcast()
 	c.cancelContext()

package/srpc/common-rpc.hpp

@@ -1,109 +1,139 @@
 #pragma once
 
-#include <atomic>
+#include "errors.hpp"
+#include "writer.hpp"
+
 #include <condition_variable>
 #include <deque>
 #include <mutex>
+#include <stop_token>
 #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
+/*
+ * CommonRPC holds the state one call shares between its transport side and
+ * its handler side: message delivery, half-close, and cancellation. The
+ * packet writer must outlive the call and interrupt blocked writes when
+ * closed. Subclasses drive it through Handle* from the transport and
+ * ReadOne/WriteCallData from the handler.
+ */
 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();
+	CommonRPC();
+	virtual ~CommonRPC();
+
+	/* Cancel interrupts reads and writes. Repeating it is safe. */
+	void Cancel();
+
+	/* IsCanceled reports whether Cancel or a peer cancel has run. */
+	bool IsCanceled() const;
+
+	/*
+	 * StopToken lets handlers cancel work outside ReadOne when the call
+	 * ends.
+	 */
+	std::stop_token StopToken() const
+	{
+		return stop_source.get_token();
+	}
+
+	/* GetService and GetMethod stay stable after call startup. */
+	const std::string &GetService() const
+	{
+		return service;
+	}
+	const std::string &GetMethod() const
+	{
+		return method;
+	}
+
+	/*
+	 * RemoteErrorMessage retains the peer's diagnostic when ReadOne
+	 * returns RemoteError.
+	 */
+	std::string RemoteErrorMessage() const;
+
+	/*
+	 * ReadOne returns the next queued message in out. It returns EOF_
+	 * after a normal completion, the peer's error for a failed call, and
+	 * Canceled after local cancellation; an abrupt peer disconnect is not
+	 * a successful EOF.
+	 */
+	Error ReadOne(std::string *out);
+
+	/*
+	 * WriteCallData writes one data packet. data_is_zero marks an
+	 * intentionally empty message; complete ends the sending side; err
+	 * carries the terminal verdict. A failed write ends the call, except
+	 * for a bare half-close, whose outcome the transport close settles.
+	 */
+	Error WriteCallData(const std::string &data, bool data_is_zero,
+			    bool complete, Error err);
+
+	/*
+	 * HandleStreamClose records the transport ending. EOF_ means the peer
+	 * half-closed cleanly; any other error becomes the call's verdict when
+	 * the peer has not given one.
+	 */
+	void HandleStreamClose(Error close_err);
+
+	/* HandleCallCancel honors the peer's cancel packet. */
+	Error HandleCallCancel();
+
+	/* HandleCallData queues one data packet and applies its verdict. */
+	Error HandleCallData(const srpc::CallData &pkt);
+
+	/* WriteCallCancel writes cancel to the remote and ends the call. */
+	Error WriteCallCancel();
 
 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};
+	/* Finish publishes err as the call's verdict and closes the writer. */
+	void Finish(Error err);
+
+	/* CloseWriter closes the transport once per call, outside the locks. */
+	void CloseWriter();
+
+	/*
+	 * state_mutex guards the call state below. write_mutex orders outgoing
+	 * packets and may precede state_mutex; transport close never waits for
+	 * write_mutex.
+	 */
+	mutable std::mutex state_mutex;
+	std::mutex write_mutex;
+	std::condition_variable state_changed;
+
+	std::string service;
+	std::string method;
+
+	/* writer is borrowed until the call and transport callbacks stop. */
+	PacketWriter *writer = nullptr;
+	bool writer_closed = false;
+
+	/* local_completed is set once the handler side has sent its verdict. */
+	bool local_completed = false;
+	bool local_completing = false;
+	bool canceled = false;
+
+	/* data_closed ends the receive side; remote_completed records why. */
+	bool data_closed = false;
+	bool remote_completed = false;
+	Error remote_error = Error::OK;
+	std::string remote_error_message;
+
+	/*
+	 * data_queue holds messages received before their reader ran, bounded
+	 * by queued_bytes and the queue length.
+	 */
+	std::deque<std::string> data_queue;
+	size_t queued_bytes = 0;
+
+	/* stop_source drives StopToken; cancellation and close request it. */
+	std::stop_source stop_source;
 };
 
 } // namespace starpc