starpc 0.12.1 → 0.12.2

package/dist/srpc/conn.js

@@ -1,5 +1,5 @@
 import { pipe } from 'it-pipe';
-import { Mplex } from '@libp2p/mplex';
+import { mplex } from '@libp2p/mplex';
 import isPromise from 'is-promise';
 import { Client } from './client.js';
 import { combineUint8ArrayListTransform } from './array-list.js';
@@ -21,7 +21,7 @@ export class Conn {
         }
         let muxerFactory = connParams?.muxerFactory;
         if (!muxerFactory) {
-            muxerFactory = new Mplex();
+            muxerFactory = mplex()();
         }
         this.muxer = muxerFactory.createStreamMuxer({
             onIncomingStream: this.handleIncomingStream.bind(this),

package/dist/srpc/websocket.js

@@ -1,13 +1,13 @@
 import { duplex } from 'it-ws';
 import { pipe } from 'it-pipe';
-import { Mplex } from '@libp2p/mplex';
+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, direction, server) {
         super(server, {
             direction,
-            muxerFactory: new Mplex(),
+            muxerFactory: mplex()(),
         });
         this.socket = socket;
         const socketDuplex = duplex(socket);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -63,32 +63,32 @@
     "@typescript-eslint/parser": "^5.40.0",
     "bufferutil": "^4.0.6",
     "depcheck": "^1.4.3",
-    "esbuild": "^0.15.10",
+    "esbuild": "^0.15.11",
     "eslint": "^8.25.0",
     "eslint-config-prettier": "^8.5.0",
     "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
-    "ts-proto": "^1.126.1",
+    "ts-proto": "^1.128.0",
     "typescript": "^4.8.4",
     "utf-8-validate": "^5.0.9"
   },
   "dependencies": {
     "@libp2p/interface-connection": "^3.0.2",
     "@libp2p/interface-stream-muxer": "^3.0.0",
-    "@libp2p/mplex": "^6.0.2",
+    "@libp2p/mplex": "^7.0.0",
     "event-iterator": "^2.0.0",
     "is-promise": "^4.0.0",
     "isomorphic-ws": "^5.0.0",
     "it-first": "^1.0.7",
-    "it-length-prefixed": "^8.0.2",
+    "it-length-prefixed": "^8.0.3",
     "it-pipe": "^2.0.4",
     "it-pushable": "^3.1.0",
     "it-stream-types": "^1.0.4",
-    "it-ws": "^5.0.2",
+    "it-ws": "^5.0.3",
     "long": "^5.2.0",
     "patch-package": "^6.4.7",
     "protobufjs": "^7.1.2",
-    "uint8arraylist": "^2.3.2",
+    "uint8arraylist": "^2.3.3",
     "ws": "^8.9.0"
   }
 }

package/srpc/client-set.go

@@ -0,0 +1,79 @@
+package srpc
+
+import (
+	"context"
+	"errors"
+)
+
+// ClientSet wraps a list of clients into one Client.
+type ClientSet struct {
+	clients []Client
+}
+
+// NewClientSet constructs a new client set.
+func NewClientSet(clients []Client) *ClientSet {
+	return &ClientSet{clients: clients}
+}
+
+// ExecCall executes a request/reply RPC with the remote.
+func (c *ClientSet) ExecCall(
+	ctx context.Context,
+	service, method string,
+	in, out Message,
+) error {
+	return c.execCall(ctx, func(client Client) error {
+		return client.ExecCall(ctx, service, method, in, out)
+	})
+}
+
+// NewStream starts a streaming RPC with the remote & returns the stream.
+// firstMsg is optional.
+func (c *ClientSet) NewStream(
+	ctx context.Context,
+	service, method string,
+	firstMsg Message,
+) (Stream, error) {
+	var strm Stream
+	err := c.execCall(ctx, func(client Client) error {
+		var err error
+		strm, err = client.NewStream(ctx, service, method, firstMsg)
+		return err
+	})
+	return strm, err
+}
+
+// execCall executes the call conditionally retrying against subsequent client handles.
+func (c *ClientSet) execCall(ctx context.Context, doCall func(client Client) error) error {
+	var any bool
+	for _, client := range c.clients {
+		if client == nil {
+			continue
+		}
+		err := doCall(client)
+		any = true
+		if err == nil {
+			return nil
+		}
+		if err == context.Canceled {
+			select {
+			case <-ctx.Done():
+				return context.Canceled
+			default:
+				continue
+			}
+		}
+		if err.Error() == ErrUnimplemented.Error() {
+			continue
+		}
+		return err
+	}
+
+	if !any {
+		return errors.New("no available rpc clients")
+	}
+
+	return ErrUnimplemented
+}
+
+// _ is a type assertion
+var _ Client = ((*ClientSet)(nil))

package/srpc/conn.ts

@@ -5,7 +5,7 @@ import type {
 } from '@libp2p/interface-stream-muxer'
 import { pipe } from 'it-pipe'
 import type { Duplex } from 'it-stream-types'
-import { Mplex } from '@libp2p/mplex'
+import { mplex } from '@libp2p/mplex'
 import { Uint8ArrayList } from 'uint8arraylist'
 import isPromise from 'is-promise'
 
@@ -55,7 +55,7 @@ export class Conn implements Duplex<Uint8Array> {
     }
     let muxerFactory = connParams?.muxerFactory
     if (!muxerFactory) {
-      muxerFactory = new Mplex()
+      muxerFactory = mplex()()
     }
     this.muxer = muxerFactory.createStreamMuxer({
       onIncomingStream: this.handleIncomingStream.bind(this),

package/srpc/websocket.ts

@@ -1,6 +1,6 @@
 import { duplex } from 'it-ws'
 import { pipe } from 'it-pipe'
-import { Mplex } from '@libp2p/mplex'
+import { mplex } from '@libp2p/mplex'
 import { Direction } from '@libp2p/interface-connection'
 import type WebSocket from 'isomorphic-ws'
 
@@ -15,7 +15,7 @@ export class WebSocketConn extends Conn {
   constructor(socket: WebSocket, direction: Direction, server?: Server) {
     super(server, {
       direction,
-      muxerFactory: new Mplex(),
+      muxerFactory: mplex()(),
     })
     this.socket = socket
     const socketDuplex = duplex(socket)