starpc 0.18.2 → 0.19.0

package/srpc/server.ts

@@ -25,8 +25,9 @@ export class Server implements StreamHandler {
   }
 
   // rpcStreamHandler implements the RpcStreamHandler interface.
+  // uses handlePacketDuplex (expects 1 buf = 1 Packet)
   public get rpcStreamHandler(): RpcStreamHandler {
-    return this.handleStream.bind(this)
+    return this.handlePacketStream.bind(this)
   }
 
   // startRpc starts a new server-side RPC.
@@ -35,13 +36,10 @@ export class Server implements StreamHandler {
     return new ServerRPC(this.lookupMethod)
   }
 
-  // handleStream handles an incoming Uint8Array message duplex.
-  public handleStream(stream: Stream): ServerRPC {
-    return this.handleDuplex(stream)
-  }
-
-  // handleDuplex handles an incoming message duplex.
-  public handleDuplex(stream: Duplex<Uint8Array, Uint8Array>): ServerRPC {
+  // handleFragmentStream handles an incoming stream.
+  // assumes that stream does not maintain packet framing.
+  // uses length-prefixed packets for packet framing.
+  public handleFragmentStream(stream: Stream): ServerRPC {
     const rpc = this.startRpc()
     pipe(
       stream,
@@ -57,16 +55,16 @@ export class Server implements StreamHandler {
     return rpc
   }
 
-  // handlePacketDuplex handles an incoming Uint8Array duplex.
-  // skips the packet length prefix transform.
-  public handlePacketDuplex(stream: Duplex<Uint8Array>): ServerRPC {
+  // handlePacketStream handles an incoming Uint8Array duplex.
+  // the stream has one Uint8Array per packet w/o length prefix.
+  public handlePacketStream(stream: Stream): ServerRPC {
     const rpc = this.startRpc()
     pipe(stream, decodePacketSource, rpc, encodePacketSource, stream)
     return rpc
   }
 
-  // handlePacketStream handles an incoming Packet duplex.
-  public handlePacketStream(stream: Duplex<Packet>): ServerRPC {
+  // handlePacketDuplex handles an incoming Packet duplex.
+  public handlePacketDuplex(stream: Duplex<Packet>): ServerRPC {
     const rpc = this.startRpc()
     pipe(stream, rpc, stream)
     return rpc

package/srpc/stream-rwc.go

@@ -0,0 +1,85 @@
+package srpc
+
+import (
+	"bytes"
+	"io"
+)
+
+// StreamRwc implements an io.ReadWriteCloser with a srpc.Stream.
+type StreamRwc struct {
+	// Stream is the base stream interface.
+	Stream
+
+	// buf is the incoming data buffer
+	buf bytes.Buffer
+	// readMsg is the raw read message
+	readMsg RawMessage
+	// writeMsg is the raw write message
+	writeMsg RawMessage
+}
+
+// NewStreamRwc constructs a new stream read write closer.
+func NewStreamRwc(strm Stream) *StreamRwc {
+	rwc := &StreamRwc{Stream: strm}
+	rwc.readMsg.copy = true
+	rwc.writeMsg.copy = true
+	return rwc
+}
+
+// Read reads data from the stream to p.
+// Implements io.Reader.
+func (s *StreamRwc) Read(p []byte) (n int, err error) {
+	readBuf := p
+	for len(readBuf) != 0 && err == nil {
+		var rn int
+
+		// if the buffer has data, read from it.
+		if s.buf.Len() != 0 {
+			rn, err = s.buf.Read(readBuf)
+		} else {
+			if n != 0 {
+				// if we read data to p already, return now.
+				break
+			}
+
+			s.readMsg.Clear()
+			if err := s.Stream.MsgRecv(&s.readMsg); err != nil {
+				return n, err
+			}
+			data := s.readMsg.GetData()
+			if len(data) == 0 {
+				continue
+			}
+
+			// read as much as possible directly to the output
+			copy(readBuf, data)
+			if len(data) > len(readBuf) {
+				// we read some of the data, buffer the rest.
+				rn = len(readBuf)
+				_, _ = s.buf.Write(data[rn:]) // never returns an error
+			} else {
+				// we read all of data
+				rn = len(data)
+			}
+		}
+
+		// advance readBuf by rn
+		n += rn
+		readBuf = readBuf[rn:]
+	}
+	return n, err
+}
+
+// Write writes data to the stream.
+func (s *StreamRwc) Write(p []byte) (n int, err error) {
+	s.writeMsg.SetData(p)
+	err = s.Stream.MsgSend(&s.writeMsg)
+	s.writeMsg.Clear()
+	if err != nil {
+		return 0, err
+	}
+	return len(p), nil
+}
+
+// _ is a type assertion
+var _ io.ReadWriteCloser = ((*StreamRwc)(nil))

package/srpc/stream.ts

@@ -5,6 +5,7 @@ import type { Duplex } from 'it-stream-types'
 export type PacketHandler = (packet: Packet) => Promise<void>
 
 // Stream is an open connection.
+// This stream type generally assumes that each Uint8Array corresponds to a Packet.
 export type Stream = Duplex<Uint8Array>
 
 // OpenStreamFunc is a function to start a new RPC by opening a Stream.

package/srpc/writer.go

@@ -2,6 +2,8 @@ package srpc
 
 // Writer is the interface used to write messages to the remote.
 type Writer interface {
+	// Write writes raw data to the remote.
+	Write(p []byte) (n int, err error)
 	// WritePacket writes a packet to the remote.
 	WritePacket(p *Packet) error
 	// Close closes the writer.