starpc 0.0.1 → 0.1.0

package/echo/echo_vtproto.pb.go

@@ -0,0 +1,271 @@
+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
+// protoc-gen-go-vtproto version: v0.3.1-0.20220531071333-dfd3d322ffb6
+// source: github.com/aperturerobotics/starpc/echo/echo.proto
+
+package echo
+
+import (
+	fmt "fmt"
+	io "io"
+	bits "math/bits"
+
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+func (this *EchoMsg) EqualVT(that *EchoMsg) bool {
+	if this == nil {
+		return that == nil || that.String() == ""
+	} else if that == nil {
+		return this.String() == ""
+	}
+	if this.Body != that.Body {
+		return false
+	}
+	return string(this.unknownFields) == string(that.unknownFields)
+}
+
+func (m *EchoMsg) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *EchoMsg) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *EchoMsg) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if len(m.Body) > 0 {
+		i -= len(m.Body)
+		copy(dAtA[i:], m.Body)
+		i = encodeVarint(dAtA, i, uint64(len(m.Body)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarint(dAtA []byte, offset int, v uint64) int {
+	offset -= sov(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *EchoMsg) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Body)
+	if l > 0 {
+		n += 1 + l + sov(uint64(l))
+	}
+	n += len(m.unknownFields)
+	return n
+}
+
+func sov(x uint64) (n int) {
+	return (bits.Len64(x|1) + 6) / 7
+}
+func soz(x uint64) (n int) {
+	return sov(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *EchoMsg) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: EchoMsg: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EchoMsg: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Body = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skip(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLength
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroup
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLength
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLength        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflow          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroup = fmt.Errorf("proto: unexpected end of group")
+)

package/echo/server.go

@@ -0,0 +1,73 @@
+package echo
+
+import (
+	context "context"
+	"errors"
+	"io"
+	"time"
+
+	"google.golang.org/protobuf/proto"
+)
+
+// EchoServer implements the server side of Echo.
+type EchoServer struct {
+}
+
+// Echo implements echo.SRPCEchoerServer
+func (*EchoServer) Echo(ctx context.Context, msg *EchoMsg) (*EchoMsg, error) {
+	return proto.Clone(msg).(*EchoMsg), nil
+}
+
+// EchoServerStream implements SRPCEchoerServer
+func (*EchoServer) EchoServerStream(msg *EchoMsg, strm SRPCEchoer_EchoServerStreamStream) error {
+	// send 5 responses, with a 200ms delay for each
+	responses := 5
+	tkr := time.NewTicker(time.Millisecond * 200)
+	defer tkr.Stop()
+	for i := 0; i < responses; i++ {
+		if err := strm.MsgSend(msg); err != nil {
+			return err
+		}
+		select {
+		case <-strm.Context().Done():
+			return context.Canceled
+		case <-tkr.C:
+		}
+	}
+	return nil
+}
+
+// EchoClientStream implements SRPCEchoerServer
+func (*EchoServer) EchoClientStream(strm SRPCEchoer_EchoClientStreamStream) error {
+	msg, err := strm.Recv()
+	if err != nil {
+		return err
+	}
+	return strm.SendAndClose(msg)
+}
+
+// EchoBidiStream implements SRPCEchoerServer
+func (s *EchoServer) EchoBidiStream(strm SRPCEchoer_EchoBidiStreamStream) error {
+	// server sends initial message
+	if err := strm.MsgSend(&EchoMsg{Body: "hello from server"}); err != nil {
+		return err
+	}
+	for {
+		msg, err := strm.Recv()
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+		if len(msg.GetBody()) == 0 {
+			return errors.New("got message with empty body")
+		}
+		if err := strm.Send(msg); err != nil {
+			return err
+		}
+	}
+}
+
+// _ is a type assertion
+var _ SRPCEchoerServer = ((*EchoServer)(nil))

package/package.json

@@ -1,15 +1,77 @@
 {
   "name": "starpc",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
-  "repository": "github:paralin/starpc",
-  "license": "Apache-2.0",
+  "license": "MIT",
   "author": {
-    "name": "Christian Stewart",
-    "email": "christian@aperture.us",
-    "url": "http://github.com/paralin"
+    "name": "Aperture Robotics LLC.",
+    "email": "support@aperture.us",
+    "url": "http://aperture.us"
   },
-  "scripts": {},
-  "prettier": {},
-  "dependencies": {}
+  "contributors": [
+    {
+      "name": "Christian Stewart",
+      "email": "christian@aperture.us",
+      "url": "http://github.com/paralin"
+    }
+  ],
+  "main": "dist/srpc/index.js",
+  "types": "./dist/srpc/index.d.ts",
+  "files": [
+    "srpc",
+    "echo",
+    "dist/srpc",
+    "dist/echo",
+    "!**/*.tsbuildinfo"
+  ],
+  "repository": {
+    "url": "git@github.com:aperturerobotics/starpc.git"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json --outDir ./dist/",
+    "check": "tsc",
+    "codegen": "npm run gen",
+    "ci": "npm run build && npm run lint:js && npm run lint:go",
+    "format": "prettier --write './srpc/**/(*.ts|*.tsx|*.js|*.html|*.css)'",
+    "gen": "make genproto",
+    "test": "make test && npm run check",
+    "test:integration": "make integration",
+    "lint": "npm run lint:go && npm run lint:js",
+    "lint:go": "make lint",
+    "lint:js": "eslint -c .eslintrc.js --ext .ts ./{srpc,echo}/**/*.ts",
+    "postinstall": "patch-package",
+    "precommit": "npm run format"
+  },
+  "prettier": {
+    "semi": false,
+    "singleQuote": true
+  },
+  "devDependencies": {
+    "@types/varint": "^6.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.27.1",
+    "@typescript-eslint/parser": "^5.27.1",
+    "esbuild": "^0.14.43",
+    "eslint": "^8.17.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-config-standard-with-typescript": "^21.0.1",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "husky": "^8.0.1",
+    "patch-package": "^6.4.7",
+    "prettier": "^2.7.0",
+    "ts-proto": "^1.115.4",
+    "typescript": "^4.7.3"
+  },
+  "dependencies": {
+    "@libp2p/mplex": "^1.2.1",
+    "event-iterator": "^2.0.0",
+    "isomorphic-ws": "^4.0.1",
+    "it-length-prefixed": "^7.0.1",
+    "it-pipe": "^2.0.3",
+    "it-pushable": "^3.0.0",
+    "it-stream-types": "^1.0.4",
+    "it-ws": "^5.0.2",
+    "protobufjs": "^6.11.3",
+    "rxjs": "^7.5.5",
+    "ws": "^8.8.0"
+  }
 }

package/srpc/broadcast-channel.ts

@@ -0,0 +1,72 @@
+import type { Duplex, Sink } from 'it-stream-types'
+import { Conn } from './conn'
+import { EventIterator } from 'event-iterator'
+import { pipe } from 'it-pipe'
+
+// BroadcastChannelIterable is a AsyncIterable wrapper for BroadcastChannel.
+export class BroadcastChannelIterable<T> implements Duplex<T> {
+  // channel is the broadcast channel
+  public readonly channel: BroadcastChannel
+  // sink is the sink for incoming messages.
+  public sink: Sink<T>
+  // source is the source for outgoing messages.
+  public source: AsyncIterable<T>
+
+  constructor(channel: BroadcastChannel) {
+    this.channel = channel
+    this.sink = this._createSink()
+    this.source = this._createSource()
+  }
+
+  // _createSink initializes the sink field.
+  private _createSink(): Sink<T> {
+    return async (source) => {
+      for await (const msg of source) {
+        this.channel.postMessage(msg)
+      }
+    }
+  }
+
+  // _createSource initializes the source field.
+  private _createSource() {
+    return new EventIterator<T>((queue) => {
+      const messageListener = (ev: MessageEvent<T>) => {
+        if (ev.data) {
+          queue.push(ev.data)
+        }
+      }
+      this.channel.addEventListener('message', messageListener)
+
+      return () => {
+        this.channel.removeEventListener('message', messageListener)
+      }
+    })
+  }
+}
+
+// newBroadcastChannelIterable constructs a BroadcastChannelIterable with a channel name.
+export function newBroadcastChannelIterable<T>(
+  name: string
+): BroadcastChannelIterable<T> {
+  const channel = new BroadcastChannel(name)
+  return new BroadcastChannelIterable<T>(channel)
+}
+
+// BroadcastChannelConn implements a connection with a BroadcastChannel.
+//
+// expects Uint8Array objects over the BroadcastChannel.
+export class BroadcastChannelConn extends Conn {
+  // channel is the broadcast channel iterable
+  private channel: BroadcastChannelIterable<Uint8Array>
+
+  constructor(channel: BroadcastChannel) {
+    super()
+    this.channel = new BroadcastChannelIterable<Uint8Array>(channel)
+    pipe(this, this.channel, this)
+  }
+
+  // getBroadcastChannel returns the BroadcastChannel.
+  public getBroadcastChannel(): BroadcastChannel {
+    return this.channel.channel
+  }
+}

package/srpc/client-rpc.go

@@ -0,0 +1,163 @@
+package srpc
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+)
+
+// ClientRPC represents the client side of an on-going RPC call message stream.
+// Not concurrency safe: use a mutex if calling concurrently.
+type ClientRPC struct {
+	// ctx is the context, canceled when the rpc ends.
+	ctx context.Context
+	// ctxCancel is called when the rpc ends.
+	ctxCancel context.CancelFunc
+	// writer is the writer to write messages to
+	writer Writer
+	// service is the rpc service
+	service string
+	// method is the rpc method
+	method string
+	// dataCh contains queued data packets.
+	// closed when the client closes the channel.
+	dataCh chan []byte
+	// dataChClosed is a flag set after dataCh is closed.
+	// controlled by HandlePacket.
+	dataChClosed bool
+	// serverErr is an error set by the client.
+	// before dataCh is closed, managed by HandlePacket.
+	// immutable after dataCh is closed.
+	serverErr error
+}
+
+// NewClientRPC constructs a new ClientRPC session and writes CallStart.
+// the writer will be closed when the ClientRPC completes.
+// service and method must be specified.
+// must call Start after creating the RPC object.
+func NewClientRPC(ctx context.Context, service, method string) *ClientRPC {
+	rpc := &ClientRPC{
+		service: service,
+		method:  method,
+		dataCh:  make(chan []byte, 5),
+	}
+	rpc.ctx, rpc.ctxCancel = context.WithCancel(ctx)
+	return rpc
+}
+
+// Start sets the writer and writes the MsgSend message.
+// firstMsg can be nil, but is usually set if this is a non-streaming rpc.
+// must only be called once!
+func (r *ClientRPC) Start(writer Writer, firstMsg []byte) error {
+	select {
+	case <-r.ctx.Done():
+		r.Close()
+		return context.Canceled
+	default:
+	}
+	r.writer = writer
+	pkt := NewCallStartPacket(r.service, r.method, firstMsg)
+	if err := writer.WritePacket(pkt); err != nil {
+		r.Close()
+		return err
+	}
+	return nil
+}
+
+// ReadAll reads all returned Data packets and returns any error.
+// intended for use with unary rpcs.
+func (r *ClientRPC) ReadAll() ([][]byte, error) {
+	msgs := make([][]byte, 0, 1)
+	for {
+		select {
+		case <-r.ctx.Done():
+			return msgs, context.Canceled
+		case data, ok := <-r.dataCh:
+			if !ok {
+				return msgs, r.serverErr
+			}
+			msgs = append(msgs, data)
+		}
+	}
+}
+
+// Context is canceled when the ClientRPC is no longer valid.
+func (r *ClientRPC) Context() context.Context {
+	return r.ctx
+}
+
+// HandlePacketData handles an incoming unparsed message packet.
+// Not concurrency safe: use a mutex if calling concurrently.
+func (r *ClientRPC) HandlePacketData(data []byte) error {
+	pkt := &Packet{}
+	if err := pkt.UnmarshalVT(data); err != nil {
+		return err
+	}
+	return r.HandlePacket(pkt)
+}
+
+// HandlePacket handles an incoming parsed message packet.
+// Not concurrency safe: use a mutex if calling concurrently.
+func (r *ClientRPC) HandlePacket(msg *Packet) error {
+	if err := msg.Validate(); err != nil {
+		return err
+	}
+
+	switch b := msg.GetBody().(type) {
+	case *Packet_CallStart:
+		return r.HandleCallStart(b.CallStart)
+	case *Packet_CallData:
+		return r.HandleCallData(b.CallData)
+	case *Packet_CallStartResp:
+		return r.HandleCallStartResp(b.CallStartResp)
+	default:
+		return nil
+	}
+}
+
+// HandleCallStart handles the call start packet.
+func (r *ClientRPC) HandleCallStart(pkt *CallStart) error {
+	// server-to-client calls not supported
+	return errors.Wrap(ErrUnrecognizedPacket, "call start packet unexpected")
+}
+
+// HandleCallData handles the call data packet.
+func (r *ClientRPC) HandleCallData(pkt *CallData) error {
+	if r.dataChClosed {
+		return ErrCompleted
+	}
+
+	if data := pkt.GetData(); len(data) != 0 {
+		select {
+		case <-r.ctx.Done():
+			return context.Canceled
+		case r.dataCh <- data:
+		}
+	}
+
+	complete := pkt.GetComplete()
+	if err := pkt.GetError(); len(err) != 0 {
+		complete = true
+		r.serverErr = errors.New(err)
+	}
+
+	if complete {
+		r.dataChClosed = true
+		close(r.dataCh)
+	}
+
+	return nil
+}
+
+// HandleCallStartResp handles the CallStartResp packet.
+func (r *ClientRPC) HandleCallStartResp(resp *CallStartResp) error {
+	// client-side calls not supported
+	return errors.Wrap(ErrUnrecognizedPacket, "call start resp packet unexpected")
+}
+
+// Close releases any resources held by the ClientRPC.
+// not concurrency safe with HandlePacket.
+func (r *ClientRPC) Close() {
+	r.ctxCancel()
+	_ = r.writer.Close()
+}