starpc 0.43.1 → 0.44.0

package/dist/echo/echo.pb.js

@@ -1,4 +1,4 @@
-// @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
+// @generated by protoc-gen-es-lite unknown with parameter "ts_nocheck=false,target=ts"
 // @generated from file github.com/aperturerobotics/starpc/echo/echo.proto (package echo, syntax proto3)
 /* eslint-disable */
 import { createMessageType, ScalarType } from '@aptre/protobuf-es-lite';

package/dist/mock/mock.pb.js

@@ -1,4 +1,4 @@
-// @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
+// @generated by protoc-gen-es-lite unknown with parameter "ts_nocheck=false,target=ts"
 // @generated from file github.com/aperturerobotics/starpc/mock/mock.proto (package e2e.mock, syntax proto3)
 /* eslint-disable */
 import { createMessageType, ScalarType } from '@aptre/protobuf-es-lite';

package/dist/rpcstream/rpcstream.pb.js

@@ -1,4 +1,4 @@
-// @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
+// @generated by protoc-gen-es-lite unknown with parameter "ts_nocheck=false,target=ts"
 // @generated from file github.com/aperturerobotics/starpc/rpcstream/rpcstream.proto (package rpcstream, syntax proto3)
 /* eslint-disable */
 import { createMessageType, ScalarType } from '@aptre/protobuf-es-lite';

package/dist/srpc/rpcproto.pb.js

@@ -1,4 +1,4 @@
-// @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
+// @generated by protoc-gen-es-lite unknown with parameter "ts_nocheck=false,target=ts"
 // @generated from file github.com/aperturerobotics/starpc/srpc/rpcproto.proto (package srpc, syntax proto3)
 /* eslint-disable */
 import { createMessageType, ScalarType } from '@aptre/protobuf-es-lite';

package/echo/echo.pb.ts

@@ -1,4 +1,4 @@
-// @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
+// @generated by protoc-gen-es-lite unknown with parameter "ts_nocheck=false,target=ts"
 // @generated from file github.com/aperturerobotics/starpc/echo/echo.proto (package echo, syntax proto3)
 /* eslint-disable */
 

package/echo/echo_e2e_test.cpp

