starpc 0.52.1 → 0.52.2

package/echo/echo_srpc.pb.cpp

@@ -1,7 +1,7 @@
 //go:build deps_only
 
 // Code generated by protoc-gen-starpc-cpp. DO NOT EDIT.
-// protoc-gen-starpc-cpp version: v0.49.21
+// protoc-gen-starpc-cpp version: v0.52.2-0.20260927183858-4d0f9be5aa9d+dirty
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 #include "echo_srpc.pb.hpp"
@@ -17,10 +17,8 @@ std::pair<std::unique_ptr<SRPCEchoer_EchoServerStreamClient>, starpc::Error> SRP
   if (err != starpc::Error::OK) {
     return {nullptr, err};
   }
-  err = strm->CloseSend();
-  if (err != starpc::Error::OK) {
-    return {nullptr, err};
-  }
+  // A failed half-close means the call ended; MsgRecv reports its outcome.
+  (void)strm->CloseSend();
   return {std::make_unique<SRPCEchoer_EchoServerStreamClient>(std::move(strm)), starpc::Error::OK};
 }
 

package/echo/echo_srpc.pb.go

@@ -63,9 +63,8 @@ func (c *srpcEchoerClient) EchoServerStream(ctx context.Context, in *EchoMsg) (S
 		return nil, err
 	}
 	strm := &srpcEchoer_EchoServerStreamClient{stream}
-	if err := strm.CloseSend(); err != nil {
-		return nil, err
-	}
+	// A failed half-close means the call ended; MsgRecv reports its outcome.
+	_ = strm.CloseSend()
 	return strm, nil
 }
 
