starpc 0.46.0 → 0.46.2

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

@@ -0,0 +1,448 @@
+//go:build deps_only
+
+// C++ TCP integration client for cross-language testing.
+// Connects to a TCP server, runs the echo test suite.
+
+#include <arpa/inet.h>
+#include <atomic>
+#include <csignal>
+#include <cstdint>
+#include <cstring>
+#include <iostream>
+#include <mutex>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <thread>
+#include <unistd.h>
+
+#include "echo/echo_srpc.pb.hpp"
+#include "srpc/rpcproto.pb.h"
+#include "srpc/starpc.hpp"
+
+namespace {
+
+const char *kTestBody = "hello world via starpc cross-language e2e test";
+
+// 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;
+}
+
+// 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;
+}
+
+// TcpPacketWriter writes length-prefixed packets to a TCP socket.
+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());
+    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_;
+};
+
+// Connect to TCP server, returns socket fd.
+int TcpConnect(const std::string &host, int port) {
+  int fd = socket(AF_INET, SOCK_STREAM, 0);
+  if (fd < 0)
+    return -1;
+
+  struct sockaddr_in addr {};
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons(port);
+  inet_pton(AF_INET, host.c_str(), &addr.sin_addr);
+
+  if (connect(fd, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) <
+      0) {
+    close(fd);
+    return -1;
+  }
+  return fd;
+}
+
+// ReadPacketLoop reads length-prefixed packets from fd and feeds them to rpc.
+void ReadPacketLoop(int fd, starpc::ClientRPC *rpc, std::atomic<bool> *done) {
+  while (!done->load()) {
+    uint32_t len = 0;
+    if (!ReadFull(fd, &len, 4)) {
+      rpc->HandleStreamClose(starpc::Error::EOF_);
+      break;
+    }
+    std::string data(len, '\0');
+    if (!ReadFull(fd, data.data(), len)) {
+      rpc->HandleStreamClose(starpc::Error::EOF_);
+      break;
+    }
+    starpc::Error err = rpc->HandlePacketData(data);
+    if (err != starpc::Error::OK)
+      break;
+  }
+}
+
+// CleanupConn shuts down the socket, joins the reader thread, then closes fd.
+// Must be called to avoid fd reuse races between close() and the reader thread.
+void CleanupConn(int fd, std::atomic<bool> &done, std::thread &reader) {
+  done.store(true);
+  shutdown(fd, SHUT_RDWR);
+  reader.join();
+  close(fd);
+}
+
+// ParseAddr parses "host:port" into host and port.
+bool ParseAddr(const std::string &addr, std::string *host, int *port) {
+  auto pos = addr.rfind(':');
+  if (pos == std::string::npos)
+    return false;
+  *host = addr.substr(0, pos);
+  *port = std::stoi(addr.substr(pos + 1));
+  return true;
+}
+
+bool TestUnary(const std::string &host, int port) {
+  std::cout << "Testing Unary RPC... " << std::flush;
+
+  int fd = TcpConnect(host, port);
+  if (fd < 0) {
+    std::cerr << "FAILED: connect" << std::endl;
+    return false;
+  }
+
+  auto rpc = starpc::NewClientRPC("echo.Echoer", "Echo");
+  auto writer = std::make_unique<TcpPacketWriter>(fd);
+
+  std::atomic<bool> done{false};
+  std::thread reader(ReadPacketLoop, fd, rpc.get(), &done);
+
+  echo::EchoMsg req;
+  req.set_body(kTestBody);
+  std::string reqData;
+  req.SerializeToString(&reqData);
+
+  starpc::Error err = rpc->Start(writer.get(), true, reqData);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: start: " << starpc::ErrorString(err) << std::endl;
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  std::string respData;
+  err = rpc->ReadOne(&respData);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: read: " << starpc::ErrorString(err) << std::endl;
+    rpc->Close();
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  echo::EchoMsg resp;
+  if (!resp.ParseFromString(respData) || resp.body() != kTestBody) {
+    std::cerr << "FAILED: body mismatch" << std::endl;
+    rpc->Close();
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  rpc->Close();
+  CleanupConn(fd, done, reader);
+
+  std::cout << "PASSED" << std::endl;
+  return true;
+}
+
+bool TestServerStream(const std::string &host, int port) {
+  std::cout << "Testing ServerStream RPC... " << std::flush;
+
+  int fd = TcpConnect(host, port);
+  if (fd < 0) {
+    std::cerr << "FAILED: connect" << std::endl;
+    return false;
+  }
+
+  auto rpc = starpc::NewClientRPC("echo.Echoer", "EchoServerStream");
+  auto writer = std::make_unique<TcpPacketWriter>(fd);
+
+  std::atomic<bool> done{false};
+  std::thread reader(ReadPacketLoop, fd, rpc.get(), &done);
+
+  echo::EchoMsg req;
+  req.set_body(kTestBody);
+  std::string reqData;
+  req.SerializeToString(&reqData);
+
+  starpc::Error err = rpc->Start(writer.get(), true, reqData);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: start" << std::endl;
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  int received = 0;
+  for (int i = 0; i < 5; i++) {
+    std::string respData;
+    err = rpc->ReadOne(&respData);
+    if (err != starpc::Error::OK) {
+      std::cerr << "FAILED: read " << i << ": " << starpc::ErrorString(err)
+                << std::endl;
+      rpc->Close();
+      CleanupConn(fd, done, reader);
+      return false;
+    }
+    echo::EchoMsg resp;
+    if (!resp.ParseFromString(respData) || resp.body() != kTestBody) {
+      std::cerr << "FAILED: body mismatch at " << i << std::endl;
+      rpc->Close();
+      CleanupConn(fd, done, reader);
+      return false;
+    }
+    received++;
+  }
+
+  rpc->Close();
+  CleanupConn(fd, done, reader);
+
+  if (received != 5) {
+    std::cerr << "FAILED: expected 5, got " << received << std::endl;
+    return false;
+  }
+
+  std::cout << "PASSED" << std::endl;
+  return true;
+}
+
+bool TestClientStream(const std::string &host, int port) {
+  std::cout << "Testing ClientStream RPC... " << std::flush;
+
+  int fd = TcpConnect(host, port);
+  if (fd < 0) {
+    std::cerr << "FAILED: connect" << std::endl;
+    return false;
+  }
+
+  auto rpc = starpc::NewClientRPC("echo.Echoer", "EchoClientStream");
+  auto writer = std::make_unique<TcpPacketWriter>(fd);
+
+  std::atomic<bool> done{false};
+  std::thread reader(ReadPacketLoop, fd, rpc.get(), &done);
+
+  starpc::Error err = rpc->Start(writer.get(), false, "");
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: start" << std::endl;
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  echo::EchoMsg req;
+  req.set_body(kTestBody);
+  std::string reqData;
+  req.SerializeToString(&reqData);
+
+  err = rpc->WriteCallData(reqData, false, false, starpc::Error::OK);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: write" << std::endl;
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  err = rpc->WriteCallData("", false, true, starpc::Error::OK);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: close send" << std::endl;
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  std::string respData;
+  err = rpc->ReadOne(&respData);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: read: " << starpc::ErrorString(err) << std::endl;
+    rpc->Close();
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  echo::EchoMsg resp;
+  if (!resp.ParseFromString(respData) || resp.body() != kTestBody) {
+    std::cerr << "FAILED: body mismatch" << std::endl;
+    rpc->Close();
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  rpc->Close();
+  CleanupConn(fd, done, reader);
+
+  std::cout << "PASSED" << std::endl;
+  return true;
+}
+
+bool TestBidiStream(const std::string &host, int port) {
+  std::cout << "Testing BidiStream RPC... " << std::flush;
+
+  int fd = TcpConnect(host, port);
+  if (fd < 0) {
+    std::cerr << "FAILED: connect" << std::endl;
+    return false;
+  }
+
+  auto rpc = starpc::NewClientRPC("echo.Echoer", "EchoBidiStream");
+  auto writer = std::make_unique<TcpPacketWriter>(fd);
+
+  std::atomic<bool> done{false};
+  std::thread reader(ReadPacketLoop, fd, rpc.get(), &done);
+
+  starpc::Error err = rpc->Start(writer.get(), false, "");
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: start" << std::endl;
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  // Receive initial "hello from server" message.
+  std::string initData;
+  err = rpc->ReadOne(&initData);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: read init: " << starpc::ErrorString(err) << std::endl;
+    rpc->Close();
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+  echo::EchoMsg initMsg;
+  if (!initMsg.ParseFromString(initData) ||
+      initMsg.body() != "hello from server") {
+    std::cerr << "FAILED: init body mismatch: '" << initMsg.body() << "'"
+              << std::endl;
+    rpc->Close();
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  // Send a message and expect echo.
+  echo::EchoMsg req;
+  req.set_body(kTestBody);
+  std::string reqData;
+  req.SerializeToString(&reqData);
+
+  err = rpc->WriteCallData(reqData, false, false, starpc::Error::OK);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: write" << std::endl;
+    rpc->Close();
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  std::string respData;
+  err = rpc->ReadOne(&respData);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: read echo: " << starpc::ErrorString(err) << std::endl;
+    rpc->Close();
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  echo::EchoMsg resp;
+  if (!resp.ParseFromString(respData) || resp.body() != kTestBody) {
+    std::cerr << "FAILED: echo body mismatch" << std::endl;
+    rpc->Close();
+    CleanupConn(fd, done, reader);
+    return false;
+  }
+
+  // Close send.
+  err = rpc->WriteCallData("", false, true, starpc::Error::OK);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: close send" << std::endl;
+  }
+
+  rpc->Close();
+  CleanupConn(fd, done, reader);
+
+  std::cout << "PASSED" << std::endl;
+  return true;
+}
+
+} // namespace
+
+int main(int argc, char *argv[]) {
+  // Ignore SIGPIPE so writing to a closed socket returns EPIPE instead of
+  // killing the process. The server may close its side before we send cleanup
+  // packets.
+  signal(SIGPIPE, SIG_IGN);
+
+  if (argc < 2) {
+    std::cerr << "usage: cpp-client <host:port>" << std::endl;
+    return 1;
+  }
+
+  std::string host;
+  int port;
+  if (!ParseAddr(argv[1], &host, &port)) {
+    std::cerr << "invalid address: " << argv[1] << std::endl;
+    return 1;
+  }
+
+  std::cout << "=== starpc C++ Cross-Language Client ===" << std::endl;
+
+  int passed = 0, failed = 0;
+
+  if (TestUnary(host, port))
+    passed++;
+  else
+    failed++;
+  if (TestServerStream(host, port))
+    passed++;
+  else
+    failed++;
+  if (TestClientStream(host, port))
+    passed++;
+  else
+    failed++;
+  if (TestBidiStream(host, port))
+    passed++;
+  else
+    failed++;
+
+  std::cout << std::endl
+            << "Results: " << passed << " passed, " << failed << " failed"
+            << std::endl;
+
+  if (failed > 0) {
+    std::cout << "FAILED" << std::endl;
+    return 1;
+  }
+  std::cout << "All tests passed." << std::endl;
+  return 0;
+}

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

@@ -0,0 +1,221 @@
+//go:build deps_only
+
+// C++ TCP integration server for cross-language testing.
+// Listens on TCP, handles one RPC per connection using length-prefixed packets.
+
+#include <arpa/inet.h>
+#include <csignal>
+#include <cstdint>
+#include <cstring>
+#include <iostream>
+#include <mutex>
+#include <netinet/in.h>
+#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"
+
+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;
+}
+
+// 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;
+}
+
+// TcpPacketWriter writes length-prefixed packets to a TCP socket.
+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;
+  }
+
+private:
+  int fd_;
+  std::mutex mtx_;
+};
+
+// EchoServerImpl implements the echo service.
+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;
+  }
+};
+
+// 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);
+}
+
+} // 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;
+}