starpc 0.52.1 → 0.52.2

package/srpc/rpc_lifecycle_test.cc

@@ -0,0 +1,333 @@
+//go:build deps_only
+
+#include "echo/echo.pb.h"
+#include "rpcstream/rpcstream.hpp"
+#include "srpc/client.hpp"
+#include "srpc/rpcproto.pb.h"
+#include "srpc/server-rpc.hpp"
+
+#include <atomic>
+#include <cstdlib>
+#include <future>
+#include <iostream>
+#include <latch>
+
+namespace {
+using starpc::Error;
+
+void Check(bool value, const char *message)
+{
+	if (value)
+		return;
+	std::cerr << message << '\n';
+	std::exit(1);
+}
+
+/*
+ * Writer is a test PacketWriter: optional write and close callbacks, plus a
+ * count of closes for assertions.
+ */
+class Writer final : public starpc::PacketWriter {
+public:
+	Error WritePacket(const srpc::Packet &packet) override
+	{
+		if (write)
+			return write(packet);
+		return Error::OK;
+	}
+	Error Close() override
+	{
+		++closes;
+		if (close)
+			close();
+		return Error::OK;
+	}
+	std::function<Error(const srpc::Packet &)> write;
+	std::function<void()> close;
+	std::atomic<int> closes = 0;
+};
+
+/* WaitingHandler blocks in MsgRecv until its test releases it. */
+class WaitingHandler final : public starpc::Invoker {
+public:
+	std::pair<bool, Error> InvokeMethod(const std::string &,
+					    const std::string &,
+					    starpc::Stream *stream) override
+	{
+		entered.count_down();
+		echo::EchoMsg message;
+		const auto err = stream->MsgRecv(&message);
+		exited = true;
+		return {true, err};
+	}
+	std::latch entered{1};
+	std::atomic<bool> exited = false;
+};
+
+/* DestroyWaitingServer proves destruction joins a blocked handler. */
+void DestroyWaitingServer()
+{
+	Writer writer;
+	WaitingHandler handler;
+	{
+		starpc::ServerRPC rpc(&handler, &writer);
+		srpc::CallStart start;
+		start.set_rpc_service("test");
+		start.set_rpc_method("wait");
+		Check(rpc.HandleCallStart(start) == Error::OK, "start handler");
+		handler.entered.wait();
+	}
+	Check(handler.exited,
+	      "server destruction must join the canceled handler");
+	Check(writer.closes == 1, "writer closes once");
+}
+
+/* ReentrantTransport proves a synchronous reply cannot deadlock the call. */
+void ReentrantTransport()
+{
+	starpc::ClientRPC rpc("test", "call");
+	Writer writer;
+	writer.close = [&] { rpc.HandleStreamClose(Error::OK); };
+	writer.write = [&](const srpc::Packet &) {
+		srpc::CallData data;
+		data.set_data("reply");
+		data.set_complete(true);
+		return rpc.HandleCallData(data);
+	};
+	Check(rpc.Start(&writer, false, "ignored") == Error::OK,
+	      "synchronous reply must not deadlock");
+	std::string reply;
+	Check(rpc.ReadOne(&reply) == Error::OK && reply == "reply",
+	      "deliver synchronous reply");
+	Check(rpc.ReadOne(&reply) == Error::EOF_, "explicit completion is EOF");
+	rpc.Close();
+	rpc.Close();
+	Check(writer.closes == 1,
+	      "reentrant close must not repeat transport cleanup");
+}
+
+/* CancelBlockedWriter proves cancellation interrupts a blocked write. */
+void CancelBlockedWriter()
+{
+	Writer writer;
+	starpc::ClientRPC rpc("test", "call");
+	Check(rpc.Start(&writer, false, "") == Error::OK,
+	      "start blocked writer test");
+	std::latch writing{1}, closed{1};
+	writer.write = [&](const srpc::Packet &) {
+		writing.count_down();
+		closed.wait();
+		return Error::Canceled;
+	};
+	writer.close = [&] { closed.count_down(); };
+	std::jthread sender([&] {
+		(void)rpc.WriteCallData("pending", false, false, Error::OK);
+	});
+	writing.wait();
+	rpc.Close();
+	sender.join();
+	Check(writer.closes == 1,
+	      "cancellation must interrupt a blocked write");
+}
+
+/* DisconnectAndErrors pins how disconnects and remote errors surface. */
+void DisconnectAndErrors()
+{
+	starpc::ClientRPC rpc("test", "call");
+	rpc.HandleStreamClose(Error::EOF_);
+	std::string message;
+	Check(rpc.ReadOne(&message) == Error::ClosedBeforeCompletion,
+	      "abrupt EOF is not completion");
+
+	starpc::ClientRPC failed("test", "call");
+	srpc::CallData data;
+	data.set_error("specific server failure");
+	Check(failed.HandleCallData(data) == Error::OK, "receive server error");
+	Check(failed.ReadOne(&message) == Error::RemoteError,
+	      "preserve remote error kind");
+	Check(failed.RemoteErrorMessage() == data.error(),
+	      "preserve remote diagnostic");
+	auto messages = starpc::NewMsgStream(&failed, [&] { failed.Close(); });
+	Check(messages->RemoteErrorMessage() == data.error(),
+	      "stream exposes the remote diagnostic");
+}
+
+/* StreamDestruction proves each stream releases its writer exactly once. */
+void StreamDestruction()
+{
+	int destroyed = 0;
+	struct CountedWriter final : starpc::PacketWriter {
+		explicit CountedWriter(int &count)
+			: count(count)
+		{
+		}
+		~CountedWriter() override
+		{
+			++count;
+		}
+		Error WritePacket(const srpc::Packet &) override
+		{
+			return Error::OK;
+		}
+		Error Close() override
+		{
+			return Error::OK;
+		}
+		int &count;
+	};
+	auto client = starpc::NewClient([&](auto, auto) {
+		return std::make_pair(
+			std::make_unique<CountedWriter>(destroyed), Error::OK);
+	});
+	{
+		auto [stream, err] = client->NewStream("test", "call", nullptr);
+		Check(err == Error::OK, "open stream");
+		stream->Close();
+		stream->Close();
+	}
+	Check(destroyed == 1, "stream must destroy its writer exactly once");
+	{
+		auto [stream, err] = client->NewStream("test", "call", nullptr);
+		Check(err == Error::OK, "open automatically closed stream");
+	}
+	Check(destroyed == 2, "dropping a stream must release its writer");
+}
+
+/* BoundReceiveQueue pins the receive queue's byte and message bounds. */
+void BoundReceiveQueue()
+{
+	starpc::ClientRPC rpc("test", "call");
+	srpc::CallData data;
+	data.set_data(std::string(4 * 1024 * 1024 + 1, 'x'));
+	Check(rpc.HandleCallData(data) == Error::ResourceExhausted,
+	      "bound unread message bytes");
+	starpc::ClientRPC empty("test", "call");
+	data.clear_data();
+	data.set_data_is_zero(true);
+	for (int i = 0; i < 1024; ++i) {
+		Check(empty.HandleCallData(data) == Error::OK,
+		      "queue empty message");
+	}
+	Check(empty.HandleCallData(data) == Error::ResourceExhausted,
+	      "bound empty message count");
+}
+
+/*
+ * NestedReleaseWaitsForHandler proves the Invoker is released only after the
+ * nested handler returns.
+ */
+void NestedReleaseWaitsForHandler()
+{
+	WaitingHandler handler;
+	class DisconnectStream final : public rpcstream::RpcStream {
+	public:
+		explicit DisconnectStream(WaitingHandler &handler)
+			: handler(handler)
+		{
+		}
+		Error Send(const rpcstream::RpcStreamPacket &) override
+		{
+			return Error::OK;
+		}
+		Error CloseSend() override
+		{
+			return Error::OK;
+		}
+		Error Close() override
+		{
+			return Error::OK;
+		}
+		Error Recv(rpcstream::RpcStreamPacket *packet) override
+		{
+			packet->Clear();
+			if (reads++ == 0) {
+				packet->mutable_init()->set_component_id(
+					"component");
+				return Error::OK;
+			}
+			if (reads == 2) {
+				packet->set_data(
+					starpc::NewCallStartPacket(
+						"test", "wait", "", false)
+						->SerializeAsString());
+				return Error::OK;
+			}
+			handler.entered.wait();
+			return Error::EOF_;
+		}
+
+	private:
+		WaitingHandler &handler;
+		int reads = 0;
+	};
+	bool released = false;
+	auto stream = std::make_shared<DisconnectStream>(handler);
+	const auto err =
+		rpcstream::HandleRpcStream(stream, [&](const std::string &) {
+			return std::make_tuple(
+				&handler,
+				[&] {
+					Check(handler.exited,
+					      "nested handler must return "
+					      "before its service is released");
+					released = true;
+				},
+				Error::OK);
+		});
+	Check(err == Error::OK && released,
+	      "nested disconnect must release its service");
+}
+
+/* ReceiveThreadJoinsOnDestruction proves writer destruction joins the pump. */
+void ReceiveThreadJoinsOnDestruction()
+{
+	class WaitingStream final : public rpcstream::RpcStream {
+	public:
+		Error Send(const rpcstream::RpcStreamPacket &) override
+		{
+			return Error::OK;
+		}
+		Error Recv(rpcstream::RpcStreamPacket *) override
+		{
+			entered.count_down();
+			closed.wait();
+			return Error::EOF_;
+		}
+		Error CloseSend() override
+		{
+			return Close();
+		}
+		Error Close() override
+		{
+			if (!stopped.exchange(true))
+				closed.count_down();
+			return Error::OK;
+		}
+		std::latch entered{1}, closed{1};
+		std::atomic<bool> stopped{false};
+	};
+	auto stream = std::make_shared<WaitingStream>();
+	std::atomic<bool> returned{false};
+	auto [writer, started] = rpcstream::StartReadPump(
+		stream, [](const std::string &) { return Error::OK; },
+		[&](Error) { returned = true; });
+	Check(started == Error::OK, "start receive thread");
+	stream->entered.wait();
+	writer.reset();
+	Check(returned, "writer destruction must join its receive callback");
+}
+
+} // namespace
+
+int main()
+{
+	DestroyWaitingServer();
+	ReentrantTransport();
+	CancelBlockedWriter();
+	DisconnectAndErrors();
+	StreamDestruction();
+	BoundReceiveQueue();
+	NestedReleaseWaitsForHandler();
+	ReceiveThreadJoinsOnDestruction();
+	std::cout << "RPC lifecycle checks passed\n";
+}

