starpc 0.3.5 → 0.4.1

package/srpc/common-rpc.ts

@@ -1,8 +1,8 @@
 import type { Source, Sink } from 'it-stream-types'
 import { pushable } from 'it-pushable'
 
-import type { CallData, CallStart } from './rpcproto.js'
-import { Packet } from './rpcproto.js'
+import type { CallData, CallStart } from './rpcproto.pb.js'
+import { Packet } from './rpcproto.pb.js'
 
 // CommonRPC is common logic between server and client RPCs.
 export class CommonRPC {

package/srpc/conn-duplex.ts

@@ -18,7 +18,7 @@ export class DuplexConn extends Conn {
   ) {
     super(server, connParams)
     this.channel = duplex
-    pipe(this, this.channel, this)
+    pipe(this.channel, this, this.channel)
   }
 
   // getChannelDuplex returns the Duplex channel.

package/srpc/conn.ts

@@ -19,7 +19,7 @@ export interface ConnParams {
 // Implemented by Server.
 export interface StreamHandler {
   // handleStream handles an incoming stream.
-  handleStream(strm: Duplex<Uint8Array>): Promise<void>
+  handleStream(strm: Duplex<Uint8Array>): void
 }
 
 // Conn implements a generic connection with a two-way stream.

package/srpc/handler.ts

@@ -84,28 +84,34 @@ export function createInvokeFn(
     })
 
     // pipe responseSink to dataSink.
-    const responsePipe = pipe(
+    pipe(
       responseSink,
       buildEncodeMessageTransform(methodInfo.responseType),
       dataSink
     )
 
+    // requestSource is a Source of decoded request messages.
+    const requestSource = pipe(dataSource, requestDecode)
+
     // build the request argument.
     let requestArg: any
     if (methodInfo.requestStream) {
-      // requestSource is a Source of decoded request messages.
-      const requestSource = pipe(dataSource, requestDecode)
       // convert the request data source into an Observable<T>
       requestArg = observableFrom(requestSource)
     } else {
       // receive a single message for the argument.
-      const requestRx = requestDecode(dataSource)
-      for await (const msg of requestRx) {
-        requestArg = msg
-        break
+      for await (const msg of requestSource) {
+        if (msg) {
+          requestArg = msg
+          break
+        }
       }
     }
 
+    if (!requestArg) {
+      throw new Error('request object was empty')
+    }
+
     // Call the implementation.
     try {
       const responseObj = methodProto(requestArg)
@@ -128,9 +134,7 @@ export function createInvokeFn(
             },
             complete: () => {
               responseSink.end()
-              responsePipe.finally(() => {
-                resolve()
-              })
+              resolve()
             },
           })
         })

package/srpc/index.ts

@@ -1,4 +1,4 @@
-export type { OpenStreamFunc } from './stream.js'
+export type { PacketHandler, Stream, OpenStreamFunc } from './stream.js'
 export { Client } from './client.js'
 export { Server } from './server.js'
 export { Conn, ConnParams } from './conn.js'
@@ -9,9 +9,9 @@ export {
   newBroadcastChannelIterable,
   BroadcastChannelConn,
 } from './broadcast-channel.js'
-
 export {
   MessagePortIterable,
   newMessagePortIterable,
   MessagePortConn,
 } from './message-port.js'
+export { ObservableSource } from './observable-source.js'

package/srpc/{rpc-stream.go → msg-stream.go}

@@ -5,8 +5,8 @@ import (
 	"io"
 )
 
