starpc 0.52.1 → 0.52.2

package/srpc/client-rpc.hpp

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <string>
-
 #include "common-rpc.hpp"
 #include "errors.hpp"
 #include "msg-stream.hpp"
 #include "packet.hpp"
 #include "writer.hpp"
 
+#include <string>
+
 namespace srpc {
 class Packet;
 class CallStart;
@@ -15,54 +15,68 @@ class CallStart;
 
 namespace starpc {
 
-// ClientRPC represents the client side of an on-going RPC call message stream.
-// Matches Go ClientRPC struct in client-rpc.go
+/*
+ * ClientRPC is the caller's side of one call. The transport feeds it packets
+ * through HandlePacketData and it writes through the PacketWriter given to
+ * Start.
+ */
 class ClientRPC : public CommonRPC, public MsgStreamRw {
 public:
-  // Constructor matching NewClientRPC in Go
-  ClientRPC(const std::string &service, const std::string &method);
-  ~ClientRPC() override;
+	/* ClientRPC opens a call for service and method. */
+	ClientRPC(const std::string &service, const std::string &method);
+	~ClientRPC() override;
 
-  // Start sets the writer and writes the CallStart message.
-  // Must only be called once!
-  // Matches Go Start method in client-rpc.go
-  Error Start(PacketWriter *writer, bool write_first_msg,
-              const std::string &first_msg);
+	/*
+	 * Start attaches a borrowed writer and writes CallStart once. The
+	 * writer must outlive this call and its callbacks. The caller closes
+	 * a rejected writer.
+	 */
+	Error Start(PacketWriter *writer, bool write_first_msg,
+		    const std::string &first_msg);
 
-  // HandlePacketData handles an incoming unparsed message packet.
-  // Matches Go HandlePacketData in client-rpc.go
-  Error HandlePacketData(const std::string &data);
+	/* HandlePacketData parses one serialized packet and handles it. */
+	Error HandlePacketData(const std::string &data);
 
-  // HandleStreamClose handles the stream closing optionally with an error.
-  // Matches Go HandleStreamClose (overrides CommonRPC)
-  void HandleStreamClose(Error close_err);
+	/* HandleStreamClose records the transport ending with its outcome. */
+	void HandleStreamClose(Error close_err);
 
-  // HandlePacket handles an incoming parsed message packet.
-  // Matches Go HandlePacket in client-rpc.go
-  Error HandlePacket(const srpc::Packet &pkt);
+	/* HandlePacket validates and dispatches one parsed packet. */
+	Error HandlePacket(const srpc::Packet &pkt);
 
-  // HandleCallStart handles the call start packet.
-  // Matches Go HandleCallStart in client-rpc.go
-  Error HandleCallStart(const srpc::CallStart &pkt);
+	/*
+	 * HandleCallStart rejects a CallStart: the caller never receives one.
+	 */
+	Error HandleCallStart(const srpc::CallStart &pkt);
 
-  // Close releases any resources held by the ClientRPC.
-  // Matches Go Close in client-rpc.go
-  void Close();
+	/* Close cancels the call. */
+	void Close();
 
-  // MsgStreamRw interface implementation
-  Error ReadOne(std::string *out) override { return CommonRPC::ReadOne(out); }
-  Error WriteCallData(const std::string &data, bool data_is_zero, bool complete,
-                      Error err) override {
-    return CommonRPC::WriteCallData(data, data_is_zero, complete, err);
-  }
-  Error WriteCallCancel() override { return CommonRPC::WriteCallCancel(); }
+	/* MsgStreamRw over the shared call state. */
+	Error ReadOne(std::string *out) override
+	{
+		return CommonRPC::ReadOne(out);
+	}
+	Error WriteCallData(const std::string &data, bool data_is_zero,
+			    bool complete, Error err) override
+	{
+		return CommonRPC::WriteCallData(data, data_is_zero, complete,
+						err);
+	}
+	Error WriteCallCancel() override
+	{
+		return CommonRPC::WriteCallCancel();
+	}
+	std::string RemoteErrorMessage() const override
+	{
+		return CommonRPC::RemoteErrorMessage();
+	}
 };
 
-// NewClientRPC constructs a new ClientRPC session.
-// Matches Go NewClientRPC function in client-rpc.go
+/* NewClientRPC constructs a ClientRPC for service and method. */
 inline std::unique_ptr<ClientRPC> NewClientRPC(const std::string &service,
-                                               const std::string &method) {
-  return std::make_unique<ClientRPC>(service, method);
+					       const std::string &method)
+{
+	return std::make_unique<ClientRPC>(service, method);
 }
 
 } // namespace starpc

package/srpc/client-rpc.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+
+import { ClientRPC } from './client-rpc.js'
+import { isClosedBeforeCompletionError } from './errors.js'
+import { Packet } from './rpcproto.pb.js'
+
+describe('ClientRPC', () => {
+  it('fails a call whose transport ends before the remote completes it', async () => {
+    const call = new ClientRPC('svc', 'method')
+    await call.sink(packetSource(callDataPacket(new Uint8Array([1]))))
+
+    const received = new Array<number>()
+    const read = async () => {
+      for await (const data of call.rpcDataSource) {
+        received.push(data[0])
+      }
+    }
+    const err = await read().then(
+      () => undefined,
+      (err: unknown) => err,
+    )
+
+    expect(received).toEqual([1])
+    expect(isClosedBeforeCompletionError(err)).toBe(true)
+    expect(isClosedBeforeCompletionError(call.isClosed)).toBe(true)
+  })
+
+  it('ends a call cleanly when the remote completes it before the transport ends', async () => {
+    const call = new ClientRPC('svc', 'method')
+    await call.sink(
+      packetSource(
+        callDataPacket(new Uint8Array([1])),
+        callDataPacket(undefined, true),
+      ),
+    )
+
+    const received = new Array<number>()
+    for await (const data of call.rpcDataSource) {
+      received.push(data[0])
+    }
+
+    expect(received).toEqual([1])
+    expect(call.isClosed).toBe(false)
+  })
+})
+
+// callDataPacket builds an incoming call-data packet.
+function callDataPacket(data?: Uint8Array, complete = false): Packet {
+  return Packet.create({
+    body: {
+      case: 'callData',
+      value: {
+        data: data ?? new Uint8Array(0),
+        dataIsZero: false,
+        complete,
+        error: '',
+      },
+    },
+  })
+}
+
+// packetSource yields packets and then ends like a closed transport.
+async function* packetSource(...packets: Packet[]): AsyncGenerator<Packet> {
+  for (const packet of packets) {
+    yield packet
+  }
+}

package/srpc/client-rpc.ts

@@ -1,6 +1,7 @@
 import type { CompleteMessage } from '@aptre/protobuf-es-lite'
 import type { CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
+import { ERR_CLOSED_BEFORE_COMPLETION } from './errors.js'
 
 // ClientRPC is an ongoing RPC from the client side.
 export class ClientRPC extends CommonRPC {
@@ -37,4 +38,13 @@ export class ClientRPC extends CommonRPC {
       `unexpected server to client rpc: ${packet.rpcService || '<empty>'}/${packet.rpcMethod || '<empty>'}`,
     )
   }
+
+  // handleSourceEnd fails the call when the transport ends before the remote
+  // sent a completion or an error, so a truncated stream does not read as a
+  // complete one.
+  protected override async handleSourceEnd() {
+    if (!this.isRemoteCompleted) {
+      await this.close(new Error(ERR_CLOSED_BEFORE_COMPLETION))
+    }
+  }
 }

package/srpc/client-rpc_test.go

@@ -0,0 +1,76 @@
+package srpc
+
+import (
+	"context"
+	"io"
+	"testing"
+)
+
+// callbackPacketWriter exercises synchronous transport callbacks.
+type callbackPacketWriter struct {
+	// write delivers the outgoing packet before returning.
+	write func(*Packet) error
+	// close interrupts pending writes.
+	close func() error
+}
+
+// WritePacket invokes the test's synchronous transport.
+func (w *callbackPacketWriter) WritePacket(packet *Packet) error { return w.write(packet) }
+
+// Close interrupts the test transport.
+func (w *callbackPacketWriter) Close() error { return w.close() }
+
+func TestClientRPCSynchronousTransport(t *testing.T) {
+	// A transport may deliver its reply before the request write returns.
+	rpc := NewClientRPC(t.Context(), "service", "method")
+	writer := &callbackPacketWriter{
+		write: func(packet *Packet) error {
+			return rpc.HandleCallData(&CallData{Data: []byte("reply"), Complete: true})
+		},
+		close: func() error {
+			rpc.HandleStreamClose(io.EOF)
+			return nil
+		},
+	}
+	if err := rpc.Start(writer, false, nil); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(rpc.Close)
+
+	// Both startup and cleanup callbacks must run outside the state lock.
+	data, err := rpc.ReadOne()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(data) != "reply" {
+		t.Fatalf("unexpected response %q", data)
+	}
+}
+
+func TestClientRPCCancelBlockedStart(t *testing.T) {
+	// Cancel while CallStart is blocked on a peer that never reads.
+	ctx, cancel := context.WithCancel(t.Context())
+	t.Cleanup(cancel)
+	rpc := NewClientRPC(ctx, "service", "method")
+	entered, closed := make(chan struct{}), make(chan struct{})
+	writer := &callbackPacketWriter{
+		write: func(*Packet) error {
+			close(entered)
+			<-closed
+			return io.ErrClosedPipe
+		},
+		close: func() error {
+			close(closed)
+			return nil
+		},
+	}
+	done := make(chan error, 1)
+	go func() { done <- rpc.Start(writer, false, nil) }()
+	<-entered
+	cancel()
+	if err := <-done; err != io.ErrClosedPipe {
+		t.Fatalf("blocked start returned %v", err)
+	}
+}
+
+var _ PacketWriter = (*callbackPacketWriter)(nil)

package/srpc/client.cpp

@@ -3,99 +3,111 @@
 #include "client.hpp"
 
 namespace starpc {
+namespace {
+
+/*
+ * ClientStream is the Stream over one opened call. The transport and the
+ * stream share the ClientRPC; destroying the writer joins the transport's
+ * readers, so the call outlives every callback.
+ */
+class ClientStream final : public Stream {
+public:
+	ClientStream(std::shared_ptr<ClientRPC> rpc,
+		     std::unique_ptr<PacketWriter> writer)
+		: rpc(std::move(rpc)),
+		  writer(std::move(writer)),
+		  messages(
+			  this->rpc.get(), [this] { this->rpc->Close(); },
+			  this->rpc->StopToken())
+	{
+	}
+	~ClientStream() override
+	{
+		Close();
+	}
+
+	Error MsgSend(const Message &message) override
+	{
+		return messages.MsgSend(message);
+	}
+	Error MsgRecv(Message *message) override
+	{
+		return messages.MsgRecv(message);
+	}
+	Error CloseSend() override
+	{
+		return messages.CloseSend();
+	}
+	std::stop_token StopToken() const override
+	{
+		return rpc->StopToken();
+	}
+	std::string RemoteErrorMessage() const override
+	{
+		return rpc->RemoteErrorMessage();
+	}
+	Error Close() override
+	{
+		rpc->Close();
+		return Error::OK;
+	}
+
+private:
+	/* rpc is shared with the transport callbacks. */
+	std::shared_ptr<ClientRPC> rpc;
+	std::unique_ptr<PacketWriter> writer;
+	MsgStream messages;
+};
+
+} // namespace
 
 Error ClientImpl::ExecCall(const std::string &service,
-                           const std::string &method, const Message &in,
-                           Message *out) {
-  std::string first_msg;
-  if (!in.SerializeToString(&first_msg)) {
-    return Error::InvalidMessage;
-  }
-
-  auto client_rpc = NewClientRPC(service, method);
-
-  // Open the stream with handlers
-  auto [writer, err] = open_stream_(
-      [&client_rpc](const std::string &data) -> Error {
-        return client_rpc->HandlePacketData(data);
-      },
-      [&client_rpc](Error close_err) {
-        client_rpc->HandleStreamClose(close_err);
-      });
-
-  if (err != Error::OK) {
-    return err;
-  }
-
-  err = client_rpc->Start(writer.get(), true, first_msg);
-  if (err != Error::OK) {
-    client_rpc->Close();
-    return err;
-  }
-
-  std::string msg;
-  err = client_rpc->ReadOne(&msg);
-  if (err != Error::OK) {
-    client_rpc->Close();
-    return err;
-  }
-
-  if (!out->ParseFromString(msg)) {
-    client_rpc->Close();
-    return Error::InvalidMessage;
-  }
-
-  client_rpc->Close();
-  return Error::OK;
+			   const std::string &method, const Message &in,
+			   Message *out)
+{
+	auto [stream, err] = NewStream(service, method, &in);
+	if (err != Error::OK)
+		return err;
+	return stream->MsgRecv(out);
 }
 
 std::pair<std::unique_ptr<Stream>, Error>
 ClientImpl::NewStream(const std::string &service, const std::string &method,
-                      const Message *first_msg) {
-  std::string first_msg_data;
-  if (first_msg != nullptr) {
-    if (!first_msg->SerializeToString(&first_msg_data)) {
-      return {nullptr, Error::InvalidMessage};
-    }
-  }
-
-  auto client_rpc = std::make_shared<ClientRPC>(service, method);
-
-  // Open the stream with handlers
-  auto [writer, err] = open_stream_(
-      [client_rpc](const std::string &data) -> Error {
-        return client_rpc->HandlePacketData(data);
-      },
-      [client_rpc](Error close_err) {
-        client_rpc->HandleStreamClose(close_err);
-      });
-
-  if (err != Error::OK) {
-    return {nullptr, err};
-  }
-
-  err = client_rpc->Start(writer.get(), first_msg != nullptr, first_msg_data);
-  if (err != Error::OK) {
-    return {nullptr, err};
-  }
-
-  // Create MsgStream with close callback
-  // Note: We need to capture writer to extend its lifetime
-  auto writer_ptr = writer.release();
-  auto stream =
-      std::make_unique<MsgStream>(client_rpc.get(), [client_rpc, writer_ptr]() {
-        client_rpc->Cancel();
-        if (writer_ptr) {
-          writer_ptr->Close();
-          delete writer_ptr;
-        }
-      });
-
-  // We need to keep client_rpc alive - in a real implementation
-  // we'd use a mechanism to tie its lifetime to the stream.
-  // For now, the shared_ptr in the lambda captures keeps it alive.
-
-  return {std::move(stream), Error::OK};
+		      const Message *first_msg)
+{
+	if (service.empty())
+		return {nullptr, Error::EmptyServiceID};
+	if (method.empty())
+		return {nullptr, Error::EmptyMethodID};
+
+	std::string first_data;
+	if (first_msg != nullptr && !first_msg->SerializeToString(&first_data))
+		return {nullptr, Error::InvalidMessage};
+
+	/*
+	 * Transport callbacks share the call, without referring to this stack
+	 * frame.
+	 */
+	auto rpc = std::make_shared<ClientRPC>(service, method);
+	auto [writer, err] = open_stream(
+		[rpc](const std::string &data) {
+			return rpc->HandlePacketData(data);
+		},
+		[rpc](Error closed) { rpc->HandleStreamClose(closed); });
+	if (err != Error::OK) {
+		if (writer)
+			(void)writer->Close();
+		return {nullptr, err};
+	}
+
+	err = rpc->Start(writer.get(), first_msg != nullptr, first_data);
+	if (err != Error::OK) {
+		rpc->Close();
+		return {nullptr, err};
+	}
+	return {std::make_unique<ClientStream>(std::move(rpc),
+					       std::move(writer)),
+		Error::OK};
 }
 
 } // namespace starpc

package/srpc/client.hpp

@@ -1,10 +1,5 @@
 #pragma once
 
-#include <functional>
-#include <memory>
-#include <string>
-#include <utility>
-
 #include "client-rpc.hpp"
 #include "errors.hpp"
 #include "message.hpp"
@@ -13,54 +8,70 @@
 #include "stream.hpp"
 #include "writer.hpp"
 
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+
 namespace starpc {
 
-// OpenStreamFunc opens a stream with a remote.
-// msgHandler must not be called concurrently.
-// Matches Go OpenStreamFunc in client.go
+/*
+ * OpenStreamFunc opens one stream over the transport. It returns the writer
+ * the caller writes packets through; msg_handler and close_handler must not
+ * be called concurrently. Matches Go OpenStreamFunc in client.go.
+ */
 using OpenStreamFunc =
-    std::function<std::pair<std::unique_ptr<PacketWriter>, Error>(
-        PacketDataHandler msg_handler, CloseHandler close_handler)>;
+	std::function<std::pair<std::unique_ptr<PacketWriter>, Error>(
+		PacketDataHandler msg_handler, CloseHandler close_handler)>;
 
-// Client implements a SRPC client which can initiate RPC streams.
-// Matches Go Client interface in client.go
+/*
+ * Client starts RPC streams over a transport. Matches the Go Client
+ * interface in client.go.
+ */
 class Client {
 public:
-  virtual ~Client() = default;
+	virtual ~Client() = default;
 
-  // ExecCall executes a request/reply RPC with the remote.
-  virtual Error ExecCall(const std::string &service, const std::string &method,
-                         const Message &in, Message *out) = 0;
+	/* ExecCall runs one request/reply RPC and parses the reply into out. */
+	virtual Error ExecCall(const std::string &service,
+			       const std::string &method, const Message &in,
+			       Message *out) = 0;
 
-  // NewStream starts a streaming RPC with the remote & returns the stream.
-  // firstMsg is optional (can be nullptr).
-  virtual std::pair<std::unique_ptr<Stream>, Error>
-  NewStream(const std::string &service, const std::string &method,
-            const Message *first_msg) = 0;
+	/*
+	 * NewStream opens a streaming RPC and returns the stream. first_msg,
+	 * when set, is sent as the call's first message.
+	 */
+	virtual std::pair<std::unique_ptr<Stream>, Error>
+	NewStream(const std::string &service, const std::string &method,
+		  const Message *first_msg) = 0;
 };
 
-// ClientImpl is the default implementation of Client with a transport.
-// Matches Go client struct in client.go
+/*
+ * ClientImpl is the default Client over an OpenStreamFunc transport. Matches
+ * the Go client struct in client.go.
+ */
 class ClientImpl : public Client {
 public:
-  explicit ClientImpl(OpenStreamFunc open_stream)
-      : open_stream_(std::move(open_stream)) {}
+	explicit ClientImpl(OpenStreamFunc open_stream)
+		: open_stream(std::move(open_stream))
+	{
+	}
 
-  Error ExecCall(const std::string &service, const std::string &method,
-                 const Message &in, Message *out) override;
+	Error ExecCall(const std::string &service, const std::string &method,
+		       const Message &in, Message *out) override;
 
-  std::pair<std::unique_ptr<Stream>, Error>
-  NewStream(const std::string &service, const std::string &method,
-            const Message *first_msg) override;
+	std::pair<std::unique_ptr<Stream>, Error>
+	NewStream(const std::string &service, const std::string &method,
+		  const Message *first_msg) override;
 
 private:
-  OpenStreamFunc open_stream_;
+	OpenStreamFunc open_stream;
 };
 
-// NewClient constructs a client with a OpenStreamFunc.
-// Matches Go NewClient function in client.go
-inline std::unique_ptr<Client> NewClient(OpenStreamFunc open_stream) {
-  return std::make_unique<ClientImpl>(std::move(open_stream));
+/* NewClient constructs a Client over open_stream. */
+inline std::unique_ptr<Client> NewClient(OpenStreamFunc open_stream)
+{
+	return std::make_unique<ClientImpl>(std::move(open_stream));
 }
 
 } // namespace starpc