starpc 0.52.1 → 0.52.2

package/srpc/mux.rs

@@ -90,9 +90,7 @@ impl Mux {
         let method_ids = handler.method_ids();
 
         let mut services = self.services.write().unwrap();
-        let service_methods = services
-            .entry(service_id.to_string())
-            .or_insert_with(HashMap::new);
+        let service_methods = services.entry(service_id.to_string()).or_default();
 
         for method_id in method_ids {
             if !method_id.is_empty() {
@@ -346,7 +344,9 @@ mod tests {
         }
 
         // Should find the method even with empty service ID
-        let (handled, result) = mux.invoke_method("", "TestMethod", Box::new(MockStream)).await;
+        let (handled, result) = mux
+            .invoke_method("", "TestMethod", Box::new(MockStream))
+            .await;
         assert!(handled);
         assert!(result.is_ok());
     }

package/srpc/net.go

@@ -7,12 +7,14 @@ import (
 
 // Dial dials a remote server using TCP with the default muxed conn type.
 func Dial(addr string) (Client, error) {
+	// Connect the byte stream before attaching its stream multiplexer.
 	nconn, err := net.Dial("tcp", addr)
 	if err != nil {
 		return nil, err
 	}
 	muxedConn, err := NewMuxedConn(nconn, false, nil)
 	if err != nil {
+		_ = nconn.Close()
 		return nil, err
 	}
 	return NewClientWithMuxedConn(muxedConn), nil
@@ -22,11 +24,14 @@ func Dial(addr string) (Client, error) {
 // Returns on any fatal error or if ctx was canceled.
 // errCh is an optional error channel (can be nil)
 func Listen(ctx context.Context, addr string, srv *Server, errCh <-chan error) error {
+	// The listener and its accept routine live until this function returns.
 	lis, err := net.Listen("tcp", addr)
 	if err != nil {
 		return err
 	}
+	defer lis.Close()
 
+	// Observe serving failure alongside the caller's stop conditions.
 	listenErrCh := make(chan error, 1)
 	go func() {
 		listenErrCh <- AcceptMuxedListener(ctx, lis, srv, nil)
@@ -35,10 +40,14 @@ func Listen(ctx context.Context, addr string, srv *Server, errCh <-chan error) e
 
 	select {
 	case <-ctx.Done():
-		return context.Canceled
-	case err := <-errCh:
-		return err
+		err = ctx.Err()
+	case err = <-errCh:
 	case err := <-listenErrCh:
 		return err
 	}
+
+	// Closing the listener wakes Accept; wait for its cleanup before returning.
+	_ = lis.Close()
+	<-listenErrCh
+	return err
 }

package/srpc/packet.cpp

@@ -6,78 +6,80 @@
 
 namespace starpc {
 
-PacketDataHandler NewPacketDataHandler(PacketHandler handler) {
-  return [handler](const std::string &data) -> Error {
-    srpc::Packet pkt;
-    if (!pkt.ParseFromString(data)) {
-      return Error::InvalidMessage;
-    }
-    return handler(pkt);
-  };
+PacketDataHandler NewPacketDataHandler(PacketHandler handler)
+{
+	return [handler](const std::string &data) -> Error {
+		srpc::Packet pkt;
+		if (!pkt.ParseFromString(data))
+			return Error::InvalidMessage;
+		return handler(pkt);
+	};
 }
 
-Error ValidatePacket(const srpc::Packet &pkt) {
-  switch (pkt.body_case()) {
-  case srpc::Packet::kCallStart:
-    return ValidateCallStart(pkt.call_start());
-  case srpc::Packet::kCallData:
-    return ValidateCallData(pkt.call_data());
-  case srpc::Packet::kCallCancel:
-    return Error::OK;
-  default:
-    return Error::UnrecognizedPacket;
-  }
+Error ValidatePacket(const srpc::Packet &pkt)
+{
+	switch (pkt.body_case()) {
+	case srpc::Packet::kCallStart:
+		return ValidateCallStart(pkt.call_start());
+	case srpc::Packet::kCallData:
+		return ValidateCallData(pkt.call_data());
+	case srpc::Packet::kCallCancel:
+		return Error::OK;
+	default:
+		return Error::UnrecognizedPacket;
+	}
 }
 
-Error ValidateCallStart(const srpc::CallStart &pkt) {
-  if (pkt.rpc_method().empty()) {
-    return Error::EmptyMethodID;
-  }
-  if (pkt.rpc_service().empty()) {
-    return Error::EmptyServiceID;
-  }
-  return Error::OK;
+Error ValidateCallStart(const srpc::CallStart &pkt)
+{
+	if (pkt.rpc_method().empty())
+		return Error::EmptyMethodID;
+	if (pkt.rpc_service().empty())
+		return Error::EmptyServiceID;
+	return Error::OK;
 }
 
-Error ValidateCallData(const srpc::CallData &pkt) {
-  if (pkt.data().empty() && !pkt.complete() && pkt.error().empty() &&
-      !pkt.data_is_zero()) {
-    return Error::EmptyPacket;
-  }
-  return Error::OK;
+Error ValidateCallData(const srpc::CallData &pkt)
+{
+	if (pkt.data().empty() && !pkt.complete() && pkt.error().empty() &&
+	    !pkt.data_is_zero())
+		return Error::EmptyPacket;
+	return Error::OK;
 }
 
 std::unique_ptr<srpc::Packet> NewCallStartPacket(const std::string &service,
-                                                 const std::string &method,
-                                                 const std::string &data,
-                                                 bool data_is_zero) {
-  auto pkt = std::make_unique<srpc::Packet>();
-  auto *call_start = pkt->mutable_call_start();
-  call_start->set_rpc_service(service);
-  call_start->set_rpc_method(method);
-  call_start->set_data(data);
-  call_start->set_data_is_zero(data_is_zero);
-  return pkt;
+						 const std::string &method,
+						 const std::string &data,
+						 bool data_is_zero)
+{
+	auto pkt = std::make_unique<srpc::Packet>();
+	auto *call_start = pkt->mutable_call_start();
+	call_start->set_rpc_service(service);
+	call_start->set_rpc_method(method);
+	call_start->set_data(data);
+	call_start->set_data_is_zero(data_is_zero);
+	return pkt;
 }
 
 std::unique_ptr<srpc::Packet> NewCallDataPacket(const std::string &data,
-                                                bool data_is_zero,
-                                                bool complete, Error err) {
-  auto pkt = std::make_unique<srpc::Packet>();
-  auto *call_data = pkt->mutable_call_data();
-  call_data->set_data(data);
-  call_data->set_data_is_zero(data_is_zero);
-  call_data->set_complete(err != Error::OK || complete);
-  if (err != Error::OK) {
-    call_data->set_error(ErrorString(err));
-  }
-  return pkt;
+						bool data_is_zero,
+						bool complete, Error err)
+{
+	auto pkt = std::make_unique<srpc::Packet>();
+	auto *call_data = pkt->mutable_call_data();
+	call_data->set_data(data);
+	call_data->set_data_is_zero(data_is_zero);
+	call_data->set_complete(err != Error::OK || complete);
+	if (err != Error::OK)
+		call_data->set_error(ErrorString(err));
+	return pkt;
 }
 
-std::unique_ptr<srpc::Packet> NewCallCancelPacket() {
-  auto pkt = std::make_unique<srpc::Packet>();
-  pkt->set_call_cancel(true);
-  return pkt;
+std::unique_ptr<srpc::Packet> NewCallCancelPacket()
+{
+	auto pkt = std::make_unique<srpc::Packet>();
+	pkt->set_call_cancel(true);
+	return pkt;
 }
 
 } // namespace starpc

package/srpc/packet.hpp

@@ -1,12 +1,12 @@
 #pragma once
 
+#include "errors.hpp"
+
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <string>
 
-#include "errors.hpp"
-
 namespace srpc {
 class Packet;
 class CallStart;
@@ -15,42 +15,57 @@ class CallData;
 
 namespace starpc {
 
-// CloseHandler handles the stream closing with an optional error.
-// Matches Go CloseHandler in packet.go
+/*
+ * CloseHandler receives the transport close outcome for a stream.
+ * Matches Go CloseHandler in packet.go.
+ */
 using CloseHandler = std::function<void(Error close_err)>;
 
-// PacketHandler handles a packet.
-// Matches Go PacketHandler in packet.go
+/* PacketHandler receives one parsed packet. Matches Go PacketHandler. */
 using PacketHandler = std::function<Error(const srpc::Packet &pkt)>;
 
-// PacketDataHandler handles a packet before it is parsed.
-// Matches Go PacketDataHandler in packet.go
+/*
+ * PacketDataHandler receives one packet before parsing, as its serialized
+ * bytes. Matches Go PacketDataHandler in packet.go.
+ */
 using PacketDataHandler = std::function<Error(const std::string &data)>;
 
-// NewPacketDataHandler wraps a PacketHandler with a decoding step.
+/* NewPacketDataHandler parses each payload and forwards it to handler. */
 PacketDataHandler NewPacketDataHandler(PacketHandler handler);
 
-// Validate performs cursory validation of a Packet.
+/*
+ * ValidatePacket checks a packet's shape: its body is one of the known types
+ * and the body's required fields are present.
+ */
 Error ValidatePacket(const srpc::Packet &pkt);
 
-// Validate performs cursory validation of a CallStart.
+/* ValidateCallStart requires the service and method IDs to be present. */
 Error ValidateCallStart(const srpc::CallStart &pkt);
 
-// Validate performs cursory validation of a CallData.
+/*
+ * ValidateCallData rejects a packet that carries no data, no completion, no
+ * error, and no zero-length marker.
+ */
 Error ValidateCallData(const srpc::CallData &pkt);
 
-// NewCallStartPacket constructs a new CallStart packet.
+/*
+ * NewCallStartPacket builds the CallStart packet that opens a call.
+ * data_is_zero marks an intentionally empty first message.
+ */
 std::unique_ptr<srpc::Packet> NewCallStartPacket(const std::string &service,
-                                                 const std::string &method,
-                                                 const std::string &data,
-                                                 bool data_is_zero);
+						 const std::string &method,
+						 const std::string &data,
+						 bool data_is_zero);
 
-// NewCallDataPacket constructs a new CallData packet.
+/*
+ * NewCallDataPacket builds one CallData packet. err carries the call's
+ * terminal verdict; complete ends the sending side.
+ */
 std::unique_ptr<srpc::Packet> NewCallDataPacket(const std::string &data,
-                                                bool data_is_zero,
-                                                bool complete, Error err);
+						bool data_is_zero,
+						bool complete, Error err);
 
-// NewCallCancelPacket constructs a new CallCancel packet with cancel.
+/* NewCallCancelPacket builds the packet that cancels the call. */
 std::unique_ptr<srpc::Packet> NewCallCancelPacket();
 
 } // namespace starpc

package/srpc/packet.rs

@@ -10,10 +10,8 @@ use bytes::Bytes;
 
 /// Creates a new CallStart packet.
 ///
-/// # Arguments
-/// * `service` - The service ID
-/// * `method` - The method ID
-/// * `data` - Optional initial data (None = no data, Some(empty) = empty data)
+/// `None` data sends no payload; `Some(empty)` sends empty data with the
+/// `data_is_zero` flag set.
 pub fn new_call_start(
     service: impl Into<String>,
     method: impl Into<String>,
@@ -31,10 +29,7 @@ pub fn new_call_start(
     }
 }
 
-/// Creates a new CallData packet with data.
-///
-/// # Arguments
-/// * `data` - The data to send (can be empty)
+/// Creates a new CallData packet carrying `data`, which may be empty.
 pub fn new_call_data(data: Vec<u8>) -> Packet {
     let data_is_zero = data.is_empty();
     Packet {
@@ -49,16 +44,9 @@ pub fn new_call_data(data: Vec<u8>) -> Packet {
 
 /// Creates a new CallData packet with optional data and flags.
 ///
-/// # Arguments
-/// * `data` - Optional data bytes
-/// * `data_is_zero` - True if empty data should be sent
-/// * `complete` - True if this completes the stream
-/// * `error` - Optional error message
-pub fn new_call_data_full(
-    data: Option<Bytes>,
-    complete: bool,
-    error: Option<String>,
-) -> Packet {
+/// Sets `complete` when either `complete` or `error` is set, so an error
+/// always ends the call.
+pub fn new_call_data_full(data: Option<Bytes>, complete: bool, error: Option<String>) -> Packet {
     let (data_bytes, data_is_zero) = encode_optional_data(data);
 
     Packet {
@@ -83,10 +71,7 @@ pub fn new_call_complete() -> Packet {
     }
 }
 
-/// Creates a new CallData packet with an error.
-///
-/// # Arguments
-/// * `error` - The error message
+/// Creates a new CallData packet carrying an error message.
 pub fn new_call_error(error: impl Into<String>) -> Packet {
     Packet {
         body: Some(Body::CallData(CallData {
@@ -154,11 +139,7 @@ impl Validate for CallData {
         // - data_is_zero flag set (indicating intentionally empty data)
         // - complete flag set
         // - error message
-        if self.data.is_empty()
-            && !self.data_is_zero
-            && !self.complete
-            && self.error.is_empty()
-        {
+        if self.data.is_empty() && !self.data_is_zero && !self.complete && self.error.is_empty() {
             return Err(Error::EmptyPacket);
         }
         Ok(())