starpc 0.52.1 → 0.52.2

package/srpc/client-half-close_test.go

@@ -0,0 +1,152 @@
+package srpc_test
+
+import (
+	"context"
+	"io"
+	"net"
+	"testing"
+
+	"github.com/aperturerobotics/starpc/echo"
+	"github.com/aperturerobotics/starpc/srpc"
+	"github.com/pkg/errors"
+)
+
+// endedClient returns each new stream only after its transport has closed, so
+// the generated caller half-closes after the remote already ended the call.
+type endedClient struct {
+	srpc.Client
+	// closed is closed after the transport close callback of the one stream
+	// this client may open returns.
+	closed <-chan struct{}
+}
+
+// NewStream opens the stream and waits for its transport to close.
+func (c *endedClient) NewStream(
+	ctx context.Context,
+	service, method string,
+	firstMsg srpc.Message,
+) (srpc.Stream, error) {
+	strm, err := c.Client.NewStream(ctx, service, method, firstMsg)
+	if err != nil {
+		return nil, err
+	}
+	<-c.closed
+	return strm, nil
+}
+
+// onceEchoServer answers a server stream with one message and returns.
+type onceEchoServer struct {
+	*echo.EchoServer
+}
+
+// EchoServerStream sends the request back once and completes the call.
+func (onceEchoServer) EchoServerStream(msg *echo.EchoMsg, strm echo.SRPCEchoer_EchoServerStreamStream) error {
+	return strm.Send(msg)
+}
+
+// newEchoPipe serves impl over an in-memory pipe per stream.
+func newEchoPipe(t *testing.T, impl echo.SRPCEchoerServer) srpc.OpenStreamFunc {
+	t.Helper()
+	mux := srpc.NewMux()
+	if err := echo.SRPCRegisterEchoer(mux, impl); err != nil {
+		t.Fatal(err)
+	}
+	return srpc.NewServerPipe(srpc.NewServer(mux))
+}
+
+// notifyClose wraps openStream for a single stream and returns a channel
+// closed after that stream's transport close callback returns.
+func notifyClose(openStream srpc.OpenStreamFunc) (srpc.OpenStreamFunc, <-chan struct{}) {
+	closed := make(chan struct{})
+	return func(
+		ctx context.Context,
+		msgHandler srpc.PacketDataHandler,
+		closeHandler srpc.CloseHandler,
+	) (srpc.PacketWriter, error) {
+		return openStream(ctx, msgHandler, func(closeErr error) {
+			closeHandler(closeErr)
+			close(closed)
+		})
+	}, closed
+}
+
+func TestServerStreamCompletedBeforeCloseSend(t *testing.T) {
+	// Complete the server stream before the generated caller half-closes.
+	openStream, closed := notifyClose(newEchoPipe(t, onceEchoServer{echo.NewEchoServer(nil)}))
+	client := echo.NewSRPCEchoerClient(&endedClient{Client: srpc.NewClient(openStream), closed: closed})
+	strm, err := client.EchoServerStream(t.Context(), &echo.EchoMsg{Body: bodyTxt})
+	if err != nil {
+		t.Fatalf("server stream discarded after remote completion: %v", err)
+	}
+	t.Cleanup(func() { _ = strm.Close() })
+
+	// Read the buffered response, then the clean completion.
+	msg, err := strm.Recv()
+	if err != nil {
+		t.Fatalf("buffered response lost: %v", err)
+	}
+	if msg.GetBody() != bodyTxt {
+		t.Fatalf("expected %q got %q", bodyTxt, msg.GetBody())
+	}
+	if _, err := strm.Recv(); err != io.EOF {
+		t.Fatalf("expected io.EOF after completion, got %v", err)
+	}
+}
+
+func TestClientStreamCompletedBeforeCloseSend(t *testing.T) {
+	// EchoClientStream replies to the first message without waiting for the
+	// half-close, so the call ends while the client may still send.
+	openStream, closed := notifyClose(newEchoPipe(t, echo.NewEchoServer(nil)))
+	client := echo.NewSRPCEchoerClient(srpc.NewClient(openStream))
+	strm, err := client.EchoClientStream(t.Context())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = strm.Close() })
+
+	// Send the one request and wait for the call to end.
+	if err := strm.Send(&echo.EchoMsg{Body: bodyTxt}); err != nil {
+		t.Fatal(err)
+	}
+	<-closed
+
+	// The half-close fails, but the reply is still readable.
+	msg, err := strm.CloseAndRecv()
+	if err != nil {
+		t.Fatalf("buffered reply lost: %v", err)
+	}
+	if msg.GetBody() != bodyTxt {
+		t.Fatalf("expected %q got %q", bodyTxt, msg.GetBody())
+	}
+}
+
+func TestServerStreamTransportFailureBeforeCloseSend(t *testing.T) {
+	// Accept CallStart, then drop the transport without a response.
+	openStream, closed := notifyClose(func(
+		ctx context.Context,
+		msgHandler srpc.PacketDataHandler,
+		closeHandler srpc.CloseHandler,
+	) (srpc.PacketWriter, error) {
+		srvPipe, clientPipe := net.Pipe()
+		srvPrw := srpc.NewPacketReadWriter(srvPipe)
+		go func() {
+			_ = srvPrw.ReadToHandler(func([]byte) error {
+				return srvPrw.Close()
+			})
+		}()
+		clientPrw := srpc.NewPacketReadWriter(clientPipe)
+		go clientPrw.ReadPump(msgHandler, closeHandler)
+		return clientPrw, nil
+	})
+	client := echo.NewSRPCEchoerClient(&endedClient{Client: srpc.NewClient(openStream), closed: closed})
+	strm, err := client.EchoServerStream(t.Context(), &echo.EchoMsg{Body: bodyTxt})
+	if err != nil {
+		t.Fatalf("server stream discarded after transport failure: %v", err)
+	}
+	t.Cleanup(func() { _ = strm.Close() })
+
+	// Recv reports that the call ended without a verdict.
+	if _, err := strm.Recv(); !errors.Is(err, srpc.ErrClosedBeforeCompletion) {
+		t.Fatalf("expected ErrClosedBeforeCompletion, got %v", err)
+	}
+}

