starpc 0.52.1 → 0.52.2

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

@@ -0,0 +1,139 @@
+//go:build deps_only
+
+/*
+ * C++ pipe integration server for cross-language testing: it serves one RPC
+ * session over length-prefixed packets on stdin and stdout.
+ */
+
+#include "echo/echo_srpc.pb.hpp"
+#include "srpc/rpcproto.pb.h"
+#include "srpc/server-rpc.hpp"
+
+#include <array>
+#include <csignal>
+#include <iostream>
+#include <mutex>
+
+#ifdef _WIN32
+#include <fcntl.h>
+#include <io.h>
+#endif
+
+namespace {
+
+/*
+ * PipeWriter writes length-prefixed packets to stdout. Close stops further
+ * writes; the process exits when stdin ends, so no destructor is needed.
+ */
+class PipeWriter final : public starpc::PacketWriter {
+public:
+	starpc::Error WritePacket(const srpc::Packet &packet) override
+	{
+		std::lock_guard lock(write_mutex);
+		if (closed)
+			return starpc::Error::Canceled;
+
+		const auto data = packet.SerializeAsString();
+		const auto size = static_cast<uint32_t>(data.size());
+		const std::array<char, 4> header{static_cast<char>(size),
+						 static_cast<char>(size >> 8),
+						 static_cast<char>(size >> 16),
+						 static_cast<char>(size >> 24)};
+		std::cout.write(header.data(), header.size());
+		std::cout.write(data.data(), data.size());
+		std::cout.flush();
+		return std::cout ? starpc::Error::OK : starpc::Error::Canceled;
+	}
+	starpc::Error Close() override
+	{
+		closed = true;
+		return starpc::Error::OK;
+	}
+
+private:
+	std::mutex write_mutex;
+	std::atomic<bool> closed{false};
+};
+
+/* PipeEcho implements the echo service under test. */
+class PipeEcho final : public echo::SRPCEchoerServer {
+public:
+	starpc::Error Echo(const echo::EchoMsg &request,
+			   echo::EchoMsg *response) override
+	{
+		*response = request;
+		return starpc::Error::OK;
+	}
+	starpc::Error EchoServerStream(
+		const echo::EchoMsg &request,
+		echo::SRPCEchoer_EchoServerStreamStream *stream) override
+	{
+		return stream->Send(request);
+	}
+	starpc::Error
+	EchoClientStream(echo::SRPCEchoer_EchoClientStreamStream *stream,
+			 echo::EchoMsg *response) override
+	{
+		return stream->Recv(response);
+	}
+	starpc::Error
+	EchoBidiStream(echo::SRPCEchoer_EchoBidiStreamStream *stream) override
+	{
+		echo::EchoMsg message;
+		while (true) {
+			const auto read = stream->Recv(&message);
+			if (read == starpc::Error::EOF_)
+				return starpc::Error::OK;
+			if (read != starpc::Error::OK)
+				return read;
+			const auto sent = stream->Send(message);
+			if (sent != starpc::Error::OK)
+				return sent;
+		}
+	}
+	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;
+	}
+};
+
+} // namespace
+
+int main()
+{
+#ifdef _WIN32
+	_setmode(_fileno(stdin), _O_BINARY);
+	_setmode(_fileno(stdout), _O_BINARY);
+#else
+	std::signal(SIGPIPE, SIG_IGN);
+#endif
+	PipeEcho service;
+	const auto handler = echo::NewSRPCEchoerHandler(&service);
+	PipeWriter writer;
+	starpc::ServerRPC rpc(handler.get(), &writer);
+	while (true) {
+		std::array<unsigned char, 4> header{};
+		std::cin.read(reinterpret_cast<char *>(header.data()),
+			      header.size());
+		if (!std::cin)
+			break;
+		const uint32_t size = static_cast<uint32_t>(header[0]) |
+				      static_cast<uint32_t>(header[1]) << 8 |
+				      static_cast<uint32_t>(header[2]) << 16 |
+				      static_cast<uint32_t>(header[3]) << 24;
+		if (size == 0 || size > 10'000'000)
+			return 2;
+		std::string packet(size, '\0');
+		std::cin.read(packet.data(), packet.size());
+		if (!std::cin)
+			return 2;
+		if (rpc.HandlePacketData(packet) != starpc::Error::OK)
+			return 2;
+	}
+	rpc.HandleStreamClose(starpc::Error::EOF_);
+}