-// RPCStream implements the stream interface passed to implementations.
-type RPCStream struct {
+// MsgStream implements the stream interface passed to implementations.
+type MsgStream struct {
 	// ctx is the stream context
 	ctx context.Context
 	// writer is the stream writer
@@ -15,10 +15,10 @@ type RPCStream struct {
 	dataCh chan []byte
 }
 
-// NewRPCStream constructs a new Stream with a ClientRPC.
+// NewMsgStream constructs a new Stream with a ClientRPC.
 // dataCh should be closed when no more messages will arrive.
-func NewRPCStream(ctx context.Context, writer Writer, dataCh chan []byte) *RPCStream {
-	return &RPCStream{
+func NewMsgStream(ctx context.Context, writer Writer, dataCh chan []byte) *MsgStream {
+	return &MsgStream{
 		ctx:    ctx,
 		writer: writer,
 		dataCh: dataCh,
@@ -26,12 +26,12 @@ func NewRPCStream(ctx context.Context, writer Writer, dataCh chan []byte) *RPCSt
 }
 
 // Context is canceled when the Stream is no longer valid.
-func (r *RPCStream) Context() context.Context {
+func (r *MsgStream) Context() context.Context {
 	return r.ctx
 }
 
 // MsgSend sends the message to the remote.
-func (r *RPCStream) MsgSend(msg Message) error {
+func (r *MsgStream) MsgSend(msg Message) error {
 	select {
 	case <-r.ctx.Done():
 		return context.Canceled
@@ -42,13 +42,13 @@ func (r *RPCStream) MsgSend(msg Message) error {
 	if err != nil {
 		return err
 	}
-	outPkt := NewCallDataPacket(msgData, false, nil)
+	outPkt := NewCallDataPacket(msgData, len(msgData) == 0, false, nil)
 	return r.writer.WritePacket(outPkt)
 }
 
 // MsgRecv receives an incoming message from the remote.
 // Parses the message into the object at msg.
-func (r *RPCStream) MsgRecv(msg Message) error {
+func (r *MsgStream) MsgRecv(msg Message) error {
 	select {
 	case <-r.Context().Done():
 		return context.Canceled
@@ -61,16 +61,16 @@ func (r *RPCStream) MsgRecv(msg Message) error {
 }
 
 // CloseSend signals to the remote that we will no longer send any messages.
-func (r *RPCStream) CloseSend() error {
-	outPkt := NewCallDataPacket(nil, true, nil)
+func (r *MsgStream) CloseSend() error {
+	outPkt := NewCallDataPacket(nil, false, true, nil)
 	return r.writer.WritePacket(outPkt)
 }
 
 // Close closes the stream.
-func (r *RPCStream) Close() error {
+func (r *MsgStream) Close() error {
 	_ = r.writer.Close()
 	return nil
 }
 
 // _ is a type assertion
-var _ Stream = ((*RPCStream)(nil))
+var _ Stream = ((*MsgStream)(nil))

package/srpc/muxed-conn.go

@@ -0,0 +1,31 @@
+package srpc
+
+import (
+	"context"
+
+	"github.com/libp2p/go-libp2p-core/network"
+)
+
+// NewClientWithMuxedConn constructs a new client with a MuxedConn.
+func NewClientWithMuxedConn(conn network.MuxedConn) Client {
+	openStreamFn := NewOpenStreamWithMuxedConn(conn)
+	return NewClient(openStreamFn)
+}
+
+// NewOpenStreamWithMuxedConn constructs a OpenStream func with a MuxedConn.
+func NewOpenStreamWithMuxedConn(conn network.MuxedConn) OpenStreamFunc {
+	return func(ctx context.Context, msgHandler PacketHandler) (Writer, error) {
+		mstrm, err := conn.OpenStream(ctx)
+		if err != nil {
+			return nil, err
+		}
+		rw := NewPacketReadWriter(mstrm, msgHandler)
+		go func() {
+			err := rw.ReadPump()
+			if err != nil {
+				_ = rw.Close()
+			}
+		}()
+		return rw, nil
+	}
+}

package/srpc/observable-source.ts

@@ -0,0 +1,40 @@
+import { Source } from 'it-stream-types'
+import { pushable, Pushable } from 'it-pushable'
+import { Observable, Subscription } from 'rxjs'
+
+// ObservableSource wraps an Observable into a Source.
+export class ObservableSource<T> {
+  // source is the source for observable objects.
+  public readonly source: Source<T>
+  // _source emits incoming data to the source.
+  private readonly _source: {
+    push: (val: T) => void
+    end: (err?: Error) => void
+  }
+  // subscription is the observable subscription
+  private readonly subscription: Subscription
+
+  constructor(observable: Observable<T>) {
+    const source: Pushable<T> = pushable({ objectMode: true })
+    this.source = source
+    this._source = source
+
+    this.subscription = observable.subscribe({
+      next: (value: T) => {
+        this._source.push(value)
+      },
+      error: (err) => {
+        this._source.end(err)
+      },
+      complete: () => {
+        this._source.end()
+      },
+    })
+  }
+
+  // close closes the subscription.
+  public close(err?: Error) {
+    this._source.end(err)
+    this.subscription.unsubscribe()
+  }
+}

package/srpc/packet.go

@@ -16,12 +16,13 @@ func (p *Packet) Validate() error {
 }
 
 // NewCallStartPacket constructs a new CallStart packet.
-func NewCallStartPacket(service, method string, data []byte) *Packet {
+func NewCallStartPacket(service, method string, data []byte, dataIsZero bool) *Packet {
 	return &Packet{Body: &Packet_CallStart{
 		CallStart: &CallStart{
 			RpcService: service,
 			RpcMethod:  method,
 			Data:       data,
+			DataIsZero: dataIsZero,
 		},
 	}}
 }
@@ -40,7 +41,7 @@ func (p *CallStart) Validate() error {
 }
 
 // NewCallDataPacket constructs a new CallData packet.
-func NewCallDataPacket(data []byte, complete bool, err error) *Packet {
+func NewCallDataPacket(data []byte, dataIsZero bool, complete bool, err error) *Packet {
 	var errStr string
 	if err != nil {
 		errStr = err.Error()
@@ -48,7 +49,7 @@ func NewCallDataPacket(data []byte, complete bool, err error) *Packet {
 	return &Packet{Body: &Packet_CallData{
 		CallData: &CallData{
 			Data:       data,
-			DataIsZero: len(data) == 0 && !complete && err == nil,
+			DataIsZero: dataIsZero,
 			Complete:   err != nil || complete,
 			Error:      errStr,
 		},

package/srpc/packet.ts

@@ -4,7 +4,7 @@ import {
   decode as lengthPrefixDecode,
 } from 'it-length-prefixed'
 
-import { Packet } from './rpcproto.js'
+import { Packet } from './rpcproto.pb.js'
 import {
   buildDecodeMessageTransform,
   buildEncodeMessageTransform,

package/srpc/server-pipe.go

@@ -9,7 +9,7 @@ import (
 // Stream with the given Server. Starts read pumps for both. Starts the
 // HandleStream function on the server in a separate goroutine.
 func NewServerPipe(server *Server) OpenStreamFunc {
-	return func(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error) {
+	return func(ctx context.Context, msgHandler PacketHandler) (Writer, error) {
 		srvPipe, clientPipe := net.Pipe()
 		go func() {
 			_ = server.HandleStream(ctx, srvPipe)

package/srpc/server-rpc.go

@@ -133,12 +133,12 @@ func (r *ServerRPC) HandleCallData(pkt *CallData) error {
 func (r *ServerRPC) invokeRPC() {
 	// ctx := r.ctx
 	serviceID, methodID := r.service, r.method
-	strm := NewRPCStream(r.ctx, r.writer, r.dataCh)
+	strm := NewMsgStream(r.ctx, r.writer, r.dataCh)
 	ok, err := r.mux.InvokeMethod(serviceID, methodID, strm)
 	if err == nil && !ok {
 		err = ErrUnimplemented
 	}
-	outPkt := NewCallDataPacket(nil, true, err)
+	outPkt := NewCallDataPacket(nil, false, true, err)
 	_ = r.writer.WritePacket(outPkt)
 	r.ctxCancel()
 	_ = r.writer.Close()
@@ -149,7 +149,7 @@ func (r *ServerRPC) invokeRPC() {
 func (r *ServerRPC) Close() {
 	r.ctxCancel()
 	if r.service == "" {
-		// invokeRPC has not been called
+		// invokeRPC has not been called, otherwise it would call Close()
 		_ = r.writer.Close()
 	}
 }

package/srpc/server-rpc.ts

@@ -1,6 +1,6 @@
 import type { Sink } from 'it-stream-types'
 
-import type { CallData, CallStart } from './rpcproto.js'
+import type { CallData, CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
 import { InvokeFn } from './handler.js'
 import { Mux } from './mux.js'

package/srpc/server.go

@@ -20,6 +20,11 @@ func NewServer(mux Mux) *Server {
 	}
 }
 
+// GetMux returns the mux.
+func (s *Server) GetMux() Mux {
+	return s.mux
+}
+
 // HandleStream handles an incoming ReadWriteCloser stream.
 func (s *Server) HandleStream(ctx context.Context, rwc io.ReadWriteCloser) error {
 	subCtx, subCtxCancel := context.WithCancel(ctx)
@@ -27,7 +32,9 @@ func (s *Server) HandleStream(ctx context.Context, rwc io.ReadWriteCloser) error
 	serverRPC := NewServerRPC(subCtx, s.mux)
 	prw := NewPacketReadWriter(rwc, serverRPC.HandlePacket)
 	serverRPC.SetWriter(prw)
-	return prw.ReadPump()
+	err := prw.ReadPump()
+	_ = rwc.Close()
+	return err
 }
 
 // AcceptMuxedConn runs a loop which calls Accept on a muxer to handle streams.

package/srpc/server.ts

@@ -4,7 +4,7 @@ import { pipe } from 'it-pipe'
 
 import { Mux } from './mux.js'
 import { ServerRPC } from './server-rpc.js'
-import { Packet } from './rpcproto.js'
+import { Packet } from './rpcproto.pb.js'
 import {
   parseLengthPrefixTransform,
   prependLengthPrefixTransform,
@@ -29,15 +29,14 @@ export class Server implements StreamHandler {
   }
 
   // handleStream handles an incoming Uint8Array message duplex.
-  // closes the stream when the rpc completes.
-  public handleStream(stream: Stream): Promise<void> {
+  public handleStream(stream: Stream): ServerRPC {
     return this.handleDuplex(stream)
   }
 
   // handleDuplex handles an incoming message duplex.
-  public async handleDuplex(stream: Duplex<Uint8Array>): Promise<void> {
+  public handleDuplex(stream: Duplex<Uint8Array>): ServerRPC {
     const rpc = this.startRpc()
-    await pipe(
+    pipe(
       stream,
       parseLengthPrefixTransform(),
       decodePacketSource,
@@ -46,11 +45,13 @@ export class Server implements StreamHandler {
       prependLengthPrefixTransform(),
       stream
     )
+    return rpc
   }
 
   // handlePacketStream handles an incoming Packet duplex.
-  public async handlePacketStream(stream: Duplex<Packet>): Promise<void> {
+  public handlePacketStream(stream: Duplex<Packet>): ServerRPC {
     const rpc = this.startRpc()
-    await pipe(stream, rpc, stream)
+    pipe(stream, rpc, stream)
+    return rpc
   }
 }

package/srpc/stream.ts

@@ -1,4 +1,4 @@
-import type { Packet } from './rpcproto'
+import type { Packet } from './rpcproto.pb.js'
 import type { Duplex } from 'it-stream-types'
 
 // PacketHandler handles incoming packets.

package/srpc/websocket.go

@@ -43,7 +43,7 @@ func (w *WebSocketConn) AcceptStream() (io.ReadWriteCloser, error) {
 }
 
 // OpenStream tries to open a stream with the remote.
-func (w *WebSocketConn) OpenStream(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error) {
+func (w *WebSocketConn) OpenStream(ctx context.Context, msgHandler PacketHandler) (Writer, error) {
 	muxedStream, err := w.mconn.OpenStream(ctx)
 	if err != nil {
 		return nil, err
@@ -63,6 +63,3 @@ func (w *WebSocketConn) OpenStream(ctx context.Context, msgHandler func(pkt *Pac
 func (w *WebSocketConn) Close() error {
 	return w.conn.Close(websocket.StatusGoingAway, "conn closed")
 }
-
-// _ is a type assertion
-var _ Conn = ((*WebSocketConn)(nil))

package/srpc/websocket.ts

@@ -17,7 +17,7 @@ export class WebSocketConn extends Conn {
     })
     this.socket = socket
     const socketDuplex = duplex(socket)
-    pipe(this.source, socketDuplex, this.sink)
+    pipe(socketDuplex, this, socketDuplex)
   }
 
   // getSocket returns the websocket.

package/srpc/conn.go

@@ -1,7 +0,0 @@
-package srpc
-
-// Conn represents a connection to a remote.
-type Conn interface {
-	// GetOpenStreamFunc returns the OpenStream func.
-	GetOpenStreamFunc() OpenStreamFunc
-}