starpc 0.8.3 → 0.8.6

package/dist/e2e/e2e.js

@@ -8,7 +8,7 @@ async function runRPC() {
     const echoer = new EchoerServer(server);
     mux.register(createHandler(EchoerDefinition, echoer));
     const clientConn = new Conn();
-    const serverConn = new Conn(server);
+    const serverConn = new Conn(server, { direction: 'inbound' });
     pipe(clientConn, serverConn, clientConn);
     const client = new Client(clientConn.buildOpenStreamFunc());
     await runRpcStreamTest(client);

package/dist/integration/integration.js

@@ -5,7 +5,7 @@ async function runRPC() {
     const addr = 'ws://localhost:5000/demo';
     console.log(`Connecting to ${addr}`);
     const ws = new WebSocket(addr);
-    const channel = new WebSocketConn(ws);
+    const channel = new WebSocketConn(ws, 'outbound');
     const client = channel.buildClient();
     console.log('Running client test via WebSocket..');
     await runClientTest(client);

package/dist/srpc/conn.d.ts

@@ -1,10 +1,11 @@
-import type { Stream } from '@libp2p/interface-connection';
+import type { Direction, Stream } from '@libp2p/interface-connection';
 import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer';
 import type { Duplex } from 'it-stream-types';
 import type { OpenStreamFunc, Stream as SRPCStream } from './stream.js';
 import { Client } from './client.js';
 export interface ConnParams {
     muxerFactory?: StreamMuxerFactory;
+    direction?: Direction;
 }
 export interface StreamHandler {
     handleStream(strm: Duplex<Uint8Array>): void;

package/dist/srpc/conn.js

@@ -15,6 +15,7 @@ export class Conn {
         }
         this.muxer = muxerFactory.createStreamMuxer({
             onIncomingStream: this.handleIncomingStream.bind(this),
+            direction: connParams?.direction || 'outbound',
         });
     }
     // sink returns the message sink.

package/dist/srpc/websocket.d.ts

@@ -1,8 +1,9 @@
+import { Direction } from '@libp2p/interface-connection';
 import type WebSocket from 'isomorphic-ws';
 import { Conn } from './conn.js';
 import { Server } from './server.js';
 export declare class WebSocketConn extends Conn {
     private socket;
-    constructor(socket: WebSocket, server?: Server);
+    constructor(socket: WebSocket, direction: Direction, server?: Server);
     getSocket(): WebSocket;
 }

package/dist/srpc/websocket.js

@@ -4,8 +4,9 @@ import { Mplex } from '@libp2p/mplex';
 import { Conn } from './conn.js';
 // WebSocketConn implements a connection with a WebSocket and optional Server.
 export class WebSocketConn extends Conn {
-    constructor(socket, server) {
+    constructor(socket, direction, server) {
         super(server, {
+            direction,
             muxerFactory: new Mplex(),
         });
         this.socket = socket;

package/e2e/e2e.ts

@@ -10,7 +10,7 @@ async function runRPC() {
   mux.register(createHandler(EchoerDefinition, echoer))
 
   const clientConn = new Conn()
-  const serverConn = new Conn(server)
+  const serverConn = new Conn(server, {direction: 'inbound'})
   pipe(clientConn, serverConn, clientConn)
   const client = new Client(clientConn.buildOpenStreamFunc())
 

package/e2e/e2e_test.go

@@ -32,14 +32,16 @@ func RunE2E(t *testing.T, cb func(client echo.SRPCEchoerClient) error) {
 	// construct the client
 	clientPipe, serverPipe := net.Pipe()
 
-	clientMp, err := mp.NewMultiplex(clientPipe, false, nil)
+	// outbound=true
+	clientMp, err := mp.NewMultiplex(clientPipe, true, nil)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	client := srpc.NewClientWithMuxedConn(mplex.NewMuxedConn(clientMp))
 
 	ctx := context.Background()
-	serverMp, _ := mp.NewMultiplex(serverPipe, true, nil)
+	// outbound=false
+	serverMp, _ := mp.NewMultiplex(serverPipe, false, nil)
 	go func() {
 		_ = server.AcceptMuxedConn(ctx, mplex.NewMuxedConn(serverMp))
 	}()

package/echo/server.go

@@ -21,6 +21,11 @@ func NewEchoServer(rpcStreamMux srpc.Mux) *EchoServer {
 	return &EchoServer{rpcStreamMux: rpcStreamMux}
 }
 
+// Register registers the Echo server with the Mux.
+func (e *EchoServer) Register(mux srpc.Mux) error {
+	return SRPCRegisterEchoer(mux, e)
+}
+
 // Echo implements echo.SRPCEchoerServer
 func (*EchoServer) Echo(ctx context.Context, msg *EchoMsg) (*EchoMsg, error) {
 	return proto.Clone(msg).(*EchoMsg), nil

package/go.mod

@@ -13,7 +13,7 @@ require (
 require (
 	github.com/libp2p/go-libp2p v0.20.1-0.20220622205512-3cf611ad8c9c
 	github.com/libp2p/go-libp2p-core v0.19.0
-	github.com/libp2p/go-mplex v0.7.0
+	github.com/libp2p/go-mplex v0.7.1-0.20220702225122-8cbdf39b21f5
 	github.com/sirupsen/logrus v1.8.2-0.20220112234510-85981c045988
 )
 

package/go.sum

@@ -67,8 +67,8 @@ github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoR
 github.com/libp2p/go-libp2p-core v0.19.0 h1:KDw7hanmh0EuVdZqsHCAzmkdiYMk5uR5h0UGSCVTxSU=
 github.com/libp2p/go-libp2p-core v0.19.0/go.mod h1:AkA+FUKQfYt1FLNef5fOPlo/naAWjKy/RCjkcPjqzYg=
 github.com/libp2p/go-libp2p-testing v0.10.0 h1:LO7wuUPPNAe1D1s0HZ+9WoROaGIn/MEl1wtugXuTRzg=
-github.com/libp2p/go-mplex v0.7.0 h1:BDhFZdlk5tbr0oyFq/xv/NPGfjbnrsDam1EvutpBDbY=
-github.com/libp2p/go-mplex v0.7.0/go.mod h1:rW8ThnRcYWft/Jb2jeORBmPd6xuG3dGxWN/W168L9EU=
+github.com/libp2p/go-mplex v0.7.1-0.20220702225122-8cbdf39b21f5 h1:ik8jmF64ZDxAn5K9zJ74ZHed6SBoomwcrP+p6QT7OOQ=
+github.com/libp2p/go-mplex v0.7.1-0.20220702225122-8cbdf39b21f5/go.mod h1:rW8ThnRcYWft/Jb2jeORBmPd6xuG3dGxWN/W168L9EU=
 github.com/libp2p/go-openssl v0.0.7 h1:eCAzdLejcNVBzP/iZM9vqHnQm+XyCEbSSIheIPRGNsw=
 github.com/libp2p/go-openssl v0.0.7/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=

package/integration/integration.ts

@@ -6,7 +6,7 @@ async function runRPC() {
   const addr = 'ws://localhost:5000/demo'
   console.log(`Connecting to ${addr}`)
   const ws = new WebSocket(addr)
-  const channel = new WebSocketConn(ws)
+  const channel = new WebSocketConn(ws, 'outbound')
   const client = channel.buildClient()
 
   console.log('Running client test via WebSocket..')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.8.3",
+  "version": "0.8.6",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/accept.go

@@ -15,7 +15,7 @@ func AcceptMuxedListener(ctx context.Context, lis net.Listener, srv *Server) err
 			return err
 		}
 
-		mc, err := NewMuxedConn(nc, true)
+		mc, err := NewMuxedConn(nc, false)
 		if err != nil {
 			_ = nc.Close()
 			continue

package/srpc/client-rpc.go

@@ -2,6 +2,7 @@ package srpc
 
 import (
 	"context"
+	"io"
 
 	"github.com/pkg/errors"
 )
@@ -86,6 +87,24 @@ func (r *ClientRPC) ReadAll() ([][]byte, error) {
 	}
 }
 
+// ReadOne reads a single message and returns.
+//
+// returns io.EOF if the stream ended.
+func (r *ClientRPC) ReadOne() ([]byte, error) {
+	select {
+	case <-r.ctx.Done():
+		return nil, context.Canceled
+	case data, ok := <-r.dataCh:
+		if !ok {
+			if err := r.serverErr; err != nil {
+				return nil, err
+			}
+			return nil, io.EOF
+		}
+		return data, nil
+	}
+}
+
 // Context is canceled when the ClientRPC is no longer valid.
 func (r *ClientRPC) Context() context.Context {
 	return r.ctx

package/srpc/client.go

@@ -2,7 +2,6 @@ package srpc
 
 import (
 	"context"
-	"io"
 
 	"github.com/pkg/errors"
 )
@@ -55,17 +54,12 @@ func (c *client) Invoke(rctx context.Context, service, method string, in, out Me
 	if err := clientRPC.Start(writer, true, firstMsg); err != nil {
 		return err
 	}
-	msgs, err := clientRPC.ReadAll()
+	msg, err := clientRPC.ReadOne()
 	if err != nil {
 		// this includes any server returned error.
 		return err
 	}
-	if len(msgs) == 0 {
-		// no reply? return eof.
-		return io.EOF
-	}
-	// parse first message to out
-	if err := out.UnmarshalVT(msgs[0]); err != nil {
+	if err := out.UnmarshalVT(msg); err != nil {
 		return errors.Wrap(ErrInvalidMessage, err.Error())
 	}
 	// done

package/srpc/conn.ts

@@ -1,4 +1,4 @@
-import type { Stream } from '@libp2p/interface-connection'
+import type { Direction, Stream } from '@libp2p/interface-connection'
 import type {
   StreamMuxer,
   StreamMuxerFactory,
@@ -13,6 +13,9 @@ import { Client } from './client.js'
 export interface ConnParams {
   // muxerFactory overrides using the default factory (@libp2p/mplex).
   muxerFactory?: StreamMuxerFactory
+  // direction is the muxer connection direction.
+  // defaults to outbound.
+  direction?: Direction
 }
 
 // StreamHandler handles incoming streams.
@@ -42,6 +45,7 @@ export class Conn implements Duplex<Uint8Array> {
     }
     this.muxer = muxerFactory.createStreamMuxer({
       onIncomingStream: this.handleIncomingStream.bind(this),
+      direction: connParams?.direction || 'outbound',
     })
   }
 

package/srpc/muxed-conn.go

@@ -2,6 +2,7 @@ package srpc
 
 import (
 	"context"
+	"io"
 	"net"
 
 	"github.com/libp2p/go-libp2p-core/network"
@@ -9,9 +10,9 @@ import (
 	mp "github.com/libp2p/go-mplex"
 )
 
-// NewMuxedConn constructs a new MuxedConn from a Conn.
-func NewMuxedConn(conn net.Conn, isServer bool) (network.MuxedConn, error) {
-	m, err := mp.NewMultiplex(conn, isServer, nil)
+// NewMuxedConn constructs a new MuxedConn from a ReadWriteCloser.
+func NewMuxedConn(conn io.ReadWriteCloser, outbound bool) (network.MuxedConn, error) {
+	m, err := mp.NewMultiplex(conn, outbound, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -21,8 +22,8 @@ func NewMuxedConn(conn net.Conn, isServer bool) (network.MuxedConn, error) {
 // NewClientWithConn constructs the muxer and the client.
 //
 // uses libp2p mplex
-func NewClientWithConn(conn net.Conn, isServer bool) (Client, error) {
-	mconn, err := NewMuxedConn(conn, isServer)
+func NewClientWithConn(conn net.Conn, outbound bool) (Client, error) {
+	mconn, err := NewMuxedConn(conn, outbound)
 	if err != nil {
 		return nil, err
 	}

package/srpc/packet-rw.go

@@ -35,7 +35,15 @@ func (r *PacketReaderWriter) WritePacket(p *Packet) error {
 	if err != nil {
 		return err
 	}
-	_, err = r.rw.Write(data)
+	var n int
+	written := 0
+	for written < len(data) {
+		n, err = r.rw.Write(data)
+		if err != nil {
+			return err
+		}
+		written += n
+	}
 	return err
 }
 

package/srpc/server-rpc.go

@@ -2,6 +2,7 @@ package srpc
 
 import (
 	"context"
+	"io"
 
 	"github.com/pkg/errors"
 )
@@ -66,12 +67,19 @@ func (r *ServerRPC) Wait(ctx context.Context) error {
 
 // HandleStreamClose handles the incoming stream closing w/ optional error.
 func (r *ServerRPC) HandleStreamClose(closeErr error) {
+	if r.dataChClosed {
+		return
+	}
 	if closeErr != nil {
 		if r.clientErr == nil {
 			r.clientErr = closeErr
 		}
-		r.Close()
+		if closeErr != io.EOF && closeErr != context.Canceled {
+			r.Close()
+		}
 	}
+	r.dataChClosed = true
+	close(r.dataCh)
 }
 
 // HandlePacket handles an incoming parsed message packet.
@@ -163,8 +171,8 @@ func (r *ServerRPC) invokeRPC() {
 	}
 	outPkt := NewCallDataPacket(nil, false, true, err)
 	_ = r.writer.WritePacket(outPkt)
-	r.ctxCancel()
 	_ = r.writer.Close()
+	r.ctxCancel()
 }
 
 // Close releases any resources held by the ServerRPC.
@@ -173,9 +181,9 @@ func (r *ServerRPC) Close() {
 	if r.clientErr == nil {
 		r.clientErr = context.Canceled
 	}
-	r.ctxCancel()
 	if r.service == "" {
 		// invokeRPC has not been called, otherwise it would call Close()
 		_ = r.writer.Close()
 	}
+	r.ctxCancel()
 }

package/srpc/websocket.ts

@@ -1,6 +1,7 @@
 import { duplex } from 'it-ws'
 import { pipe } from 'it-pipe'
 import { Mplex } from '@libp2p/mplex'
+import { Direction } from '@libp2p/interface-connection'
 import type WebSocket from 'isomorphic-ws'
 
 import { Conn } from './conn.js'
@@ -11,8 +12,9 @@ export class WebSocketConn extends Conn {
   // socket is the web socket
   private socket: WebSocket
 
-  constructor(socket: WebSocket, server?: Server) {
+  constructor(socket: WebSocket, direction: Direction, server?: Server) {
     super(server, {
+      direction,
       muxerFactory: new Mplex(),
     })
     this.socket = socket