starpc 0.52.0 → 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/rpcproto_pb2.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: github.com/aperturerobotics/starpc/srpc/rpcproto.proto
+# Protobuf Python Version: 6.33.4
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    33,
+    4,
+    '',
+    'github.com/aperturerobotics/starpc/srpc/rpcproto.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n6github.com/aperturerobotics/starpc/srpc/rpcproto.proto\x12\x04srpc\"s\n\x06Packet\x12%\n\ncall_start\x18\x01 \x01(\x0b\x32\x0f.srpc.CallStartH\x00\x12#\n\tcall_data\x18\x02 \x01(\x0b\x32\x0e.srpc.CallDataH\x00\x12\x15\n\x0b\x63\x61ll_cancel\x18\x03 \x01(\x08H\x00\x42\x06\n\x04\x62ody\"X\n\tCallStart\x12\x13\n\x0brpc_service\x18\x01 \x01(\t\x12\x12\n\nrpc_method\x18\x02 \x01(\t\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\x12\x14\n\x0c\x64\x61ta_is_zero\x18\x04 \x01(\x08\"O\n\x08\x43\x61llData\x12\x0c\n\x04\x64\x61ta\x18\x01 \x01(\x0c\x12\x14\n\x0c\x64\x61ta_is_zero\x18\x02 \x01(\x08\x12\x10\n\x08\x63omplete\x18\x03 \x01(\x08\x12\r\n\x05\x65rror\x18\x04 \x01(\tb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'github.com.aperturerobotics.starpc.srpc.rpcproto_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_PACKET']._serialized_start=64
+  _globals['_PACKET']._serialized_end=179
+  _globals['_CALLSTART']._serialized_start=181
+  _globals['_CALLSTART']._serialized_end=269
+  _globals['_CALLDATA']._serialized_start=271
+  _globals['_CALLDATA']._serialized_end=350
+# @@protoc_insertion_point(module_scope)

package/srpc/rpcproto_pb2.pyi

@@ -0,0 +1,40 @@
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class Packet(_message.Message):
+    __slots__ = ("call_start", "call_data", "call_cancel")
+    CALL_START_FIELD_NUMBER: _ClassVar[int]
+    CALL_DATA_FIELD_NUMBER: _ClassVar[int]
+    CALL_CANCEL_FIELD_NUMBER: _ClassVar[int]
+    call_start: CallStart
+    call_data: CallData
+    call_cancel: bool
+    def __init__(self, call_start: _Optional[_Union[CallStart, _Mapping]] = ..., call_data: _Optional[_Union[CallData, _Mapping]] = ..., call_cancel: _Optional[bool] = ...) -> None: ...
+
+class CallStart(_message.Message):
+    __slots__ = ("rpc_service", "rpc_method", "data", "data_is_zero")
+    RPC_SERVICE_FIELD_NUMBER: _ClassVar[int]
+    RPC_METHOD_FIELD_NUMBER: _ClassVar[int]
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    DATA_IS_ZERO_FIELD_NUMBER: _ClassVar[int]
+    rpc_service: str
+    rpc_method: str
+    data: bytes
+    data_is_zero: bool
+    def __init__(self, rpc_service: _Optional[str] = ..., rpc_method: _Optional[str] = ..., data: _Optional[bytes] = ..., data_is_zero: _Optional[bool] = ...) -> None: ...
+
+class CallData(_message.Message):
+    __slots__ = ("data", "data_is_zero", "complete", "error")
+    DATA_FIELD_NUMBER: _ClassVar[int]
+    DATA_IS_ZERO_FIELD_NUMBER: _ClassVar[int]
+    COMPLETE_FIELD_NUMBER: _ClassVar[int]
+    ERROR_FIELD_NUMBER: _ClassVar[int]
+    data: bytes
+    data_is_zero: bool
+    complete: bool
+    error: str
+    def __init__(self, data: _Optional[bytes] = ..., data_is_zero: _Optional[bool] = ..., complete: _Optional[bool] = ..., error: _Optional[str] = ...) -> None: ...

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