starpc 0.52.0 → 0.52.2

package/integration/cross-language/cpp-server.cpp

@@ -1,7 +1,14 @@
 //go:build deps_only
 
-// C++ TCP integration server for cross-language testing.
-// Listens on TCP, handles one RPC per connection using length-prefixed packets.
+/*
+ * C++ TCP integration server for cross-language testing: it listens on TCP
+ * and serves one RPC per connection over length-prefixed packets.
+ */
+
+#include "echo/echo_srpc.pb.hpp"
+#include "rpcstream/rpcstream.hpp"
+#include "srpc/rpcproto.pb.h"
+#include "srpc/starpc.hpp"
 
 #include <arpa/inet.h>
 #include <csignal>
@@ -13,209 +20,238 @@
 #include <sys/socket.h>
 #include <thread>
 #include <unistd.h>
-
-#include "echo/echo_srpc.pb.hpp"
-#include "rpcstream/rpcstream.hpp"
-#include "srpc/rpcproto.pb.h"
-#include "srpc/starpc.hpp"
+#include <vector>
 
 namespace {
 
-// ReadFull reads exactly n bytes from fd.
-bool ReadFull(int fd, void *buf, size_t n) {
-  size_t total = 0;
-  while (total < n) {
-    ssize_t r = read(fd, static_cast<char *>(buf) + total, n - total);
-    if (r <= 0)
-      return false;
-    total += r;
-  }
-  return true;
+/* ReadFull reads exactly n bytes from fd, reporting short reads as false. */
+bool ReadFull(int fd, void *buf, size_t n)
+{
+	size_t total = 0;
+	while (total < n) {
+		ssize_t r =
+			read(fd, static_cast<char *>(buf) + total, n - total);
+		if (r <= 0)
+			return false;
+		total += r;
+	}
+	return true;
 }
 
-// WriteFull writes exactly n bytes to fd.
-bool WriteFull(int fd, const void *buf, size_t n) {
-  size_t total = 0;
-  while (total < n) {
-    ssize_t w = write(fd, static_cast<const char *>(buf) + total, n - total);
-    if (w <= 0)
-      return false;
-    total += w;
-  }
-  return true;
+/* WriteFull writes exactly n bytes to fd, reporting short writes as false. */
+bool WriteFull(int fd, const void *buf, size_t n)
+{
+	size_t total = 0;
+	while (total < n) {
+		ssize_t w = write(fd, static_cast<const char *>(buf) + total,
+				  n - total);
+		if (w <= 0)
+			return false;
+		total += w;
+	}
+	return true;
 }
 
-// TcpPacketWriter writes length-prefixed packets to a TCP socket.
+/*
+ * TcpPacketWriter writes length-prefixed packets to a TCP socket. The fd is
+ * borrowed and closed by the connection handler, not the writer.
+ */
 class TcpPacketWriter : public starpc::PacketWriter {
 public:
-  explicit TcpPacketWriter(int fd) : fd_(fd) {}
-
-  starpc::Error WritePacket(const srpc::Packet &pkt) override {
-    std::lock_guard<std::mutex> lock(mtx_);
-    std::string data;
-    if (!pkt.SerializeToString(&data))
-      return starpc::Error::InvalidMessage;
-
-    uint32_t len = static_cast<uint32_t>(data.size());
-    // Write LE uint32 length prefix.
-    if (!WriteFull(fd_, &len, 4))
-      return starpc::Error::EOF_;
-    if (!WriteFull(fd_, data.data(), data.size()))
-      return starpc::Error::EOF_;
-    return starpc::Error::OK;
-  }
-
-  starpc::Error Close() override {
-    shutdown(fd_, SHUT_WR);
-    return starpc::Error::OK;
-  }
+	explicit TcpPacketWriter(int fd)
+		: fd(fd)
+	{
+	}
+
+	starpc::Error WritePacket(const srpc::Packet &pkt) override
+	{
+		std::lock_guard<std::mutex> lock(mu);
+
+		std::string data;
+		if (!pkt.SerializeToString(&data))
+			return starpc::Error::InvalidMessage;
+
+		/* The length prefix is a little-endian uint32. */
+		uint32_t len = static_cast<uint32_t>(data.size());
+		if (!WriteFull(fd, &len, 4))
+			return starpc::Error::EOF_;
+		if (!WriteFull(fd, data.data(), data.size()))
+			return starpc::Error::EOF_;
+		return starpc::Error::OK;
+	}
+
+	starpc::Error Close() override
+	{
+		shutdown(fd, SHUT_WR);
+		return starpc::Error::OK;
+	}
 
 private:
-  int fd_;
-  std::mutex mtx_;
+	int fd;
+	std::mutex mu;
 };
 
-// EchoServerImpl implements the echo service.
+/* EchoServerImpl implements the echo service under test. */
 class EchoServerImpl : public echo::SRPCEchoerServer {
 public:
-  starpc::Error Echo(const echo::EchoMsg &req, echo::EchoMsg *resp) override {
-    resp->set_body(req.body());
-    return starpc::Error::OK;
-  }
-
-  starpc::Error
-  EchoServerStream(const echo::EchoMsg &req,
-                   echo::SRPCEchoer_EchoServerStreamStream *strm) override {
-    for (int i = 0; i < 5; i++) {
-      echo::EchoMsg msg;
-      msg.set_body(req.body());
-      starpc::Error err = strm->Send(msg);
-      if (err != starpc::Error::OK)
-        return err;
-    }
-    return starpc::Error::OK;
-  }
-
-  starpc::Error EchoClientStream(echo::SRPCEchoer_EchoClientStreamStream *strm,
-                                 echo::EchoMsg *resp) override {
-    echo::EchoMsg msg;
-    starpc::Error err = strm->Recv(&msg);
-    if (err != starpc::Error::OK)
-      return err;
-    resp->set_body(msg.body());
-    return starpc::Error::OK;
-  }
-
-  starpc::Error
-  EchoBidiStream(echo::SRPCEchoer_EchoBidiStreamStream *strm) override {
-    // Send initial message (matches Go server behavior).
-    echo::EchoMsg init;
-    init.set_body("hello from server");
-    starpc::Error err = strm->Send(init);
-    if (err != starpc::Error::OK)
-      return err;
-
-    while (true) {
-      echo::EchoMsg msg;
-      err = strm->Recv(&msg);
-      if (err == starpc::Error::EOF_)
-        break;
-      if (err != starpc::Error::OK)
-        return err;
-      err = strm->Send(msg);
-      if (err != starpc::Error::OK)
-        return err;
-    }
-    return starpc::Error::OK;
-  }
-
-  starpc::Error RpcStream(echo::SRPCEchoer_RpcStreamStream *) override {
-    return starpc::Error::Unimplemented;
-  }
-
-  starpc::Error DoNothing(const google::protobuf::Empty &,
-                          google::protobuf::Empty *) override {
-    return starpc::Error::OK;
-  }
+	starpc::Error Echo(const echo::EchoMsg &req,
+			   echo::EchoMsg *resp) override
+	{
+		resp->set_body(req.body());
+		return starpc::Error::OK;
+	}
+
+	starpc::Error
+	EchoServerStream(const echo::EchoMsg &req,
+			 echo::SRPCEchoer_EchoServerStreamStream *strm) override
+	{
+		for (int i = 0; i < 5; i++) {
+			echo::EchoMsg msg;
+			msg.set_body(req.body());
+			starpc::Error err = strm->Send(msg);
+			if (err != starpc::Error::OK)
+				return err;
+		}
+		return starpc::Error::OK;
+	}
+
+	starpc::Error
+	EchoClientStream(echo::SRPCEchoer_EchoClientStreamStream *strm,
+			 echo::EchoMsg *resp) override
+	{
+		echo::EchoMsg msg;
+		starpc::Error err = strm->Recv(&msg);
+		if (err != starpc::Error::OK)
+			return err;
+		resp->set_body(msg.body());
+		return starpc::Error::OK;
+	}
+
+	starpc::Error
+	EchoBidiStream(echo::SRPCEchoer_EchoBidiStreamStream *strm) override
+	{
+		/* Send the initial message the other clients expect. */
+		echo::EchoMsg init;
+		init.set_body("hello from server");
+		starpc::Error err = strm->Send(init);
+		if (err != starpc::Error::OK)
+			return err;
+
+		while (true) {
+			echo::EchoMsg msg;
+			err = strm->Recv(&msg);
+			if (err == starpc::Error::EOF_)
+				break;
+			if (err != starpc::Error::OK)
+				return err;
+			err = strm->Send(msg);
+			if (err != starpc::Error::OK)
+				return err;
+		}
+		return starpc::Error::OK;
+	}
+
+	starpc::Error RpcStream(echo::SRPCEchoer_RpcStreamStream *) override
+	{
+		return starpc::Error::Unimplemented;
+	}
+
+	starpc::Error DoNothing(const google::protobuf::Empty &,
+				google::protobuf::Empty *) override
+	{
+		return starpc::Error::OK;
+	}
 };
 
-// HandleConnection handles one TCP connection (one RPC).
-void HandleConnection(int fd, starpc::Mux *mux) {
-  auto writer = std::make_unique<TcpPacketWriter>(fd);
-  auto serverRpc = starpc::NewServerRPC(mux, writer.get());
-
-  while (true) {
-    // Read 4-byte LE uint32 length prefix.
-    uint32_t len = 0;
-    if (!ReadFull(fd, &len, 4))
-      break;
-
-    // Read the packet data.
-    std::string data(len, '\0');
-    if (!ReadFull(fd, data.data(), len))
-      break;
-
-    starpc::Error err = serverRpc->HandlePacketData(data);
-    if (err != starpc::Error::OK && err != starpc::Error::Completed)
-      break;
-  }
-
-  close(fd);
+/*
+ * HandleConnection serves one TCP connection: it reads length-prefixed
+ * packets until the socket ends, then closes the fd.
+ */
+void HandleConnection(int fd, starpc::Mux *mux)
+{
+	auto writer = std::make_unique<TcpPacketWriter>(fd);
+	auto server_rpc = starpc::NewServerRPC(mux, writer.get());
+
+	while (true) {
+		/* The length prefix is a little-endian uint32. */
+		uint32_t len = 0;
+		if (!ReadFull(fd, &len, 4))
+			break;
+
+		std::string data(len, '\0');
+		if (!ReadFull(fd, data.data(), len))
+			break;
+
+		starpc::Error err = server_rpc->HandlePacketData(data);
+		if (err != starpc::Error::OK && err != starpc::Error::Completed)
+			break;
+	}
+
+	close(fd);
 }
 
 } // namespace
 
-int main() {
-  signal(SIGPIPE, SIG_IGN);
-
-  auto mux = starpc::NewMux();
-  EchoServerImpl server;
-  auto [handler, err] = echo::SRPCRegisterEchoer(mux.get(), &server);
-  (void)handler;
-  if (err != starpc::Error::OK) {
-    std::cerr << "register error: " << starpc::ErrorString(err) << std::endl;
-    return 1;
-  }
-
-  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
-  if (sockfd < 0) {
-    std::cerr << "socket error" << std::endl;
-    return 1;
-  }
-
-  int opt = 1;
-  setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
-
-  struct sockaddr_in addr {};
-  addr.sin_family = AF_INET;
-  addr.sin_port = 0; // OS-assigned port.
-  addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-
-  if (bind(sockfd, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) <
-      0) {
-    std::cerr << "bind error" << std::endl;
-    close(sockfd);
-    return 1;
-  }
-
-  if (listen(sockfd, 10) < 0) {
-    std::cerr << "listen error" << std::endl;
-    close(sockfd);
-    return 1;
-  }
-
-  // Get the assigned port.
-  socklen_t addrLen = sizeof(addr);
-  getsockname(sockfd, reinterpret_cast<struct sockaddr *>(&addr), &addrLen);
-  std::cout << "LISTENING 127.0.0.1:" << ntohs(addr.sin_port) << std::endl;
-
-  while (true) {
-    int clientFd = accept(sockfd, nullptr, nullptr);
-    if (clientFd < 0)
-      break;
-    std::thread(HandleConnection, clientFd, mux.get()).detach();
-  }
-
-  close(sockfd);
-  return 0;
+int main()
+{
+	signal(SIGPIPE, SIG_IGN);
+
+	auto mux = starpc::NewMux();
+	EchoServerImpl server;
+	auto [handler, err] = echo::SRPCRegisterEchoer(mux.get(), &server);
+	(void)handler;
+	if (err != starpc::Error::OK) {
+		std::cerr << "register error: " << starpc::ErrorString(err)
+			  << std::endl;
+		return 1;
+	}
+
+	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
+	if (sockfd < 0) {
+		std::cerr << "socket error" << std::endl;
+		return 1;
+	}
+
+	int opt = 1;
+	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+	struct sockaddr_in addr{};
+	addr.sin_family = AF_INET;
+	addr.sin_port = 0; /* OS-assigned port. */
+	addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+
+	if (bind(sockfd, reinterpret_cast<struct sockaddr *>(&addr),
+		 sizeof(addr)) < 0) {
+		std::cerr << "bind error" << std::endl;
+		close(sockfd);
+		return 1;
+	}
+
+	if (listen(sockfd, 10) < 0) {
+		std::cerr << "listen error" << std::endl;
+		close(sockfd);
+		return 1;
+	}
+
+	/* Report the assigned port so the test driver can connect. */
+	socklen_t addr_len = sizeof(addr);
+	getsockname(sockfd, reinterpret_cast<struct sockaddr *>(&addr),
+		    &addr_len);
+	std::cout << "LISTENING 127.0.0.1:" << ntohs(addr.sin_port)
+		  << std::endl;
+
+	/* Connection threads borrow mux, so join them before it ends. */
+	std::vector<std::thread> connections;
+	while (true) {
+		int client_fd = accept(sockfd, nullptr, nullptr);
+		if (client_fd < 0)
+			break;
+		connections.emplace_back(HandleConnection, client_fd,
+					 mux.get());
+	}
+
+	close(sockfd);
+	for (auto &connection : connections)
+		connection.join();
+	return 0;
 }

package/integration/cross-language/go-client/main.go

@@ -6,19 +6,23 @@ import (
 	"io"
 	"net"
 	"os"
+	"strings"
 
 	"github.com/aperturerobotics/starpc/echo"
+	"github.com/aperturerobotics/starpc/rpcstream"
 	"github.com/aperturerobotics/starpc/srpc"
 )
 
 const bodyTxt = "hello world via starpc cross-language e2e test"
 
 func main() {
-	if len(os.Args) <= 1 {
-		fmt.Fprintf(os.Stderr, "usage: go-client <addr>\n")
+	nested := len(os.Args) >= 3 && os.Args[1] == "--nested"
+	nestedRelease := len(os.Args) >= 3 && os.Args[1] == "--nested-release"
+	if len(os.Args) != 2 && !nested && !nestedRelease {
+		fmt.Fprintf(os.Stderr, "usage: go-client [--nested] <addr>\n")
 		os.Exit(1)
 	}
-	addr := os.Args[1]
+	addr := os.Args[len(os.Args)-1]
 	openStream := func(ctx context.Context, msgHandler srpc.PacketDataHandler, closeHandler srpc.CloseHandler) (srpc.PacketWriter, error) {
 		conn, err := net.Dial("tcp", addr) //nolint:gosec
 		if err != nil {
@@ -48,6 +52,12 @@ func main() {
 		fmt.Fprintf(os.Stderr, "bidi stream test failed: %v\n", err)
 		os.Exit(1)
 	}
+	if nested || nestedRelease {
+		if err := testNested(ctx, echoClient, nestedRelease); err != nil {
+			fmt.Fprintf(os.Stderr, "nested lifecycle test failed: %v\n", err)
+			os.Exit(1)
+		}
+	}
 	fmt.Println("All tests passed.")
 }
 
@@ -143,3 +153,69 @@ func testBidiStream(ctx context.Context, client echo.SRPCEchoerClient) error {
 	fmt.Println("  PASSED")
 	return nil
 }
+
+func testNested(ctx context.Context, parent echo.SRPCEchoerClient, release bool) error {
+	proxy := rpcstream.NewRpcStreamClient(parent.RpcStream, "test", true)
+	if err := testUnary(ctx, echo.NewSRPCEchoerClient(proxy)); err != nil {
+		return fmt.Errorf("nested unary: %w", err)
+	}
+
+	if release {
+		missing := rpcstream.NewRpcStreamClient(parent.RpcStream, "missing", true)
+		var missingOut echo.EchoMsg
+		if err := missing.ExecCall(ctx, "echo.Echoer", "Echo", &echo.EchoMsg{}, &missingOut); err == nil || !strings.Contains(err.Error(), "unknown component: missing") {
+			return fmt.Errorf("unknown component returned wrong result: %v", err)
+		}
+	}
+
+	stream, err := proxy.NewStream(ctx, "echo.Echoer", "EchoBidiStream", nil)
+	if err != nil {
+		return fmt.Errorf("nested bidi: %w", err)
+	}
+	if err := stream.MsgSend(&echo.EchoMsg{Body: "nested later data"}); err != nil {
+		return fmt.Errorf("nested later data: %w", err)
+	}
+	if err := stream.Close(); err != nil {
+		return fmt.Errorf("nested cancel: %w", err)
+	}
+
+	var terminal echo.EchoMsg
+	if err := proxy.ExecCall(ctx, "missing.Service", "Missing", &echo.EchoMsg{}, &terminal); err == nil || !strings.Contains(err.Error(), "missing.Service") {
+		return fmt.Errorf("unknown nested method returned wrong result: %v", err)
+	}
+
+	if release {
+		var terminalError echo.EchoMsg
+		if err := proxy.ExecCall(ctx, "echo.Echoer", "Echo", &echo.EchoMsg{Body: "__nested_error__"}, &terminalError); err == nil || !strings.Contains(err.Error(), "nested terminal error") {
+			return fmt.Errorf("terminal nested error returned wrong result: %v", err)
+		}
+	}
+
+	if release {
+		releaseClient := rpcstream.NewRpcStreamClient(parent.RpcStream, "release", true)
+		var released echo.EchoMsg
+		err := releaseClient.ExecCall(ctx, "echo.Echoer", "Echo", &echo.EchoMsg{Body: "__nested_release__"}, &released)
+		if err == nil || (!strings.Contains(err.Error(), "stream closed before the remote reported completion") && !strings.Contains(err.Error(), "EOF") && !strings.Contains(err.Error(), "canceled")) {
+			return fmt.Errorf("release during active call returned wrong result: %v", err)
+		}
+		status, err := parent.Echo(ctx, &echo.EchoMsg{Body: "__nested_release_status__"})
+		if err != nil {
+			return fmt.Errorf("release completion status failed: %w", err)
+		}
+		if status.GetBody() != "released" {
+			return fmt.Errorf("release completion returned %q", status.GetBody())
+		}
+		if err := releaseClient.ExecCall(ctx, "echo.Echoer", "Echo", &echo.EchoMsg{}, &released); err == nil || !strings.Contains(err.Error(), "unknown component: release") {
+			return fmt.Errorf("released component returned wrong result: %v", err)
+		}
+	}
+
+	direct, err := rpcstream.OpenRpcStream(ctx, parent.RpcStream, "test", true)
+	if err != nil {
+		return fmt.Errorf("nested direct open: %w", err)
+	}
+	if err := direct.Close(); err != nil {
+		return fmt.Errorf("nested abrupt close: %w", err)
+	}
+	return nil
+}