package/srpc/client-invoker.go

@@ -17,65 +17,55 @@ func NewClientInvoker(client Client) *ClientInvoker {
 }
 
 // InvokeMethod invokes the method by proxying to the remote via the client.
-// Returns false, nil if the client is nil.
+// The remote's terminal result, including its error, is the result of the
+// call. Returns false, nil if the client is nil.
 func (c *ClientInvoker) InvokeMethod(serviceID, methodID string, strm Stream) (bool, error) {
 	if c.client == nil {
 		return false, nil
 	}
 
-	ctx := strm.Context()
-
-	// Open a stream to the remote
-	remoteStrm, err := c.client.NewStream(ctx, serviceID, methodID, nil)
+	// Open a stream to the remote.
+	remoteStrm, err := c.client.NewStream(strm.Context(), serviceID, methodID, nil)
 	if err != nil {
 		return true, err
 	}
 	defer remoteStrm.Close()
 
-	// Proxy data between the streams
-	errCh := make(chan error, 2)
-	go proxyStreamTo(strm, remoteStrm, errCh)
-	go proxyStreamTo(remoteStrm, strm, errCh)
+	// Forward the caller's messages until it half-closes or fails.
+	go forwardRequests(strm, remoteStrm)
 
-	// Wait for both directions to complete
-	var outErr error
-	for range 2 {
-		if err := <-errCh; err != nil && outErr == nil && err != io.EOF {
-			outErr = err
-		}
+	// Forward the remote's messages; the server publishes the result to the
+	// caller after this returns.
+	return true, forwardMessages(remoteStrm, strm)
+}
+
+// forwardRequests copies the caller's messages to the remote, then
+// half-closes the remote, or closes it when the caller fails.
+func forwardRequests(caller, remote Stream) {
+	if err := forwardMessages(caller, remote); err != nil {
+		_ = remote.Close()
+		return
 	}
-	return true, outErr
+	_ = remote.CloseSend()
 }
 
-// proxyStreamTo copies messages from src to dst.
-func proxyStreamTo(src, dst Stream, errCh chan error) {
-	rerr := func() error {
-		pkt := NewRawMessage(nil, true)
-		for {
-			err := src.MsgRecv(pkt)
-			if err != nil {
-				return err
-			}
-			// Forward all messages including empty ones (valid for empty proto messages)
-			err = dst.MsgSend(pkt)
-			pkt.Clear()
-			if err != nil {
-				return err
+// forwardMessages copies messages from src to dst until src ends. It returns
+// nil when src half-closes.
+func forwardMessages(src, dst Stream) error {
+	// Forward all messages including empty ones, which are valid empty protos.
+	pkt := NewRawMessage(nil, true)
+	for {
+		if err := src.MsgRecv(pkt); err != nil {
+			if err == io.EOF {
+				return nil
 			}
+			return err
 		}
-	}()
-
-	if rerr != nil && rerr != io.EOF {
-		if errCh != nil {
-			errCh <- rerr
+		err := dst.MsgSend(pkt)
+		pkt.Clear()
+		if err != nil {
+			return err
 		}
-		_ = dst.Close()
-		return
-	}
-
-	rerr = dst.CloseSend()
-	if errCh != nil {
-		errCh <- rerr
 	}
 }
 

package/srpc/client-invoker_test.go

@@ -0,0 +1,53 @@
+package srpc_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/aperturerobotics/starpc/echo"
+	"github.com/aperturerobotics/starpc/srpc"
+	"github.com/pkg/errors"
+)
+
+// failingEchoServer fails every unary echo.
+type failingEchoServer struct {
+	*echo.EchoServer
+}
+
+// Echo returns errEchoFailed.
+func (failingEchoServer) Echo(context.Context, *echo.EchoMsg) (*echo.EchoMsg, error) {
+	return nil, errEchoFailed
+}
+
+// errEchoFailed is the error failingEchoServer returns.
+var errEchoFailed = errors.New("echo failed")
+
+// TestClientInvokerForwardsResult checks that a proxied call reports the
+// remote's reply and the remote handler's error.
+func TestClientInvokerForwardsResult(t *testing.T) {
+	ctx := t.Context()
+	proxy := func(server echo.SRPCEchoerServer) echo.SRPCEchoerClient {
+		mux := srpc.NewMux()
+		if err := echo.SRPCRegisterEchoer(mux, server); err != nil {
+			t.Fatal(err)
+		}
+		remote := srpc.NewClient(srpc.NewServerPipe(srpc.NewServer(mux)))
+		invoker := srpc.NewClientInvoker(remote)
+		return echo.NewSRPCEchoerClient(srpc.NewClient(srpc.NewServerPipe(srpc.NewServer(invoker))))
+	}
+
+	// A reply passes through unchanged.
+	reply, err := proxy(echo.NewEchoServer(nil)).Echo(ctx, &echo.EchoMsg{Body: "hello"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if reply.GetBody() != "hello" {
+		t.Errorf("reply body = %q", reply.GetBody())
+	}
+
+	// A handler error reaches the caller instead of a cancellation.
+	_, err = proxy(failingEchoServer{}).Echo(ctx, &echo.EchoMsg{Body: "hello"})
+	if err == nil || err.Error() != errEchoFailed.Error() {
+		t.Errorf("proxied error = %v, want %v", err, errEchoFailed)
+	}
+}

package/srpc/client-rpc.cpp

@@ -6,101 +6,86 @@
 
 namespace starpc {
 
-ClientRPC::ClientRPC(const std::string &service, const std::string &method) {
-  Init();
-  service_ = service;
-  method_ = method;
+ClientRPC::ClientRPC(const std::string &service, const std::string &method)
+{
+	this->service = service;
+	this->method = method;
 }
 
 ClientRPC::~ClientRPC() = default;
 
 Error ClientRPC::Start(PacketWriter *writer, bool write_first_msg,
-                       const std::string &first_msg) {
-  if (writer == nullptr) {
-    return Error::NilWriter;
-  }
-
-  if (IsCanceled()) {
-    Cancel();
-    writer->Close();
-    return Error::Canceled;
-  }
-
-  bool first_msg_empty = false;
-  Error err = Error::OK;
-
-  {
-    std::lock_guard<std::mutex> lock(mtx_);
-    writer_ = writer;
-
-    if (write_first_msg) {
-      first_msg_empty = first_msg.empty();
-    }
-
-    auto pkt =
-        NewCallStartPacket(service_, method_, first_msg, first_msg_empty);
-    err = writer->WritePacket(*pkt);
-    if (err != Error::OK) {
-      Cancel();
-      writer->Close();
-    }
-  }
-
-  cv_.notify_all();
-  return err;
+		       const std::string &first_msg)
+{
+	if (writer == nullptr)
+		return Error::NilWriter;
+	if (service.empty())
+		return Error::EmptyServiceID;
+	if (method.empty())
+		return Error::EmptyMethodID;
+
+	std::unique_lock writing(write_mutex);
+	{
+		std::lock_guard lock(state_mutex);
+		if (this->writer != nullptr)
+			return Error::Completed;
+		this->writer = writer;
+		if (canceled || data_closed) {
+			writing.unlock();
+			/* The caller closes a rejected writer. */
+			return Error::Canceled;
+		}
+	}
+
+	const auto packet = NewCallStartPacket(
+		service, method, write_first_msg ? first_msg : "",
+		write_first_msg && first_msg.empty());
+	const auto written = writer->WritePacket(*packet);
+	writing.unlock();
+	if (written != Error::OK)
+		HandleStreamClose(written);
+	return written;
 }
 
-Error ClientRPC::HandlePacketData(const std::string &data) {
-  srpc::Packet pkt;
-  if (!pkt.ParseFromString(data)) {
-    return Error::InvalidMessage;
-  }
-  return HandlePacket(pkt);
+Error ClientRPC::HandlePacketData(const std::string &data)
+{
+	srpc::Packet packet;
+	if (!packet.ParseFromString(data))
+		return Error::InvalidMessage;
+	return HandlePacket(packet);
 }
 
-void ClientRPC::HandleStreamClose(Error close_err) {
-  std::lock_guard<std::mutex> lock(mtx_);
-  if (close_err != Error::OK && remote_err_ == Error::OK) {
-    remote_err_ = close_err;
-  }
-  data_closed_ = true;
-  Cancel();
-  cv_.notify_all();
+void ClientRPC::HandleStreamClose(Error close_err)
+{
+	CommonRPC::HandleStreamClose(close_err);
 }
 
-Error ClientRPC::HandlePacket(const srpc::Packet &msg) {
-  Error err = ValidatePacket(msg);
-  if (err != Error::OK) {
-    return err;
-  }
-
-  switch (msg.body_case()) {
-  case srpc::Packet::kCallStart:
-    return HandleCallStart(msg.call_start());
-  case srpc::Packet::kCallData:
-    return HandleCallData(msg.call_data());
-  case srpc::Packet::kCallCancel:
-    if (msg.call_cancel()) {
-      return HandleCallCancel();
-    }
-    return Error::OK;
-  default:
-    return Error::OK;
-  }
+Error ClientRPC::HandlePacket(const srpc::Packet &packet)
+{
+	const auto err = ValidatePacket(packet);
+	if (err != Error::OK)
+		return err;
+
+	switch (packet.body_case()) {
+	case srpc::Packet::kCallStart:
+		return Error::UnrecognizedPacket;
+	case srpc::Packet::kCallData:
+		return HandleCallData(packet.call_data());
+	case srpc::Packet::kCallCancel:
+		return packet.call_cancel() ? HandleCallCancel() : Error::OK;
+	default:
+		return Error::UnrecognizedPacket;
+	}
 }
 
-Error ClientRPC::HandleCallStart(const srpc::CallStart &pkt) {
-  // server-to-client calls not supported
-  return Error::UnrecognizedPacket;
+Error ClientRPC::HandleCallStart(const srpc::CallStart &)
+{
+	return Error::UnrecognizedPacket;
 }
 
-void ClientRPC::Close() {
-  std::lock_guard<std::mutex> lock(mtx_);
-  // call did not start yet if writer is nil.
-  if (writer_ != nullptr) {
-    WriteCallCancelLocked();
-    CloseLocked();
-  }
+void ClientRPC::Close()
+{
+	Cancel();
 }
 
 } // namespace starpc

package/srpc/client-rpc.go

@@ -11,10 +11,8 @@ type ClientRPC struct {
 	commonRPC
 }
 
-// NewClientRPC constructs a new ClientRPC session and writes CallStart.
-// the writer will be closed when the ClientRPC completes.
-// service and method must be specified.
-// must call Start after creating the RPC object.
+// NewClientRPC constructs a call with the given service and method.
+// Start attaches its transport; Close releases it.
 func NewClientRPC(ctx context.Context, service, method string) *ClientRPC {
 	rpc := &ClientRPC{}
 	initCommonRPC(ctx, &rpc.commonRPC)
@@ -23,39 +21,42 @@ func NewClientRPC(ctx context.Context, service, method string) *ClientRPC {
 	return rpc
 }
 
-// Start sets the writer and writes the MsgSend message.
-// must only be called once!
+// Start attaches one writer and sends CallStart without holding the state lock.
 func (r *ClientRPC) Start(writer PacketWriter, writeFirstMsg bool, firstMsg []byte) error {
+	// Validate the call before transferring the transport to it.
 	if writer == nil {
 		return ErrNilWriter
 	}
-
-	if err := r.ctx.Err(); err != nil {
-		r.cancelContext()
-		_ = writer.Close()
-		return context.Canceled
+	if !writeFirstMsg {
+		firstMsg = nil
 	}
-
-	var firstMsgEmpty bool
-	var err error
-	locked := r.bcast.Lock()
-	r.writer = writer
-
-	if writeFirstMsg {
-		firstMsgEmpty = len(firstMsg) == 0
+	pkt := NewCallStartPacket(r.service, r.method, firstMsg, writeFirstMsg && len(firstMsg) == 0)
+	if err := pkt.Validate(); err != nil {
+		return err
 	}
 
-	pkt := NewCallStartPacket(r.service, r.method, firstMsg, firstMsgEmpty)
-	err = writer.WritePacket(pkt)
-	if err != nil {
-		r.cancelContext()
-		_ = writer.Close()
+	// Publish the writer before transport callbacks can deliver a response.
+	locked := r.bcast.Lock()
+	if r.writer != nil {
+		locked.Unlock()
+		return ErrCompleted
 	}
-
+	r.writer = writer
 	locked.Broadcast()
 	locked.Unlock()
 
-	return err
+	// Cancellation closes the transport even when its first write is blocked.
+	stop := context.AfterFunc(r.ctx, r.Close)
+	defer stop()
+	if err := r.ctx.Err(); err != nil {
+		r.Close()
+		return err
+	}
+	if err := writer.WritePacket(pkt); err != nil {
+		r.Close()
+		return err
+	}
+	return nil
 }
 
 // HandlePacketData handles an incoming unparsed message packet.
@@ -95,20 +96,18 @@ func (r *ClientRPC) HandlePacket(msg *Packet) error {
 
 // HandleCallStart handles the call start packet.
 func (r *ClientRPC) HandleCallStart(pkt *CallStart) error {
-	// server-to-client calls not supported
 	return errors.Wrap(ErrUnrecognizedPacket, "call start packet unexpected")
 }
 
 // Close releases any resources held by the ClientRPC.
 func (r *ClientRPC) Close() {
+	// Settle the call before releasing a transport that can call back into it.
 	locked := r.bcast.Lock()
-	var writer PacketWriter
-	// call did not start yet if writer is nil.
-	if r.writer != nil {
-		_ = r.WriteCallCancel()
-		writer = r.closeLocked(&locked)
-	}
+	writer := r.closeLocked(&locked)
 	locked.Unlock()
+
+	// Closing the transport interrupts pending writes; sending cancellation first
+	// could itself block forever behind a peer that stopped reading.
 	if writer != nil {
 		_ = writer.Close()
 	}