package/srpc/server-cancel_test.go

@@ -0,0 +1,39 @@
+package srpc
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+)
+
+// TestServerCancellationRetainsIdentity checks cancellation across the wire,
+// independently of the client's own context cancellation.
+func TestServerCancellationRetainsIdentity(t *testing.T) {
+	// Exercise the real packet codec and pipe with a canceled remote handler.
+	ctx, cancel := context.WithTimeout(t.Context(), time.Second)
+	defer cancel()
+	server := NewServer(InvokerFunc(func(string, string, Stream) (bool, error) {
+		return true, context.Canceled
+	}))
+	rpc := NewClientRPC(ctx, "service", "method")
+	defer rpc.Close()
+	writer, err := NewServerPipe(server)(ctx, rpc.HandlePacketData, rpc.HandleStreamClose)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatal(err)
+	}
+
+	// Both receive and completion must retain the remote cancellation sentinel.
+	if _, err := rpc.ReadOne(); !errors.Is(err, context.Canceled) {
+		t.Fatalf("receive cancellation = %v", err)
+	}
+	if err := rpc.Wait(ctx); !errors.Is(err, context.Canceled) {
+		t.Fatalf("completion cancellation = %v", err)
+	}
+	if err := ctx.Err(); err != nil {
+		t.Fatal("client deadline hid the remote cancellation", err)
+	}
+}