package/integration/cross-language/cpp-pipe_test.go

@@ -0,0 +1,114 @@
+package integration
+
+import (
+	"context"
+	"io"
+	"os"
+	"os/exec"
+	"testing"
+	"time"
+
+	"github.com/aperturerobotics/starpc/echo"
+	"github.com/aperturerobotics/starpc/srpc"
+)
+
+// processPipe joins the separate stdin/stdout handles used by the native process.
+type processPipe struct {
+	// input carries packets to the child.
+	input io.WriteCloser
+	// output carries replies from the child.
+	output io.ReadCloser
+}
+
+// Read receives framed data from the child.
+func (p *processPipe) Read(data []byte) (int, error) { return p.output.Read(data) }
+
+// Write sends framed data to the child.
+func (p *processPipe) Write(data []byte) (int, error) { return p.input.Write(data) }
+
+// Close interrupts both directions of the child connection.
+func (p *processPipe) Close() error {
+	inputErr := p.input.Close()
+	outputErr := p.output.Close()
+	if inputErr != nil {
+		return inputErr
+	}
+	return outputErr
+}
+
+func TestCppProcessPipe(t *testing.T) {
+	binary := os.Getenv("STARPC_CPP_PIPE_SERVER")
+	if binary == "" {
+		t.Skip("set STARPC_CPP_PIPE_SERVER to the compiled C++ pipe server")
+	}
+	for _, abrupt := range []bool{false, true} {
+		t.Run(map[bool]string{false: "complete", true: "disconnect"}[abrupt], func(t *testing.T) {
+			// Start a real C++ process with the same pipe framing used by Go.
+			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+			t.Cleanup(cancel)
+			cmd := exec.CommandContext(ctx, binary) //nolint:gosec // the caller names the server binary
+			input, err := cmd.StdinPipe()
+			if err != nil {
+				t.Fatal(err)
+			}
+			output, err := cmd.StdoutPipe()
+			if err != nil {
+				t.Fatal(err)
+			}
+			cmd.Stderr = os.Stderr
+			if err := cmd.Start(); err != nil {
+				t.Fatal(err)
+			}
+			connection := &processPipe{input: input, output: output}
+			transport := srpc.NewPacketReadWriter(connection)
+			readerDone := make(chan struct{})
+			client := srpc.NewClient(func(_ context.Context, handler srpc.PacketDataHandler, closed srpc.CloseHandler) (srpc.PacketWriter, error) {
+				go func() {
+					defer close(readerDone)
+					transport.ReadPump(handler, closed)
+				}()
+				return transport, nil
+			})
+			t.Cleanup(func() {
+				_ = connection.Close()
+				<-readerDone
+				if err := cmd.Wait(); err != nil {
+					t.Errorf("C++ process shutdown: %v", err)
+				}
+			})
+
+			// Successive requests use the same running process and generated API.
+			stream, err := echo.NewSRPCEchoerClient(client).EchoBidiStream(t.Context())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, body := range []string{"", "initial setup", "apply another activity"} {
+				if err := stream.MsgSend(&echo.EchoMsg{Body: body}); err != nil {
+					t.Fatal(err)
+				}
+				reply, err := stream.Recv()
+				if err != nil {
+					t.Fatal(err)
+				}
+				if reply.Body != body {
+					t.Fatalf("reply %q, wanted %q", reply.Body, body)
+				}
+			}
+
+			// An explicit half-close completes normally; a dropped pipe cancels the
+			// blocked C++ handler and process destruction joins it.
+			if abrupt {
+				_ = connection.Close()
+				return
+			}
+			if err := stream.CloseSend(); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := stream.Recv(); err != io.EOF {
+				t.Fatalf("completion returned %v", err)
+			}
+		})
+	}
+}
+
+var _ io.ReadWriteCloser = (*processPipe)(nil)