@@ -0,0 +1,289 @@
+//go:build deps_only
+
+// Echo end-to-end test for starpc C++ implementation.
+// Tests unary and streaming RPC patterns.
+
+#include <atomic>
+#include <cassert>
+#include <iostream>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <thread>
+
+#include "echo/echo_srpc.pb.hpp"
+#include "srpc/rpcproto.pb.h"
+#include "srpc/starpc.hpp"
+
+namespace {
+
+const char* kTestBody = "hello world via starpc C++ e2e test";
+
+// InMemoryTransport provides an in-memory packet transport for testing.
+// Simulates a bidirectional connection between client and server.
+class InMemoryTransport {
+ public:
+  struct Endpoint {
+    std::mutex mtx;
+    std::condition_variable cv;
+    std::queue<std::string> packets;
+    bool closed = false;
+  };
+
+  InMemoryTransport() : client_endpoint_(std::make_shared<Endpoint>()),
+                        server_endpoint_(std::make_shared<Endpoint>()) {}
+
+  // Get writer for client to send to server
+  std::shared_ptr<Endpoint> ClientToServer() { return server_endpoint_; }
+  // Get writer for server to send to client
+  std::shared_ptr<Endpoint> ServerToClient() { return client_endpoint_; }
+  // Get reader for client (reads from server)
+  std::shared_ptr<Endpoint> ClientReader() { return client_endpoint_; }
+  // Get reader for server (reads from client)
+  std::shared_ptr<Endpoint> ServerReader() { return server_endpoint_; }
+
+  static void Send(std::shared_ptr<Endpoint> ep, const std::string& data) {
+    std::lock_guard<std::mutex> lock(ep->mtx);
+    if (!ep->closed) {
+      ep->packets.push(data);
+      ep->cv.notify_all();
+    }
+  }
+
+  static bool Recv(std::shared_ptr<Endpoint> ep, std::string* out, int timeout_ms = 5000) {
+    std::unique_lock<std::mutex> lock(ep->mtx);
+    if (!ep->cv.wait_for(lock, std::chrono::milliseconds(timeout_ms), [&ep]() {
+          return !ep->packets.empty() || ep->closed;
+        })) {
+      return false;  // timeout
+    }
+    if (ep->packets.empty()) {
+      return false;  // closed
+    }
+    *out = ep->packets.front();
+    ep->packets.pop();
+    return true;
+  }
+
+  static void Close(std::shared_ptr<Endpoint> ep) {
+    std::lock_guard<std::mutex> lock(ep->mtx);
+    ep->closed = true;
+    ep->cv.notify_all();
+  }
+
+ private:
+  std::shared_ptr<Endpoint> client_endpoint_;
+  std::shared_ptr<Endpoint> server_endpoint_;
+};
+
+// InMemoryPacketWriter writes packets to an InMemoryTransport endpoint.
+class InMemoryPacketWriter : public starpc::PacketWriter {
+ public:
+  explicit InMemoryPacketWriter(std::shared_ptr<InMemoryTransport::Endpoint> ep)
+      : endpoint_(ep) {}
+
+  starpc::Error WritePacket(const srpc::Packet& pkt) override {
+    std::string data;
+    if (!pkt.SerializeToString(&data)) {
+      return starpc::Error::InvalidMessage;
+    }
+    InMemoryTransport::Send(endpoint_, data);
+    return starpc::Error::OK;
+  }
+
+  starpc::Error Close() override {
+    InMemoryTransport::Close(endpoint_);
+    return starpc::Error::OK;
+  }
+
+ private:
+  std::shared_ptr<InMemoryTransport::Endpoint> endpoint_;
+};
+
+// EchoServerImpl implements the echo server.
+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 {
+    // Send 5 copies of the message
+    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 {
+    // Receive first message and return it
+    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 {
+    // Echo back all received messages
+    while (true) {
+      echo::EchoMsg msg;
+      starpc::Error 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* strm) override {
+    // Simple echo for RpcStream - not used in tests
+    return starpc::Error::Unimplemented;
+  }
+
+  starpc::Error DoNothing(const google::protobuf::Empty& req, google::protobuf::Empty* resp) override {
+    // Just return OK
+    return starpc::Error::OK;
+  }
+};
+
+// RunServer runs the server-side packet handling loop.
+void RunServer(InMemoryTransport* transport, starpc::Mux* mux) {
+  auto reader = transport->ServerReader();
+  auto writer_ep = transport->ServerToClient();
+  auto writer = std::make_unique<InMemoryPacketWriter>(writer_ep);
+
+  auto server_rpc = starpc::NewServerRPC(mux, writer.get());
+
+  while (true) {
+    std::string data;
+    if (!InMemoryTransport::Recv(reader, &data)) {
+      break;
+    }
+    starpc::Error err = server_rpc->HandlePacketData(data);
+    if (err != starpc::Error::OK && err != starpc::Error::Completed) {
+      std::cerr << "Server error: " << starpc::ErrorString(err) << std::endl;
+      break;
+    }
+  }
+}
+
+// Test unary RPC
+bool TestUnary() {
+  std::cout << "Testing Unary RPC... " << std::flush;
+
+  InMemoryTransport transport;
+
+  // Setup server
+  auto mux = starpc::NewMux();
+  EchoServerImpl server_impl;
+  auto [handler, reg_err] = echo::SRPCRegisterEchoer(mux.get(), &server_impl);
+  if (reg_err != starpc::Error::OK) {
+    std::cerr << "FAILED: Registration error: " << starpc::ErrorString(reg_err) << std::endl;
+    return false;
+  }
+
+  // Start server thread
+  std::thread server_thread([&transport, &mux]() {
+    RunServer(&transport, mux.get());
+  });
+
+  // Setup client
+  auto client_rpc = starpc::NewClientRPC("echo.Echoer", "Echo");
+  auto writer = std::make_unique<InMemoryPacketWriter>(transport.ClientToServer());
+
+  // Start client receive thread
+  auto client_reader = transport.ClientReader();
+  std::thread client_recv_thread([&client_rpc, &client_reader]() {
+    while (true) {
+      std::string data;
+      if (!InMemoryTransport::Recv(client_reader, &data)) {
+        client_rpc->HandleStreamClose(starpc::Error::EOF_);
+        break;
+      }
+      starpc::Error err = client_rpc->HandlePacketData(data);
+      if (err != starpc::Error::OK) {
+        break;
+      }
+    }
+  });
+
+  // Send request
+  echo::EchoMsg req;
+  req.set_body(kTestBody);
+  std::string req_data;
+  req.SerializeToString(&req_data);
+
+  starpc::Error err = client_rpc->Start(writer.get(), true, req_data);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: Start error: " << starpc::ErrorString(err) << std::endl;
+    return false;
+  }
+
+  // Read response
+  std::string resp_data;
+  err = client_rpc->ReadOne(&resp_data);
+  if (err != starpc::Error::OK) {
+    std::cerr << "FAILED: ReadOne error: " << starpc::ErrorString(err) << std::endl;
+    return false;
+  }
+
+  echo::EchoMsg resp;
+  if (!resp.ParseFromString(resp_data)) {
+    std::cerr << "FAILED: Parse response error" << std::endl;
+    return false;
+  }
+
+  if (resp.body() != kTestBody) {
+    std::cerr << "FAILED: Expected '" << kTestBody << "' got '" << resp.body() << "'" << std::endl;
+    return false;
+  }
+
+  // Cleanup
+  client_rpc->Close();
+  writer->Close();
+  InMemoryTransport::Close(transport.ServerReader());
+
+  client_recv_thread.join();
+  server_thread.join();
+
+  std::cout << "PASSED" << std::endl;
+  return true;
+}
+
+}  // namespace
+
+int main() {
+  std::cout << "=== starpc C++ E2E Tests ===" << std::endl;
+
+  int passed = 0;
+  int failed = 0;
+
+  if (TestUnary()) {
+    passed++;
+  } else {
+    failed++;
+  }
+
+  std::cout << std::endl;
+  std::cout << "Results: " << passed << " passed, " << failed << " failed" << std::endl;
+
+  return failed > 0 ? 1 : 0;
+}

package/echo/echo_srpc.pb.cpp

@@ -0,0 +1,113 @@
+//go:build deps_only
+
+// Code generated by protoc-gen-starpc-cpp. DO NOT EDIT.
+// protoc-gen-starpc-cpp version: v0.43.2-0.20260131104303-1de77bff6409+dirty
+// source: github.com/aperturerobotics/starpc/echo/echo.proto
+
+#include "echo_srpc.pb.hpp"
+
+namespace echo {
+
+starpc::Error SRPCEchoerClientImpl::Echo(const echo::EchoMsg& in, echo::EchoMsg* out) {
+  return cc_->ExecCall(service_id_, "Echo", in, out);
+}
+
+std::pair<std::unique_ptr<SRPCEchoer_EchoServerStreamClient>, starpc::Error> SRPCEchoerClientImpl::EchoServerStream(const echo::EchoMsg& in) {
+  auto [strm, err] = cc_->NewStream(service_id_, "EchoServerStream", &in);
+  if (err != starpc::Error::OK) {
+    return {nullptr, err};
+  }
+  err = strm->CloseSend();
+  if (err != starpc::Error::OK) {
+    return {nullptr, err};
+  }
+  return {std::make_unique<SRPCEchoer_EchoServerStreamClient>(std::move(strm)), starpc::Error::OK};
+}
+
+std::pair<std::unique_ptr<SRPCEchoer_EchoClientStreamClient>, starpc::Error> SRPCEchoerClientImpl::EchoClientStream() {
+  auto [strm, err] = cc_->NewStream(service_id_, "EchoClientStream", nullptr);
+  if (err != starpc::Error::OK) {
+    return {nullptr, err};
+  }
+  return {std::make_unique<SRPCEchoer_EchoClientStreamClient>(std::move(strm)), starpc::Error::OK};
+}
+
+std::pair<std::unique_ptr<SRPCEchoer_EchoBidiStreamClient>, starpc::Error> SRPCEchoerClientImpl::EchoBidiStream() {
+  auto [strm, err] = cc_->NewStream(service_id_, "EchoBidiStream", nullptr);
+  if (err != starpc::Error::OK) {
+    return {nullptr, err};
+  }
+  return {std::make_unique<SRPCEchoer_EchoBidiStreamClient>(std::move(strm)), starpc::Error::OK};
+}
+
+std::pair<std::unique_ptr<SRPCEchoer_RpcStreamClient>, starpc::Error> SRPCEchoerClientImpl::RpcStream() {
+  auto [strm, err] = cc_->NewStream(service_id_, "RpcStream", nullptr);
+  if (err != starpc::Error::OK) {
+    return {nullptr, err};
+  }
+  return {std::make_unique<SRPCEchoer_RpcStreamClient>(std::move(strm)), starpc::Error::OK};
+}
+
+starpc::Error SRPCEchoerClientImpl::DoNothing(const google::protobuf::Empty& in, google::protobuf::Empty* out) {
+  return cc_->ExecCall(service_id_, "DoNothing", in, out);
+}
+
+std::vector<std::string> SRPCEchoerHandler::GetMethodIDs() const {
+  return {
+    "Echo",
+    "EchoServerStream",
+    "EchoClientStream",
+    "EchoBidiStream",
+    "RpcStream",
+    "DoNothing",
+  };
+}
+
+std::pair<bool, starpc::Error> SRPCEchoerHandler::InvokeMethod(
+    const std::string& service_id,
+    const std::string& method_id,
+    starpc::Stream* strm) {
+  if (!service_id.empty() && service_id != service_id_) {
+    return {false, starpc::Error::OK};
+  }
+
+  if (method_id == "Echo") {
+    echo::EchoMsg req;
+    starpc::Error err = strm->MsgRecv(&req);
+    if (err != starpc::Error::OK) return {true, err};
+    echo::EchoMsg resp;
+    err = impl_->Echo(req, &resp);
+    if (err != starpc::Error::OK) return {true, err};
+    return {true, strm->MsgSend(resp)};
+  } else if (method_id == "EchoServerStream") {
+    echo::EchoMsg req;
+    starpc::Error err = strm->MsgRecv(&req);
+    if (err != starpc::Error::OK) return {true, err};
+    SRPCEchoer_EchoServerStreamStream serverStrm(strm);
+    return {true, impl_->EchoServerStream(req, &serverStrm)};
+  } else if (method_id == "EchoClientStream") {
+    SRPCEchoer_EchoClientStreamStream clientStrm(strm);
+    echo::EchoMsg resp;
+    starpc::Error err = impl_->EchoClientStream(&clientStrm, &resp);
+    if (err != starpc::Error::OK) return {true, err};
+    return {true, strm->MsgSend(resp)};
+  } else if (method_id == "EchoBidiStream") {
+    SRPCEchoer_EchoBidiStreamStream bidiStrm(strm);
+    return {true, impl_->EchoBidiStream(&bidiStrm)};
+  } else if (method_id == "RpcStream") {
+    SRPCEchoer_RpcStreamStream bidiStrm(strm);
+    return {true, impl_->RpcStream(&bidiStrm)};
+  } else if (method_id == "DoNothing") {
+    google::protobuf::Empty req;
+    starpc::Error err = strm->MsgRecv(&req);
+    if (err != starpc::Error::OK) return {true, err};
+    google::protobuf::Empty resp;
+    err = impl_->DoNothing(req, &resp);
+    if (err != starpc::Error::OK) return {true, err};
+    return {true, strm->MsgSend(resp)};
+  }
+
+  return {false, starpc::Error::OK};
+}
+
+}  // namespace echo