starpc 0.18.2 → 0.19.0

package/srpc/packet-rw.go

@@ -13,9 +13,9 @@ import (
 // maxMessageSize is the max message size in bytes
 var maxMessageSize = 1e7
 
-// PacketReaderWriter reads and writes packets from a io.ReadWriter.
+// PacketReadWriter reads and writes packets from a io.ReadWriter.
 // Uses a LittleEndian uint32 length prefix.
-type PacketReaderWriter struct {
+type PacketReadWriter struct {
 	// rw is the io.ReadWriterCloser
 	rw io.ReadWriteCloser
 	// buf is the buffered data
@@ -25,12 +25,19 @@ type PacketReaderWriter struct {
 }
 
 // NewPacketReadWriter constructs a new read/writer.
-func NewPacketReadWriter(rw io.ReadWriteCloser) *PacketReaderWriter {
-	return &PacketReaderWriter{rw: rw}
+func NewPacketReadWriter(rw io.ReadWriteCloser) *PacketReadWriter {
+	return &PacketReadWriter{rw: rw}
+}
+
+// Write writes raw data to the remote.
+func (r *PacketReadWriter) Write(p []byte) (n int, err error) {
+	r.writeMtx.Lock()
+	defer r.writeMtx.Unlock()
+	return r.rw.Write(p)
 }
 
 // WritePacket writes a packet to the writer.
-func (r *PacketReaderWriter) WritePacket(p *Packet) error {
+func (r *PacketReadWriter) WritePacket(p *Packet) error {
 	r.writeMtx.Lock()
 	defer r.writeMtx.Unlock()
 
@@ -55,7 +62,7 @@ func (r *PacketReaderWriter) WritePacket(p *Packet) error {
 // ReadPump executes the read pump in a goroutine.
 //
 // calls the handler when closed or returning an error
-func (r *PacketReaderWriter) ReadPump(cb PacketHandler, closed CloseHandler) {
+func (r *PacketReadWriter) ReadPump(cb PacketDataHandler, closed CloseHandler) {
 	err := r.ReadToHandler(cb)
 	// signal that the stream is now closed.
 	if closed != nil {
@@ -65,7 +72,7 @@ func (r *PacketReaderWriter) ReadPump(cb PacketHandler, closed CloseHandler) {
 
 // ReadToHandler reads data to the given handler.
 // Does not handle closing the stream, use ReadPump instead.
-func (r *PacketReaderWriter) ReadToHandler(cb PacketHandler) error {
+func (r *PacketReadWriter) ReadToHandler(cb PacketDataHandler) error {
 	var currLen uint32
 	buf := make([]byte, 2048)
 	isOpen := true
@@ -107,11 +114,7 @@ func (r *PacketReaderWriter) ReadToHandler(cb PacketHandler) error {
 		if currLen != 0 && bufLen >= int(currLen)+4 {
 			pkt := r.buf.Next(int(currLen + 4))[4:]
 			currLen = 0
-			npkt := &Packet{}
-			if err := npkt.UnmarshalVT(pkt); err != nil {
-				return err
-			}
-			if err := cb(npkt); err != nil {
+			if err := cb(pkt); err != nil {
 				return err
 			}
 		}
@@ -122,12 +125,12 @@ func (r *PacketReaderWriter) ReadToHandler(cb PacketHandler) error {
 }
 
 // Close closes the packet rw.
-func (r *PacketReaderWriter) Close() error {
+func (r *PacketReadWriter) Close() error {
 	return r.rw.Close()
 }
 
 // readLengthPrefix reads the length prefix.
-func (r *PacketReaderWriter) readLengthPrefix(b []byte) uint32 {
+func (r *PacketReadWriter) readLengthPrefix(b []byte) uint32 {
 	if len(b) < 4 {
 		return 0
 	}
@@ -135,4 +138,4 @@ func (r *PacketReaderWriter) readLengthPrefix(b []byte) uint32 {
 }
 
 // _ is a type assertion
-var _ Writer = (*PacketReaderWriter)(nil)
+var _ Writer = (*PacketReadWriter)(nil)

package/srpc/packet.go

@@ -1,14 +1,33 @@
 package srpc
 
+import "context"
+
 // PacketHandler handles a packet.
 //
 // pkt is optional (can be nil)
 // if closeErr is set, the stream is closed after pkt.
 type PacketHandler = func(pkt *Packet) error
 
+// PacketDataHandler handles a packet before it is parsed.
+type PacketDataHandler = func(data []byte) error
+
 // CloseHandler handles the stream closing with an optional error.
 type CloseHandler = func(closeErr error)
 
+// RawStreamCtor is a function that builds a raw stream.
+type RawStreamCtor func(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (Writer, error)
+
+// NewPacketDataHandler wraps a PacketHandler with a decoding step.
+func NewPacketDataHandler(handler PacketHandler) PacketDataHandler {
+	return func(data []byte) error {
+		pkt := &Packet{}
+		if err := pkt.UnmarshalVT(data); err != nil {
+			return err
+		}
+		return handler(pkt)
+	}
+}
+
 // Validate performs cursory validation of the packet.
 func (p *Packet) Validate() error {
 	switch b := p.GetBody().(type) {

package/srpc/pushable.ts

@@ -1,4 +1,6 @@
 import { Pushable } from 'it-pushable'
+import { Source, Sink } from 'it-stream-types'
+import { castToError } from './errors.js'
 
 // writeToPushable writes the incoming server data to the pushable.
 export async function writeToPushable<T>(
@@ -15,3 +17,24 @@ export async function writeToPushable<T>(
     throw err
   }
 }
+
+// buildPushableSink builds a Sink from a Pushable.
+export function buildPushableSink<T>(target: Pushable<T>): Sink<T> {
+  return async function pushableSink(source: Source<T>): Promise<void> {
+    try {
+      for await (const pkt of source) {
+        if (Array.isArray(pkt)) {
+          for (const p of pkt) {
+            target.push(p)
+          }
+        } else {
+          target.push(pkt)
+        }
+      }
+      target.end()
+    } catch (err) {
+      const error = castToError(err)
+      target.end(error)
+    }
+  }
+}

package/srpc/raw-stream-rwc.go

@@ -0,0 +1,153 @@
+package srpc
+
+import (
+	"context"
+	"io"
+	"sync"
+
+	"github.com/aperturerobotics/util/broadcast"
+)
+
+// RawStreamRwc implements io.ReadWriteCloser with a raw stream.
+type RawStreamRwc struct {
+	// writer is used to write messages to the remote.
+	writer Writer
+	// mtx guards below fields
+	mtx sync.Mutex
+	// bcast is broadcasted when data is added to readQueue
+	bcast broadcast.Broadcast
+	// readQueue holds incoming data to read
+	readQueue [][]byte
+	// closed indicates whether the stream is closed
+	closed bool
+	// closeErr stores the error, if any, when closing the stream
+	closeErr error
+}
+
+func NewRawStreamRwc(ctx context.Context, ctorFn RawStreamCtor) (*RawStreamRwc, error) {
+	rwc := &RawStreamRwc{}
+	var err error
+	rwc.writer, err = ctorFn(ctx, rwc.handlePacketData, rwc.handleClose)
+	if err != nil {
+		return nil, err
+	}
+	return rwc, nil
+}
+
+// handlePacketData implements PacketDataHandler.
+func (r *RawStreamRwc) handlePacketData(pkt []byte) error {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	if r.closed {
+		return io.ErrClosedPipe
+	}
+
+	r.readQueue = append(r.readQueue, pkt)
+	r.bcast.Broadcast()
+	return nil
+}
+
+// handleClose handles the stream closing with an optional error.
+func (r *RawStreamRwc) handleClose(closeErr error) {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+	if r.closed {
+		return
+	}
+	r.closed = true
+	r.closeErr = closeErr
+	r.bcast.Broadcast()
+}
+
+// Read reads data from the stream to p.
+// Implements io.Reader.
+func (r *RawStreamRwc) Read(p []byte) (n int, err error) {
+	readBuf := p
+	for len(readBuf) != 0 && err == nil {
+		// if the buffer has data, read from it.
+		var rn int
+		var read []byte
+
+		r.mtx.Lock()
+		if len(r.readQueue) != 0 {
+			nrq := r.readQueue[0]
+			rn = len(readBuf)
+			if nrLen := len(nrq); nrLen < rn {
+				rn = nrLen
+			}
+			read = nrq[:rn]
+			nrq = nrq[rn:]
+			if len(nrq) == 0 {
+				r.readQueue[0] = nil
+				r.readQueue = r.readQueue[1:]
+			} else {
+				r.readQueue[0] = nrq
+			}
+		}
+		closed, closedErr := r.closed, r.closeErr
+		var wait <-chan struct{}
+		if rn == 0 && !closed {
+			wait = r.bcast.GetWaitCh()
+		}
+		r.mtx.Unlock()
+
+		// if we read data, copy it to the output buf
+		if rn != 0 {
+			// advance readBuf by rn
+			copy(readBuf, read)
+			n += rn
+			readBuf = readBuf[rn:]
+			continue
+		}
+
+		// if we read data to p already, return now.
+		if n != 0 {
+			break
+		}
+
+		// if closed or error, return.
+		if closed {
+			if closedErr != nil {
+				return n, closedErr
+			}
+			return n, io.EOF
+		}
+
+		// wait for data or closed
+		<-wait
+	}
+
+	return n, err
+}
+
+// Write writes data to the stream.
+func (r *RawStreamRwc) Write(p []byte) (int, error) {
+	return r.writer.Write(p)
+}
+
+// WritePacket writes a packet to the remote.
+func (r *RawStreamRwc) WritePacket(p *Packet) error {
+	return r.writer.WritePacket(p)
+}
+
+// Close closes the stream.
+func (r *RawStreamRwc) Close() error {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	if r.closed {
+		return r.closeErr
+	}
+
+	r.closed = true
+	r.closeErr = r.writer.Close()
+	r.bcast.Broadcast()
+	return r.closeErr
+}
+
+// _ is a type assertion
+var (
+	_ io.ReadWriteCloser = ((*RawStreamRwc)(nil))
+	_ Writer             = ((*RawStreamRwc)(nil))
+)

package/srpc/rpcproto.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.28.1-devel
+// 	protoc-gen-go v1.30.0-devel
 // 	protoc        v3.21.9
 // source: github.com/aperturerobotics/starpc/srpc/rpcproto.proto
 

package/srpc/rpcproto.pb.ts

@@ -60,47 +60,66 @@ export const Packet = {
     message: Packet,
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
-    if (message.body?.$case === 'callStart') {
-      CallStart.encode(
-        message.body.callStart,
-        writer.uint32(10).fork()
-      ).ldelim()
-    }
-    if (message.body?.$case === 'callData') {
-      CallData.encode(message.body.callData, writer.uint32(18).fork()).ldelim()
-    }
-    if (message.body?.$case === 'callCancel') {
-      writer.uint32(24).bool(message.body.callCancel)
+    switch (message.body?.$case) {
+      case 'callStart':
+        CallStart.encode(
+          message.body.callStart,
+          writer.uint32(10).fork()
+        ).ldelim()
+        break
+      case 'callData':
+        CallData.encode(
+          message.body.callData,
+          writer.uint32(18).fork()
+        ).ldelim()
+        break
+      case 'callCancel':
+        writer.uint32(24).bool(message.body.callCancel)
+        break
     }
     return writer
   },
 
   decode(input: _m0.Reader | Uint8Array, length?: number): Packet {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input)
+    const reader =
+      input instanceof _m0.Reader ? input : _m0.Reader.create(input)
     let end = length === undefined ? reader.len : reader.pos + length
     const message = createBasePacket()
     while (reader.pos < end) {
       const tag = reader.uint32()
       switch (tag >>> 3) {
         case 1:
+          if (tag != 10) {
+            break
+          }
+
           message.body = {
             $case: 'callStart',
             callStart: CallStart.decode(reader, reader.uint32()),
           }
-          break
+          continue
         case 2:
+          if (tag != 18) {
+            break
+          }
+
           message.body = {
             $case: 'callData',
             callData: CallData.decode(reader, reader.uint32()),
           }
-          break
+          continue
         case 3:
+          if (tag != 24) {
+            break
+          }
+
           message.body = { $case: 'callCancel', callCancel: reader.bool() }
-          break
-        default:
-          reader.skipType(tag & 7)
-          break
+          continue
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break
       }
+      reader.skipType(tag & 7)
     }
     return message
   },
@@ -236,28 +255,46 @@ export const CallStart = {
   },
 
   decode(input: _m0.Reader | Uint8Array, length?: number): CallStart {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input)
+    const reader =
+      input instanceof _m0.Reader ? input : _m0.Reader.create(input)
     let end = length === undefined ? reader.len : reader.pos + length
     const message = createBaseCallStart()
     while (reader.pos < end) {
       const tag = reader.uint32()
       switch (tag >>> 3) {
         case 1:
+          if (tag != 10) {
+            break
+          }
+
           message.rpcService = reader.string()
-          break
+          continue
         case 2:
+          if (tag != 18) {
+            break
+          }
+
           message.rpcMethod = reader.string()
-          break
+          continue
         case 3:
+          if (tag != 26) {
+            break
+          }
+
           message.data = reader.bytes()
-          break
+          continue
         case 4:
+          if (tag != 32) {
+            break
+          }
+
           message.dataIsZero = reader.bool()
-          break
-        default:
-          reader.skipType(tag & 7)
-          break
+          continue
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break
       }
+      reader.skipType(tag & 7)
     }
     return message
   },
@@ -367,28 +404,46 @@ export const CallData = {
   },
 
   decode(input: _m0.Reader | Uint8Array, length?: number): CallData {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input)
+    const reader =
+      input instanceof _m0.Reader ? input : _m0.Reader.create(input)
     let end = length === undefined ? reader.len : reader.pos + length
     const message = createBaseCallData()
     while (reader.pos < end) {
       const tag = reader.uint32()
       switch (tag >>> 3) {
         case 1:
+          if (tag != 10) {
+            break
+          }
+
           message.data = reader.bytes()
-          break
+          continue
         case 2:
+          if (tag != 16) {
+            break
+          }
+
           message.dataIsZero = reader.bool()
-          break
+          continue
         case 3:
+          if (tag != 24) {
+            break
+          }
+
           message.complete = reader.bool()
-          break
+          continue
         case 4:
+          if (tag != 34) {
+            break
+          }
+
           message.error = reader.string()
-          break
-        default:
-          reader.skipType(tag & 7)
-          break
+          continue
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break
       }
+      reader.skipType(tag & 7)
     }
     return message
   },

package/srpc/rpcproto_vtproto.pb.go

@@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
-// protoc-gen-go-vtproto version: v0.3.1-0.20220817155510-0ae748fd2007
+// protoc-gen-go-vtproto version: v0.4.0
 // source: github.com/aperturerobotics/starpc/srpc/rpcproto.proto
 
 package srpc
@@ -35,7 +35,7 @@ func (m *Packet) CloneVT() *Packet {
 	return r
 }
 
-func (m *Packet) CloneGenericVT() proto.Message {
+func (m *Packet) CloneMessageVT() proto.Message {
 	return m.CloneVT()
 }
 
@@ -90,7 +90,7 @@ func (m *CallStart) CloneVT() *CallStart {
 	return r
 }
 
-func (m *CallStart) CloneGenericVT() proto.Message {
+func (m *CallStart) CloneMessageVT() proto.Message {
 	return m.CloneVT()
 }
 
@@ -115,14 +115,14 @@ func (m *CallData) CloneVT() *CallData {
 	return r
 }
 
-func (m *CallData) CloneGenericVT() proto.Message {
+func (m *CallData) CloneMessageVT() proto.Message {
 	return m.CloneVT()
 }
 
 func (this *Packet) EqualVT(that *Packet) bool {
-	if this == nil {
-		return that == nil
-	} else if that == nil {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
 		return false
 	}
 	if this.Body == nil && that.Body != nil {
@@ -138,6 +138,13 @@ func (this *Packet) EqualVT(that *Packet) bool {
 	return string(this.unknownFields) == string(that.unknownFields)
 }
 
+func (this *Packet) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*Packet)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
 func (this *Packet_CallStart) EqualVT(thatIface isPacket_Body) bool {
 	that, ok := thatIface.(*Packet_CallStart)
 	if !ok {
@@ -206,9 +213,9 @@ func (this *Packet_CallCancel) EqualVT(thatIface isPacket_Body) bool {
 }
 
 func (this *CallStart) EqualVT(that *CallStart) bool {
-	if this == nil {
-		return that == nil
-	} else if that == nil {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
 		return false
 	}
 	if this.RpcService != that.RpcService {
@@ -226,10 +233,17 @@ func (this *CallStart) EqualVT(that *CallStart) bool {
 	return string(this.unknownFields) == string(that.unknownFields)
 }
 
+func (this *CallStart) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*CallStart)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
 func (this *CallData) EqualVT(that *CallData) bool {
-	if this == nil {
-		return that == nil
-	} else if that == nil {
+	if this == that {
+		return true
+	} else if this == nil || that == nil {
 		return false
 	}
 	if string(this.Data) != string(that.Data) {
@@ -247,6 +261,13 @@ func (this *CallData) EqualVT(that *CallData) bool {
 	return string(this.unknownFields) == string(that.unknownFields)
 }
 
+func (this *CallData) EqualMessageVT(thatMsg proto.Message) bool {
+	that, ok := thatMsg.(*CallData)
+	if !ok {
+		return false
+	}
+	return this.EqualVT(that)
+}
 func (m *Packet) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
@@ -1067,6 +1088,7 @@ func (m *CallData) UnmarshalVT(dAtA []byte) error {
 	}
 	return nil
 }
+
 func skip(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

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 PacketHandler, closeHandler CloseHandler) (Writer, error) {
+	return func(ctx context.Context, msgHandler PacketDataHandler, closeHandler CloseHandler) (Writer, error) {
 		srvPipe, clientPipe := net.Pipe()
 		go server.HandleStream(ctx, srvPipe)
 		clientPrw := NewPacketReadWriter(clientPipe)

package/srpc/server-rpc.go

@@ -22,6 +22,15 @@ func NewServerRPC(ctx context.Context, invoker Invoker, writer Writer) *ServerRP
 	return rpc
 }
 
+// HandlePacketData handles an incoming unparsed message packet.
+func (r *ServerRPC) HandlePacketData(data []byte) error {
+	msg := &Packet{}
+	if err := msg.UnmarshalVT(data); err != nil {
+		return err
+	}
+	return r.HandlePacket(msg)
+}
+
 // HandlePacket handles an incoming parsed message packet.
 func (r *ServerRPC) HandlePacket(msg *Packet) error {
 	if msg == nil {

package/srpc/server.go

@@ -26,12 +26,13 @@ func (s *Server) GetInvoker() Invoker {
 }
 
 // HandleStream handles an incoming stream and runs the read loop.
+// Uses length-prefixed packets.
 func (s *Server) HandleStream(ctx context.Context, rwc io.ReadWriteCloser) {
 	subCtx, subCtxCancel := context.WithCancel(ctx)
 	defer subCtxCancel()
 	prw := NewPacketReadWriter(rwc)
 	serverRPC := NewServerRPC(subCtx, s.invoker, prw)
-	prw.ReadPump(serverRPC.HandlePacket, serverRPC.HandleStreamClose)
+	prw.ReadPump(serverRPC.HandlePacketData, serverRPC.HandleStreamClose)
 }
 
 // AcceptMuxedConn runs a loop which calls Accept on a muxer to handle streams.