@@ -118,9 +117,8 @@ func (x *srpcEchoer_EchoClientStreamClient) Send(m *EchoMsg) error {
 }
 
 func (x *srpcEchoer_EchoClientStreamClient) CloseAndRecv() (*EchoMsg, error) {
-	if err := x.CloseSend(); err != nil {
-		return nil, err
-	}
+	// A failed half-close means the call ended; MsgRecv reports its outcome.
+	_ = x.CloseSend()
 	m := new(EchoMsg)
 	if err := x.MsgRecv(m); err != nil {
 		return nil, err
@@ -129,9 +127,8 @@ func (x *srpcEchoer_EchoClientStreamClient) CloseAndRecv() (*EchoMsg, error) {
 }
 
 func (x *srpcEchoer_EchoClientStreamClient) CloseAndMsgRecv(m *EchoMsg) error {
-	if err := x.CloseSend(); err != nil {
-		return err
-	}
+	// A failed half-close means the call ended; MsgRecv reports its outcome.
+	_ = x.CloseSend()
 	return x.MsgRecv(m)
 }
 

package/echo/echo_srpc.pb.hpp

@@ -1,7 +1,7 @@
 //go:build deps_only && cgo
 
 // Code generated by protoc-gen-starpc-cpp. DO NOT EDIT.
-// protoc-gen-starpc-cpp version: v0.49.21
+// protoc-gen-starpc-cpp version: v0.52.2-0.20260927183858-4d0f9be5aa9d+dirty
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 #pragma once
@@ -146,6 +146,8 @@ class SRPCEchoer_EchoServerStreamClient {
 
   starpc::Error CloseSend() { return strm_->CloseSend(); }
   starpc::Error Close() { return strm_->Close(); }
+  std::stop_token StopToken() const { return strm_->StopToken(); }
+  std::string RemoteErrorMessage() const { return strm_->RemoteErrorMessage(); }
 
  private:
   std::unique_ptr<starpc::Stream> strm_;
@@ -155,6 +157,9 @@ class SRPCEchoer_EchoServerStreamClient {
 class SRPCEchoer_EchoServerStreamStream {
  public:
   explicit SRPCEchoer_EchoServerStreamStream(starpc::Stream* strm) : strm_(strm) {}
+  std::stop_token StopToken() const { return strm_->StopToken(); }
+  starpc::Error Close() { return strm_->Close(); }
+  starpc::Error CloseSend() { return strm_->CloseSend(); }
 
   starpc::Error Send(const echo::EchoMsg& msg) {
     return strm_->MsgSend(msg);
@@ -180,13 +185,15 @@ class SRPCEchoer_EchoClientStreamClient {
   }
 
   starpc::Error CloseAndRecv(echo::EchoMsg* msg) {
-    starpc::Error err = strm_->CloseSend();
-    if (err != starpc::Error::OK) return err;
+    // A failed half-close means the call ended; MsgRecv reports its outcome.
+    (void)strm_->CloseSend();
     return strm_->MsgRecv(msg);
   }
 
   starpc::Error CloseSend() { return strm_->CloseSend(); }
   starpc::Error Close() { return strm_->Close(); }
+  std::stop_token StopToken() const { return strm_->StopToken(); }
+  std::string RemoteErrorMessage() const { return strm_->RemoteErrorMessage(); }
 
  private:
   std::unique_ptr<starpc::Stream> strm_;
@@ -196,6 +203,9 @@ class SRPCEchoer_EchoClientStreamClient {
 class SRPCEchoer_EchoClientStreamStream {
  public:
   explicit SRPCEchoer_EchoClientStreamStream(starpc::Stream* strm) : strm_(strm) {}
+  std::stop_token StopToken() const { return strm_->StopToken(); }
+  starpc::Error Close() { return strm_->Close(); }
+  starpc::Error CloseSend() { return strm_->CloseSend(); }
 
   starpc::Error Recv(echo::EchoMsg* msg) {
     return strm_->MsgRecv(msg);
@@ -220,6 +230,8 @@ class SRPCEchoer_EchoBidiStreamClient {
 
   starpc::Error CloseSend() { return strm_->CloseSend(); }
   starpc::Error Close() { return strm_->Close(); }
+  std::stop_token StopToken() const { return strm_->StopToken(); }
+  std::string RemoteErrorMessage() const { return strm_->RemoteErrorMessage(); }
 
  private:
   std::unique_ptr<starpc::Stream> strm_;
@@ -229,6 +241,9 @@ class SRPCEchoer_EchoBidiStreamClient {
 class SRPCEchoer_EchoBidiStreamStream {
  public:
   explicit SRPCEchoer_EchoBidiStreamStream(starpc::Stream* strm) : strm_(strm) {}
+  std::stop_token StopToken() const { return strm_->StopToken(); }
+  starpc::Error Close() { return strm_->Close(); }
+  starpc::Error CloseSend() { return strm_->CloseSend(); }
 
   starpc::Error Send(const echo::EchoMsg& msg) {
     return strm_->MsgSend(msg);
@@ -263,6 +278,8 @@ class SRPCEchoer_RpcStreamClient {
 
   starpc::Error CloseSend() { return strm_->CloseSend(); }
   starpc::Error Close() { return strm_->Close(); }
+  std::stop_token StopToken() const { return strm_->StopToken(); }
+  std::string RemoteErrorMessage() const { return strm_->RemoteErrorMessage(); }
 
  private:
   std::unique_ptr<starpc::Stream> strm_;
@@ -272,6 +289,9 @@ class SRPCEchoer_RpcStreamClient {
 class SRPCEchoer_RpcStreamStream {
  public:
   explicit SRPCEchoer_RpcStreamStream(starpc::Stream* strm) : strm_(strm) {}
+  std::stop_token StopToken() const { return strm_->StopToken(); }
+  starpc::Error Close() { return strm_->Close(); }
+  starpc::Error CloseSend() { return strm_->CloseSend(); }
 
   starpc::Error Send(const rpcstream::RpcStreamPacket& msg) {
     return strm_->MsgSend(msg);

package/echo/echo_srpc.pb.rs

@@ -1,9 +1,9 @@
 // Code generated by protoc-gen-starpc-rust. DO NOT EDIT.
-// protoc-gen-starpc-rust version: v0.49.21
+// protoc-gen-starpc-rust version: (devel)
 // source: github.com/aperturerobotics/starpc/echo/echo.proto
 
 #[allow(unused_imports)]
-use starpc::StreamExt;
+use starpc::StreamExt as _;
 
 /// Service ID for Echoer.
 pub const ECHOER_SERVICE_ID: &str = "echo.Echoer";
@@ -62,7 +62,10 @@ pub trait EchoerClient: Send + Sync {
     /// Echo.
     async fn echo(&self, request: &EchoMsg) -> starpc::Result<EchoMsg>;
     /// EchoServerStream.
-    async fn echo_server_stream(&self, request: &EchoMsg) -> starpc::Result<Box<dyn EchoerEchoServerStreamStream>>;
+    async fn echo_server_stream(
+        &self,
+        request: &EchoMsg,
+    ) -> starpc::Result<Box<dyn EchoerEchoServerStreamStream>>;
     /// EchoClientStream.
     async fn echo_client_stream(&self) -> starpc::Result<Box<dyn EchoerEchoClientStreamStream>>;
     /// EchoBidiStream.
@@ -90,27 +93,45 @@ impl<C: starpc::Client + 'static> EchoerClient for EchoerClientImpl<C> {
     async fn echo(&self, request: &EchoMsg) -> starpc::Result<EchoMsg> {
         self.client.exec_call("echo.Echoer", "Echo", request).await
     }
-    async fn echo_server_stream(&self, request: &EchoMsg) -> starpc::Result<Box<dyn EchoerEchoServerStreamStream>> {
+    async fn echo_server_stream(
+        &self,
+        request: &EchoMsg,
+    ) -> starpc::Result<Box<dyn EchoerEchoServerStreamStream>> {
         use starpc::ProstMessage;
         let data = request.encode_to_vec();
-        let stream = self.client.new_stream("echo.Echoer", "EchoServerStream", Some(&data)).await?;
-        stream.close_send().await?;
+        let stream = self
+            .client
+            .new_stream("echo.Echoer", "EchoServerStream", Some(&data))
+            .await?;
+        // A failed half-close means the call ended; msg_recv reports its outcome.
+        let _ = stream.close_send().await;
         Ok(Box::new(EchoerEchoServerStreamStreamImpl { stream }))
     }
     async fn echo_client_stream(&self) -> starpc::Result<Box<dyn EchoerEchoClientStreamStream>> {
-        let stream = self.client.new_stream("echo.Echoer", "EchoClientStream", None).await?;
+        let stream = self
+            .client
+            .new_stream("echo.Echoer", "EchoClientStream", None)
+            .await?;
         Ok(Box::new(EchoerEchoClientStreamStreamImpl { stream }))
     }
     async fn echo_bidi_stream(&self) -> starpc::Result<Box<dyn EchoerEchoBidiStreamStream>> {
-        let stream = self.client.new_stream("echo.Echoer", "EchoBidiStream", None).await?;
+        let stream = self
+            .client
+            .new_stream("echo.Echoer", "EchoBidiStream", None)
+            .await?;
         Ok(Box::new(EchoerEchoBidiStreamStreamImpl { stream }))
     }
     async fn rpc_stream(&self) -> starpc::Result<Box<dyn EchoerRpcStreamStream>> {
-        let stream = self.client.new_stream("echo.Echoer", "RpcStream", None).await?;
+        let stream = self
+            .client
+            .new_stream("echo.Echoer", "RpcStream", None)
+            .await?;
         Ok(Box::new(EchoerRpcStreamStreamImpl { stream }))
     }
     async fn do_nothing(&self, request: &Empty) -> starpc::Result<Empty> {
-        self.client.exec_call("echo.Echoer", "DoNothing", request).await
+        self.client
+            .exec_call("echo.Echoer", "DoNothing", request)
+            .await
     }
 }
 
@@ -144,7 +165,8 @@ impl EchoerEchoClientStreamStream for EchoerEchoClientStreamStreamImpl {
         self.stream.msg_send(msg).await
     }
     async fn close_and_recv(&self) -> starpc::Result<EchoMsg> {
-        self.stream.close_send().await?;
+        // A failed half-close means the call ended; msg_recv reports its outcome.
+        let _ = self.stream.close_send().await;
         self.stream.msg_recv().await
     }
 }
@@ -193,9 +215,13 @@ impl EchoerRpcStreamStream for EchoerRpcStreamStreamImpl {
 #[starpc::async_trait]
 pub trait EchoerServer: Send + Sync {
     /// Echo.
-    async fn echo(&self, request: EchoMsg) -> starpc::Result<EchoMsg>;
+    async fn echo(&self, context: &starpc::Context, request: EchoMsg) -> starpc::Result<EchoMsg>;
     /// EchoServerStream.
-    async fn echo_server_stream(&self, request: EchoMsg, stream: Box<dyn starpc::Stream>) -> starpc::Result<()>;
+    async fn echo_server_stream(
+        &self,
+        request: EchoMsg,
+        stream: Box<dyn starpc::Stream>,
+    ) -> starpc::Result<()>;
     /// EchoClientStream.
     async fn echo_client_stream(&self, stream: &dyn starpc::Stream) -> starpc::Result<EchoMsg>;
     /// EchoBidiStream.
@@ -203,7 +229,7 @@ pub trait EchoerServer: Send + Sync {
     /// RpcStream.
     async fn rpc_stream(&self, stream: Box<dyn starpc::Stream>) -> starpc::Result<()>;
     /// DoNothing.
-    async fn do_nothing(&self, request: Empty) -> starpc::Result<Empty>;
+    async fn do_nothing(&self, context: &starpc::Context, request: Empty) -> starpc::Result<Empty>;
 }
 
 const ECHOER_METHOD_IDS: &[&str] = &[
@@ -223,7 +249,9 @@ pub struct EchoerHandler<S: EchoerServer> {
 impl<S: EchoerServer + 'static> EchoerHandler<S> {
     /// Creates a new handler wrapping the server implementation.
     pub fn new(server: S) -> Self {
-        Self { server: std::sync::Arc::new(server) }
+        Self {
+            server: std::sync::Arc::new(server),
+        }
     }
 
     /// Creates a new handler with a shared server.
@@ -246,7 +274,7 @@ impl<S: EchoerServer + 'static> starpc::Invoker for EchoerHandler<S> {
                     Ok(r) => r,
                     Err(e) => return (true, Err(e)),
                 };
-                match self.server.echo(request).await {
+                match <S as EchoerServer>::echo(self.server.as_ref(), stream.context(), request).await {
                     Ok(response) => {
                         if let Err(e) = stream.msg_send(&response).await {
                             return (true, Err(e));
@@ -261,10 +289,16 @@ impl<S: EchoerServer + 'static> starpc::Invoker for EchoerHandler<S> {
                     Ok(r) => r,
                     Err(e) => return (true, Err(e)),
                 };
-                (true, self.server.echo_server_stream(request, stream).await)
+                (
+                    true,
+                    <S as EchoerServer>::echo_server_stream(self.server.as_ref(), request, stream)
+                        .await,
+                )
             }
             "EchoClientStream" => {
-                match self.server.echo_client_stream(stream.as_ref()).await {
+                match <S as EchoerServer>::echo_client_stream(self.server.as_ref(), stream.as_ref())
+                    .await
+                {
                     Ok(response) => {
                         if let Err(e) = stream.msg_send(&response).await {
                             return (true, Err(e));
@@ -274,18 +308,20 @@ impl<S: EchoerServer + 'static> starpc::Invoker for EchoerHandler<S> {
                     Err(e) => (true, Err(e)),
                 }
             }
-            "EchoBidiStream" => {
-                (true, self.server.echo_bidi_stream(stream).await)
-            }
-            "RpcStream" => {
-                (true, self.server.rpc_stream(stream).await)
-            }
+            "EchoBidiStream" => (
+                true,
+                <S as EchoerServer>::echo_bidi_stream(self.server.as_ref(), stream).await,
+            ),
+            "RpcStream" => (
+                true,
+                <S as EchoerServer>::rpc_stream(self.server.as_ref(), stream).await,
+            ),
             "DoNothing" => {
                 let request: Empty = match stream.msg_recv().await {
                     Ok(r) => r,
                     Err(e) => return (true, Err(e)),
                 };
-                match self.server.do_nothing(request).await {
+                match <S as EchoerServer>::do_nothing(self.server.as_ref(), stream.context(), request).await {
                     Ok(response) => {
                         if let Err(e) = stream.msg_send(&response).await {
                             return (true, Err(e));
@@ -309,4 +345,3 @@ impl<S: EchoerServer + 'static> starpc::Handler for EchoerHandler<S> {
         ECHOER_METHOD_IDS
     }
 }
-

package/echo/echo_srpc.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 from collections.abc import AsyncIterable, AsyncIterator
 from typing import Protocol
 
@@ -117,7 +118,9 @@ class EchoerClient:
         try:
             async for request in requests:
                 await call.send(request.SerializeToString(deterministic=True))
-            await call.finish()
+            # A failed half-close means the call ended; receive reports its outcome.
+            with contextlib.suppress(OSError):
+                await call.finish()
             data = await call.receive()
             if data is None:
                 raise CallProtocolError("missing client-stream response")

package/echo/half_close_test.rs

@@ -0,0 +1,178 @@
+//! Half-close tests for the generated Rust callers.
+//!
+//! The half-close is only a notice once the request is written: a caller that
+//! half-closes after the remote ended the call must still read the buffered
+//! responses and the call's outcome.
+
+#[allow(dead_code)]
+mod gen;
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use futures::StreamExt as _;
+use prost::Message;
+use starpc::client::OpenStream;
+use starpc::testing::{create_pipe_default, create_test_pair, SingleInMemoryOpener};
+use starpc::{Client, Error, Mux, PacketCodec, Result, Server, SrpcClient, Stream, StreamExt};
+use tokio::task::JoinHandle;
+use tokio_util::codec::FramedRead;
+
+use gen::{EchoMsg, EchoerClient, EchoerClientImpl, EchoerHandler, EchoerServer};
+
+const BODY_TXT: &str = "hello world via starpc half-close test";
+
+/// Answers each streaming call once and completes it.
+struct OnceEchoServer;
+
+#[async_trait]
+impl EchoerServer for OnceEchoServer {
+    async fn echo(&self, _context: &starpc::Context, request: EchoMsg) -> Result<EchoMsg> {
+        Ok(request)
+    }
+
+    async fn echo_server_stream(&self, request: EchoMsg, stream: Box<dyn Stream>) -> Result<()> {
+        stream.msg_send(&request).await
+    }
+
+    async fn echo_client_stream(&self, stream: &dyn Stream) -> Result<EchoMsg> {
+        // Reply to the first message without waiting for the half-close.
+        stream.msg_recv().await
+    }
+
+    async fn echo_bidi_stream(&self, _stream: Box<dyn Stream>) -> Result<()> {
+        Err(Error::Unimplemented)
+    }
+
+    async fn rpc_stream(&self, _stream: Box<dyn Stream>) -> Result<()> {
+        Err(Error::Unimplemented)
+    }
+
+    async fn do_nothing(
+        &self,
+        _context: &starpc::Context,
+        request: gen::Empty,
+    ) -> Result<gen::Empty> {
+        Ok(request)
+    }
+}
+
+/// Returns each new stream only after its transport has closed, so the
+/// generated caller half-closes after the remote already ended the call.
+struct EndedClient<T: OpenStream> {
+    client: SrpcClient<T>,
+}
+
+#[async_trait]
+impl<T: OpenStream + 'static> Client for EndedClient<T> {
+    async fn exec_call<I, O>(&self, service: &str, method: &str, input: &I) -> Result<O>
+    where
+        I: Message + Send + Sync,
+        O: Message + Default,
+    {
+        self.client.exec_call(service, method, input).await
+    }
+
+    async fn new_stream(
+        &self,
+        service: &str,
+        method: &str,
+        first_msg: Option<&[u8]>,
+    ) -> Result<Box<dyn Stream>> {
+        let stream = self.client.new_stream(service, method, first_msg).await?;
+        // The transport close handler cancels the context after it settles
+        // the call's outcome and closes the writer.
+        stream.context().cancelled().await;
+        Ok(stream)
+    }
+}
+
+/// Returns one transport opener and the server task that its caller must join.
+fn serve_once_echo() -> (SingleInMemoryOpener, JoinHandle<Result<()>>) {
+    let mux = Arc::new(Mux::new());
+    mux.register(Arc::new(EchoerHandler::new(OnceEchoServer)))
+        .unwrap();
+    let (opener, server_stream) = create_test_pair();
+    let server = Server::with_arc(mux);
+    let task = tokio::spawn(async move { server.handle_stream(server_stream).await });
+    (opener, task)
+}
+
+/// Returns a transport that closes after CallStart and the peer task to join after observation.
+fn drop_after_request() -> (SingleInMemoryOpener, JoinHandle<()>) {
+    // Use the actual framing boundary to order peer closure after request admission.
+    let (client_stream, server_stream) = create_pipe_default();
+    let task = tokio::spawn(async move {
+        let mut framed = FramedRead::new(server_stream, PacketCodec::new());
+        let _ = framed.next().await;
+    });
+    (SingleInMemoryOpener::new(client_stream), task)
+}
+
+#[tokio::test]
+async fn server_stream_completed_before_close_send() {
+    // Complete the server stream before the generated caller half-closes.
+    let (opener, server) = serve_once_echo();
+    let client = EchoerClientImpl::new(EndedClient {
+        client: SrpcClient::new(opener),
+    });
+    let request = EchoMsg {
+        body: BODY_TXT.into(),
+    };
+    let stream = client
+        .echo_server_stream(&request)
+        .await
+        .expect("server stream discarded after remote completion");
+
+    // Read the buffered response, then the clean completion.
+    let msg = stream.recv().await.expect("buffered response lost");
+    assert_eq!(msg.body, BODY_TXT);
+    let end = stream.recv().await;
+    assert!(
+        matches!(end, Err(Error::StreamClosed)),
+        "expected StreamClosed after completion, got {end:?}"
+    );
+    server.await.unwrap().unwrap();
+}
+
+#[tokio::test]
+async fn client_stream_completed_before_close_send() {
+    let (opener, server) = serve_once_echo();
+    let client = EchoerClientImpl::new(SrpcClient::new(opener));
+    let stream = client.echo_client_stream().await.unwrap();
+
+    // Send the one request and wait for the call to end.
+    let request = EchoMsg {
+        body: BODY_TXT.into(),
+    };
+    stream.send(&request).await.unwrap();
+    stream.context().cancelled().await;
+
+    // The half-close fails, but the reply is still readable.
+    let msg = stream.close_and_recv().await.expect("buffered reply lost");
+    assert_eq!(msg.body, BODY_TXT);
+    server.await.unwrap().unwrap();
+}
+
+#[tokio::test]
+async fn server_stream_transport_failure_before_close_send() {
+    let (opener, server) = drop_after_request();
+    let client = EchoerClientImpl::new(EndedClient {
+        client: SrpcClient::new(opener),
+    });
+    let request = EchoMsg {
+        body: BODY_TXT.into(),
+    };
+    let stream = client
+        .echo_server_stream(&request)
+        .await
+        .expect("server stream discarded after transport failure");
+
+    // Recv reports that the call ended without a verdict.
+    let end = stream.recv().await;
+    assert!(
+        matches!(end, Err(Error::ClosedBeforeCompletion)),
+        "expected ClosedBeforeCompletion, got {end:?}"
+    );
+    server.await.unwrap();
+}

package/echo/integration_server.rs

@@ -1,3 +1,5 @@
+//! Echo transport endpoint used by cross-language integration checks.
+
 #[allow(dead_code)]
 mod gen;
 
@@ -9,21 +11,16 @@ use tokio::net::TcpListener;
 
 use gen::{EchoMsg, EchoerHandler, EchoerServer, Empty};
 
+/// Implements each echo call shape through the supplied transport stream.
 struct EchoServerImpl;
 
 #[async_trait]
 impl EchoerServer for EchoServerImpl {
-    async fn echo(&self, request: EchoMsg) -> Result<EchoMsg> {
-        Ok(EchoMsg {
-            body: request.body,
-        })
+    async fn echo(&self, _context: &starpc::Context, request: EchoMsg) -> Result<EchoMsg> {
+        Ok(EchoMsg { body: request.body })
     }
 
-    async fn echo_server_stream(
-        &self,
-        request: EchoMsg,
-        stream: Box<dyn Stream>,
-    ) -> Result<()> {
+    async fn echo_server_stream(&self, request: EchoMsg, stream: Box<dyn Stream>) -> Result<()> {
         for _ in 0..5 {
             let response = EchoMsg {
                 body: request.body.clone(),
@@ -34,10 +31,7 @@ impl EchoerServer for EchoServerImpl {
     }
 
     async fn echo_client_stream(&self, stream: &dyn Stream) -> Result<EchoMsg> {
-        match stream.msg_recv::<EchoMsg>().await {
-            Ok(msg) => Ok(msg),
-            Err(e) => Err(e),
-        }
+        stream.msg_recv().await
     }
 
     async fn echo_bidi_stream(&self, stream: Box<dyn Stream>) -> Result<()> {
@@ -63,11 +57,12 @@ impl EchoerServer for EchoServerImpl {
         Err(Error::Unimplemented)
     }
 
-    async fn do_nothing(&self, _request: Empty) -> Result<Empty> {
+    async fn do_nothing(&self, _context: &starpc::Context, _request: Empty) -> Result<Empty> {
         Ok(Empty {})
     }
 }
 
+/// Publishes a bound address and keeps accepted connections under the server owner.
 #[tokio::main]
 async fn main() -> Result<()> {
     let listener = TcpListener::bind("127.0.0.1:0").await?;
@@ -77,11 +72,9 @@ async fn main() -> Result<()> {
     let mux = Arc::new(Mux::new());
     mux.register(Arc::new(EchoerHandler::new(EchoServerImpl)))?;
 
-    loop {
-        let (stream, _) = listener.accept().await?;
-        let server = Server::with_arc(mux.clone());
-        tokio::spawn(async move {
-            let _ = server.handle_stream(stream).await;
-        });
-    }
+    // The server owns concurrent calls and their cancellation for this listener's lifetime.
+    let incoming = futures::stream::unfold(listener, |listener| async move {
+        Some((listener.accept().await.map(|(stream, _)| stream), listener))
+    });
+    Server::with_arc(mux).serve(Box::pin(incoming)).await
 }