package/srpc/server-rpc.cpp

@@ -5,93 +5,103 @@
 #include "packet.hpp"
 #include "rpcproto.pb.h"
 
+#include <system_error>
+
 namespace starpc {
 
 ServerRPC::ServerRPC(Invoker *invoker, PacketWriter *writer)
-    : invoker_(invoker) {
-  Init();
-  writer_ = writer;
+	: invoker(invoker)
+{
+	this->writer = writer;
 }
 
-ServerRPC::~ServerRPC() {
-  if (invoke_thread_.joinable()) {
-    invoke_thread_.join();
-  }
+ServerRPC::~ServerRPC()
+{
+	Cancel();
+	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::HandlePacketData(const std::string &data)
+{
+	srpc::Packet packet;
+	if (!packet.ParseFromString(data))
+		return Error::InvalidMessage;
+	return HandlePacket(packet);
 }
 
-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::HandlePacket(const srpc::Packet &packet)
+{
+	const auto err = ValidatePacket(packet);
+	if (err != Error::OK)
+		return err;
+
+	switch (packet.body_case()) {
+	case srpc::Packet::kCallStart:
+		return HandleCallStart(packet.call_start());
+	case srpc::Packet::kCallData:
+		if (service.empty())
+			return Error::UnrecognizedPacket;
+		return HandleCallData(packet.call_data());
+	case srpc::Packet::kCallCancel:
+		return packet.call_cancel() ? HandleCallCancel() : Error::OK;
+	default:
+		return Error::UnrecognizedPacket;
+	}
 }
 
-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;
+Error ServerRPC::HandleCallStart(const srpc::CallStart &packet)
+{
+	const auto valid = ValidateCallStart(packet);
+	if (valid != Error::OK)
+		return valid;
+
+	{
+		std::lock_guard lock(state_mutex);
+		if (writer == nullptr)
+			return Error::NilWriter;
+		if (invoker == nullptr)
+			return Error::Unimplemented;
+		if (!service.empty() || canceled || data_closed)
+			return Error::Completed;
+		service = packet.rpc_service();
+		method = packet.rpc_method();
+	}
+
+	if (!packet.data().empty() || packet.data_is_zero()) {
+		srpc::CallData first;
+		first.set_data(packet.data());
+		first.set_data_is_zero(packet.data_is_zero());
+		const auto queued = HandleCallData(first);
+		if (queued != Error::OK)
+			return queued;
+	}
+
+	/*
+	 * Thread creation is the sole throwing runtime boundary in this
+	 * component; a stop callback cancels the call when the thread ends.
+	 */
+	try {
+		invoke_thread = std::jthread([this](std::stop_token stop) {
+			std::stop_callback canceled(stop, [this] { Cancel(); });
+			InvokeRPC(service, method);
+		});
+	} catch (const std::system_error &) {
+		Cancel();
+		return Error::ResourceExhausted;
+	}
+	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();
+			  const std::string &method_id)
+{
+	auto stream = NewMsgStream(this, [this] { Cancel(); }, StopToken());
+	auto [found, err] =
+		invoker->InvokeMethod(service_id, method_id, stream.get());
+	if (!found && err == Error::OK)
+		err = Error::Unimplemented;
+	Finish(err);
 }
 
 } // namespace starpc

package/srpc/server-rpc.go

@@ -6,15 +6,15 @@ import (
 	"github.com/pkg/errors"
 )
 
-// ServerRPC represents the server side of an on-going RPC call message stream.
+// ServerRPC runs one remote method and retains its resources until the handler exits.
 type ServerRPC struct {
 	commonRPC
-	// invoker is the rpc call invoker
+
+	// invoker dispatches the selected service and method.
 	invoker Invoker
 }
 
-// NewServerRPC constructs a new ServerRPC session.
-// note: call SetWriter before handling any incoming messages.
+// NewServerRPC attaches the handler and transport for one incoming call.
 func NewServerRPC(ctx context.Context, invoker Invoker, writer PacketWriter) *ServerRPC {
 	rpc := &ServerRPC{invoker: invoker}
 	initCommonRPC(ctx, &rpc.commonRPC)
@@ -33,6 +33,7 @@ func (r *ServerRPC) HandlePacketData(data []byte) error {
 
 // HandlePacket handles an incoming parsed message packet.
 func (r *ServerRPC) HandlePacket(msg *Packet) error {
+	// Ignore an absent packet and reject malformed messages before dispatch.
 	if msg == nil {
 		return nil
 	}
@@ -40,6 +41,7 @@ func (r *ServerRPC) HandlePacket(msg *Packet) error {
 		return err
 	}
 
+	// Route each packet through the shared stream state.
 	switch b := msg.GetBody().(type) {
 	case *Packet_CallStart:
 		return r.HandleCallStart(b.CallStart)
@@ -57,25 +59,20 @@ func (r *ServerRPC) HandlePacket(msg *Packet) error {
 
 // HandleCallStart handles the call start packet.
 func (r *ServerRPC) HandleCallStart(pkt *CallStart) error {
-	var err error
-
+	// Accept one start before any terminal stream transition.
 	locked := r.bcast.Lock()
-	// process start: method and service
 	if r.method != "" || r.service != "" {
-		err = errors.New("call start must be sent only once")
 		locked.Unlock()
-		return err
+		return errors.New("call start must be sent only once")
 	}
 	if r.dataClosed {
-		err = ErrCompleted
 		locked.Unlock()
-		return err
+		return ErrCompleted
 	}
 
+	// Retain the request identity and optional first message for the handler.
 	service, method := pkt.GetRpcService(), pkt.GetRpcMethod()
 	r.service, r.method = service, method
-
-	// process first data packet, if included
 	if data := pkt.GetData(); len(data) != 0 || pkt.GetDataIsZero() {
 		r.dataQueue = append(r.dataQueue, data)
 	}
@@ -84,27 +81,32 @@ func (r *ServerRPC) HandleCallStart(pkt *CallStart) error {
 	// Mark the method active before scheduling it so cancellation cannot make
 	// Wait return and release a mux while invokeRPC is still running user code.
 	r.localActive = true
-
-	// invoke the rpc
 	locked.Broadcast()
 	startServerRPCInvoke(func() {
 		r.invokeRPC(service, method)
 	})
 	locked.Unlock()
 
-	return err
+	return nil
 }
 
 // invokeRPC invokes the RPC after CallStart is received.
 func (r *ServerRPC) invokeRPC(serviceID, methodID string) {
-	// on the server side, the writer is closed by invokeRPC.
+	// Run the selected handler before publishing its terminal result.
 	strm := NewMsgStream(r.ctx, r, r.cancelContext)
 	ok, err := r.invoker.InvokeMethod(serviceID, methodID, strm)
 	if err == nil && !ok {
 		err = ErrUnimplemented
 	}
-	r.beginLocalCompletion()
+
+	// Cancellation has its own packet; a text error would lose its identity.
 	outPkt := NewCallDataPacket(nil, false, true, err)
-	_ = r.writer.WritePacket(outPkt)
+	if errors.Is(err, context.Canceled) {
+		outPkt = NewCallCancelPacket()
+	}
+	r.beginLocalCompletion()
+	if err := r.writer.WritePacket(outPkt); err != nil {
+		r.HandleStreamClose(err)
+	}
 	r.finishLocalCompletion()
 }