starpc 0.46.0 → 0.46.2

package/dist/integration/cross-language/ts-client.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/integration/cross-language/ts-client.js

@@ -0,0 +1,67 @@
+import net from 'net';
+import { pipe } from 'it-pipe';
+import { pushable } from 'it-pushable';
+import { Client } from '../../srpc/client.js';
+import { parseLengthPrefixTransform, prependLengthPrefixTransform, } from '../../srpc/packet.js';
+import { combineUint8ArrayListTransform } from '../../srpc/array-list.js';
+import { runClientTest } from '../../echo/client-test.js';
+// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
+function tcpSocketToPacketStream(socket) {
+    const socketSource = async function* () {
+        const source = pushable({ objectMode: true });
+        socket.on('data', (data) => {
+            source.push(new Uint8Array(data));
+        });
+        socket.on('end', () => source.end());
+        socket.on('error', (err) => source.end(err));
+        socket.on('close', () => source.end());
+        yield* pipe(source, parseLengthPrefixTransform(), combineUint8ArrayListTransform());
+    };
+    return {
+        source: socketSource(),
+        sink: async (source) => {
+            for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
+                const data = chunk instanceof Uint8Array ? chunk : chunk.subarray();
+                await new Promise((resolve, reject) => {
+                    socket.write(data, (err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                });
+            }
+            socket.end();
+        },
+    };
+}
+async function main() {
+    const addr = process.argv[2];
+    if (!addr) {
+        console.error('usage: ts-client <host:port>');
+        process.exit(1);
+    }
+    const [host, portStr] = addr.split(':');
+    const port = parseInt(portStr, 10);
+    const openStream = async () => {
+        return new Promise((resolve, reject) => {
+            const socket = net.connect(port, host, () => {
+                resolve(tcpSocketToPacketStream(socket));
+            });
+            socket.on('error', reject);
+        });
+    };
+    const client = new Client(openStream);
+    console.log('Running client test via TCP...');
+    await runClientTest(client);
+    console.log('All tests passed.');
+    process.exit(0);
+}
+process.on('unhandledRejection', (ev) => {
+    console.error('Unhandled rejection', ev);
+    process.exit(1);
+});
+main().catch((err) => {
+    console.error('Error:', err);
+    process.exit(1);
+});

package/dist/integration/cross-language/ts-server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/integration/cross-language/ts-server.js

@@ -0,0 +1,60 @@
+import net from 'net';
+import { pipe } from 'it-pipe';
+import { pushable } from 'it-pushable';
+import { createMux, createHandler, Server } from '../../srpc/index.js';
+import { parseLengthPrefixTransform, prependLengthPrefixTransform, } from '../../srpc/packet.js';
+import { combineUint8ArrayListTransform } from '../../srpc/array-list.js';
+import { EchoerServer } from '../../echo/server.js';
+import { EchoerDefinition } from '../../echo/echo_srpc.pb.js';
+// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
+// Each Uint8Array in source/sink is one packet (no length prefix).
+function tcpSocketToPacketStream(socket) {
+    // Source: read from socket, strip length prefix, yield individual packets.
+    const socketSource = async function* () {
+        const source = pushable({ objectMode: true });
+        socket.on('data', (data) => {
+            source.push(new Uint8Array(data));
+        });
+        socket.on('end', () => source.end());
+        socket.on('error', (err) => source.end(err));
+        socket.on('close', () => source.end());
+        yield* pipe(source, parseLengthPrefixTransform(), combineUint8ArrayListTransform());
+    };
+    return {
+        source: socketSource(),
+        sink: async (source) => {
+            for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
+                const data = chunk instanceof Uint8Array ? chunk : chunk.subarray();
+                await new Promise((resolve, reject) => {
+                    socket.write(data, (err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                });
+            }
+            socket.end();
+        },
+    };
+}
+const mux = createMux();
+const server = new Server(mux.lookupMethod);
+const echoer = new EchoerServer(server);
+mux.register(createHandler(EchoerDefinition, echoer));
+const tcpServer = net.createServer((socket) => {
+    const stream = tcpSocketToPacketStream(socket);
+    server.handlePacketStream(stream);
+});
+tcpServer.listen(0, '127.0.0.1', () => {
+    const addr = tcpServer.address();
+    console.log(`LISTENING ${addr.address}:${addr.port}`);
+});
+process.on('SIGINT', () => {
+    tcpServer.close();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    tcpServer.close();
+    process.exit(0);
+});

package/echo/Cargo.toml

@@ -10,6 +10,14 @@ publish = false
 name = "echo-example"
 path = "main.rs"
 
+[[bin]]
+name = "integration-server"
+path = "integration_server.rs"
+
+[[bin]]
+name = "integration-client"
+path = "integration_client.rs"
+
 [dependencies]
 starpc = { workspace = true }
 prost = { workspace = true }

package/echo/echo_e2e_test.cpp

@@ -182,9 +182,9 @@ public:
 
   starpc::Error RpcStream(echo::SRPCEchoer_RpcStreamStream *strm) override {
     // Wrap stream to implement rpcstream::RpcStream interface
-    RpcStreamAdapter adapter(strm);
+    auto adapter = std::make_shared<RpcStreamAdapter>(strm);
     return rpcstream::HandleRpcStream(
-        &adapter, [this](const std::string &component_id) {
+        adapter, [this](const std::string &component_id) {
           if (!rpc_stream_mux_) {
             return std::make_tuple(static_cast<starpc::Invoker *>(nullptr),
                                    std::function<void()>(),

package/echo/integration_client.rs

@@ -0,0 +1,168 @@
+#[allow(dead_code)]
+mod gen;
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use starpc::client::{OpenStream, PacketReceiver, SrpcClient};
+use starpc::rpc::PacketWriter;
+use starpc::transport::create_packet_channel;
+use starpc::{Error, Result};
+// Use Error::Remote for test assertion errors since there's no Error::Remote.
+use tokio::net::TcpStream;
+
+use gen::{EchoMsg, EchoerClient, EchoerClientImpl};
+
+const BODY_TXT: &str = "hello world via starpc cross-language e2e test";
+
+/// Opens a new TCP connection per RPC call.
+struct TcpStreamOpener {
+    addr: String,
+}
+
+impl TcpStreamOpener {
+    fn new(addr: String) -> Self {
+        Self { addr }
+    }
+}
+
+#[async_trait]
+impl OpenStream for TcpStreamOpener {
+    async fn open_stream(&self) -> Result<(Arc<dyn PacketWriter>, PacketReceiver)> {
+        let stream = TcpStream::connect(&self.addr).await?;
+        let (read, write) = tokio::io::split(stream);
+        Ok(create_packet_channel(read, write))
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    let addr = std::env::args()
+        .nth(1)
+        .expect("usage: integration-client <addr>");
+
+    let opener = TcpStreamOpener::new(addr);
+    let client = SrpcClient::new(opener);
+    let echo = EchoerClientImpl::new(client);
+
+    if let Err(e) = test_unary(&echo).await {
+        eprintln!("unary test failed: {}", e);
+        std::process::exit(1);
+    }
+
+    if let Err(e) = test_server_stream(&echo).await {
+        eprintln!("server stream test failed: {}", e);
+        std::process::exit(1);
+    }
+
+    if let Err(e) = test_client_stream(&echo).await {
+        eprintln!("client stream test failed: {}", e);
+        std::process::exit(1);
+    }
+
+    if let Err(e) = test_bidi_stream(&echo).await {
+        eprintln!("bidi stream test failed: {}", e);
+        std::process::exit(1);
+    }
+
+    println!("All tests passed.");
+}
+
+async fn test_unary(echo: &dyn EchoerClient) -> Result<()> {
+    println!("Testing Unary RPC...");
+    let req = EchoMsg {
+        body: BODY_TXT.to_string(),
+    };
+    let resp = echo.echo(&req).await?;
+    if resp.body != BODY_TXT {
+        return Err(Error::Remote(format!(
+            "expected {:?} got {:?}",
+            BODY_TXT, resp.body
+        )));
+    }
+    println!("  PASSED");
+    Ok(())
+}
+
+async fn test_server_stream(echo: &dyn EchoerClient) -> Result<()> {
+    println!("Testing ServerStream RPC...");
+    let req = EchoMsg {
+        body: BODY_TXT.to_string(),
+    };
+    let stream = echo.echo_server_stream(&req).await?;
+    let mut received = 0;
+    loop {
+        match stream.recv().await {
+            Ok(msg) => {
+                if msg.body != BODY_TXT {
+                    return Err(Error::Remote(format!(
+                        "expected {:?} got {:?}",
+                        BODY_TXT, msg.body
+                    )));
+                }
+                received += 1;
+            }
+            Err(Error::StreamClosed) => break,
+            Err(e) => return Err(e),
+        }
+    }
+    if received != 5 {
+        return Err(Error::Remote(format!(
+            "expected 5 messages, got {}",
+            received
+        )));
+    }
+    println!("  PASSED");
+    Ok(())
+}
+
+async fn test_client_stream(echo: &dyn EchoerClient) -> Result<()> {
+    println!("Testing ClientStream RPC...");
+    let stream = echo.echo_client_stream().await?;
+    stream
+        .send(&EchoMsg {
+            body: BODY_TXT.to_string(),
+        })
+        .await?;
+    let resp = stream.close_and_recv().await?;
+    if resp.body != BODY_TXT {
+        return Err(Error::Remote(format!(
+            "expected {:?} got {:?}",
+            BODY_TXT, resp.body
+        )));
+    }
+    println!("  PASSED");
+    Ok(())
+}
+
+async fn test_bidi_stream(echo: &dyn EchoerClient) -> Result<()> {
+    println!("Testing BidiStream RPC...");
+    let stream = echo.echo_bidi_stream().await?;
+
+    // Receive initial message from server.
+    let msg = stream.recv().await?;
+    if msg.body != "hello from server" {
+        return Err(Error::Remote(format!(
+            "expected {:?} got {:?}",
+            "hello from server", msg.body
+        )));
+    }
+
+    // Send a message and expect echo.
+    stream
+        .send(&EchoMsg {
+            body: BODY_TXT.to_string(),
+        })
+        .await?;
+    let resp = stream.recv().await?;
+    if resp.body != BODY_TXT {
+        return Err(Error::Remote(format!(
+            "expected {:?} got {:?}",
+            BODY_TXT, resp.body
+        )));
+    }
+
+    stream.close().await?;
+    println!("  PASSED");
+    Ok(())
+}

package/echo/integration_server.rs

@@ -0,0 +1,87 @@
+#[allow(dead_code)]
+mod gen;
+
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use starpc::{Error, Mux, Result, Server, Stream, StreamExt};
+use tokio::net::TcpListener;
+
+use gen::{EchoMsg, EchoerHandler, EchoerServer, Empty};
+
+struct EchoServerImpl;
+
+#[async_trait]
+impl EchoerServer for EchoServerImpl {
+    async fn echo(&self, request: EchoMsg) -> Result<EchoMsg> {
+        Ok(EchoMsg {
+            body: request.body,
+        })
+    }
+
+    async fn echo_server_stream(
+        &self,
+        request: EchoMsg,
+        stream: Box<dyn Stream>,
+    ) -> Result<()> {
+        for _ in 0..5 {
+            let response = EchoMsg {
+                body: request.body.clone(),
+            };
+            stream.msg_send(&response).await?;
+        }
+        Ok(())
+    }
+
+    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),
+        }
+    }
+
+    async fn echo_bidi_stream(&self, stream: Box<dyn Stream>) -> Result<()> {
+        // Send initial message (matches Go server behavior).
+        stream
+            .msg_send(&EchoMsg {
+                body: "hello from server".to_string(),
+            })
+            .await?;
+        loop {
+            match stream.msg_recv::<EchoMsg>().await {
+                Ok(msg) => {
+                    stream.msg_send(&msg).await?;
+                }
+                Err(Error::StreamClosed) => break,
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
+    async fn rpc_stream(&self, _stream: Box<dyn Stream>) -> Result<()> {
+        Err(Error::Unimplemented)
+    }
+
+    async fn do_nothing(&self, _request: Empty) -> Result<Empty> {
+        Ok(Empty {})
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let listener = TcpListener::bind("127.0.0.1:0").await?;
+    let addr = listener.local_addr()?;
+    println!("LISTENING {}", addr);
+
+    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;
+        });
+    }
+}