starpc 0.0.1 → 0.1.2

package/srpc/server-http.go

@@ -0,0 +1,66 @@
+package srpc
+
+import (
+	"context"
+	"io"
+	"net/http"
+
+	"nhooyr.io/websocket"
+)
+
+// HTTPServer implements the SRPC server.
+type HTTPServer struct {
+	mux  Mux
+	srpc *Server
+	path string
+}
+
+// NewHTTPServer builds a http server / handler.
+// if path is empty, serves on all routes.
+func NewHTTPServer(mux Mux, path string) (*HTTPServer, error) {
+	return &HTTPServer{
+		mux:  mux,
+		srpc: NewServer(mux),
+		path: path,
+	}, nil
+}
+
+func (s *HTTPServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if s.path != "" && r.URL.Path != s.path {
+		return
+	}
+
+	c, err := websocket.Accept(w, r, &websocket.AcceptOptions{})
+	if err != nil {
+		// TODO: handle / log error?
+		_ = err
+		return
+	}
+	defer c.Close(websocket.StatusInternalError, "closed")
+
+	ctx := r.Context()
+	wsConn, err := NewWebSocketConn(ctx, c, true)
+	if err != nil {
+		// TODO: handle / log error?
+		c.Close(websocket.StatusInternalError, err.Error())
+		return
+	}
+
+	// handle incoming streams
+	for {
+		strm, err := wsConn.AcceptStream()
+		if err != nil {
+			if err != io.EOF && err != context.Canceled {
+				// TODO: handle / log error?
+				c.Close(websocket.StatusInternalError, err.Error())
+			}
+			return
+		}
+		go func() {
+			err := s.srpc.HandleConn(ctx, strm)
+			_ = err
+			// TODO: handle / log error?
+			// err != nil && err != io.EOF && err != context.Canceled
+		}()
+	}
+}

package/srpc/server-pipe.go

@@ -0,0 +1,26 @@
+package srpc
+
+import (
+	"context"
+	"net"
+)
+
+// NewServerPipe constructs a open stream func which creates an in-memory Pipe
+// Stream with the given Server. Starts read pumps for both. Starts the
+// HandleConn 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) {
+		srvPipe, clientPipe := net.Pipe()
+		go func() {
+			_ = server.HandleConn(ctx, srvPipe)
+		}()
+		clientPrw := NewPacketReadWriter(clientPipe, msgHandler)
+		go func() {
+			err := clientPrw.ReadPump()
+			if err != nil {
+				_ = clientPrw.Close()
+			}
+		}()
+		return clientPrw, nil
+	}
+}

package/srpc/server-rpc.go

@@ -0,0 +1,160 @@
+package srpc
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+)
+
+// ServerRPC represents the server side of an on-going RPC call message stream.
+// Not concurrency safe: use a mutex if calling concurrently.
+type ServerRPC 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
+	// mux is the mux to handle calls
+	mux Mux
+	// 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
+	// clientErr is an error set by the client.
+	// before dataCh is closed, managed by HandlePacket.
+	// immutable after dataCh is closed.
+	clientErr error
+}
+
+// NewServerRPC constructs a new ServerRPC session.
+// note: call SetWriter before handling any incoming messages.
+func NewServerRPC(ctx context.Context, mux Mux) *ServerRPC {
+	rpc := &ServerRPC{
+		dataCh: make(chan []byte, 5),
+		mux:    mux,
+	}
+	rpc.ctx, rpc.ctxCancel = context.WithCancel(ctx)
+	return rpc
+}
+
+// SetWriter sets the writer field.
+func (r *ServerRPC) SetWriter(w Writer) {
+	r.writer = w
+}
+
+// Context is canceled when the ServerRPC is no longer valid.
+func (r *ServerRPC) Context() context.Context {
+	return r.ctx
+}
+
+// HandlePacket handles an incoming parsed message packet.
+// Not concurrency safe: use a mutex if calling concurrently.
+func (r *ServerRPC) 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 *ServerRPC) HandleCallStart(pkt *CallStart) error {
+	// process start: method and service
+	if r.method != "" || r.service != "" {
+		return errors.New("call start must be sent only once")
+	}
+	if r.dataChClosed {
+		return ErrCompleted
+	}
+	r.method, r.service = pkt.GetRpcMethod(), pkt.GetRpcService()
+
+	// process first data packet, if included
+	if data := pkt.GetData(); len(data) != 0 {
+		select {
+		case r.dataCh <- data:
+		default:
+			// the channel should be empty w/ a buffer capacity of 5 here.
+			return errors.New("data channel was full, expected empty")
+		}
+	}
+
+	// invoke the rpc
+	go r.invokeRPC()
+
+	return nil
+}
+
+// HandleCallData handles the call data packet.
+func (r *ServerRPC) 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.clientErr = errors.New(err)
+	}
+
+	if complete {
+		r.dataChClosed = true
+		close(r.dataCh)
+	}
+
+	return nil
+}
+
+// HandleCallStartResp handles the CallStartResp packet.
+func (r *ServerRPC) HandleCallStartResp(resp *CallStartResp) error {
+	// client-side calls not supported
+	return errors.Wrap(ErrUnrecognizedPacket, "call start resp packet unexpected")
+}
+
+// invoke invokes the RPC after CallStart is received.
+func (r *ServerRPC) invokeRPC() {
+	// ctx := r.ctx
+	serviceID, methodID := r.service, r.method
+	strm := NewRPCStream(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)
+	_ = r.writer.WritePacket(outPkt)
+	r.ctxCancel()
+	_ = r.writer.Close()
+}
+
+// Close releases any resources held by the ServerRPC.
+// not concurrency safe with HandlePacket.
+func (r *ServerRPC) Close() {
+	r.ctxCancel()
+	if r.service == "" {
+		// invokeRPC has not been called
+		_ = r.writer.Close()
+	}
+}

package/srpc/server.go

@@ -0,0 +1,29 @@
+package srpc
+
+import (
+	"context"
+	"io"
+)
+
+// Server handles incoming RPC streams with a mux.
+type Server struct {
+	// mux is the srpc mux
+	mux Mux
+}
+
+// NewServer constructs a new SRPC server.
+func NewServer(mux Mux) *Server {
+	return &Server{
+		mux: mux,
+	}
+}
+
+// HandleConn handles an incoming ReadWriteCloser.
+func (s *Server) HandleConn(ctx context.Context, rwc io.ReadWriteCloser) error {
+	subCtx, subCtxCancel := context.WithCancel(ctx)
+	defer subCtxCancel()
+	serverRPC := NewServerRPC(subCtx, s.mux)
+	prw := NewPacketReadWriter(rwc, serverRPC.HandlePacket)
+	serverRPC.SetWriter(prw)
+	return prw.ReadPump()
+}

package/srpc/stream-pipe.go

@@ -0,0 +1,86 @@
+package srpc
+
+import (
+	"context"
+	"io"
+	"sync"
+)
+
+// pipeStream implements an in-memory stream.
+// intended for testing
+type pipeStream struct {
+	ctx       context.Context
+	ctxCancel context.CancelFunc
+	// other is the other end of the stream.
+	other *pipeStream
+	// closeOnce ensures we close only once.
+	closeOnce sync.Once
+	// dataCh is the data channel
+	dataCh chan []byte
+}
+
+// NewPipeStream constructs a new in-memory stream.
+func NewPipeStream(ctx context.Context) (Stream, Stream) {
+	s1 := &pipeStream{dataCh: make(chan []byte, 5)}
+	s1.ctx, s1.ctxCancel = context.WithCancel(ctx)
+	s2 := &pipeStream{other: s1, dataCh: make(chan []byte, 5)}
+	s2.ctx, s2.ctxCancel = context.WithCancel(ctx)
+	s1.other = s2
+	return s1, s2
+}
+
+// Context is canceled when the Stream is no longer valid.
+func (p *pipeStream) Context() context.Context {
+	return p.ctx
+}
+
+// MsgSend sends the message to the remote.
+func (p *pipeStream) MsgSend(msg Message) error {
+	data, err := msg.MarshalVT()
+	if err != nil {
+		return err
+	}
+	select {
+	case <-p.ctx.Done():
+		return context.Canceled
+	case p.other.dataCh <- data:
+		return nil
+	}
+}
+
+// MsgRecv receives an incoming message from the remote.
+// Parses the message into the object at msg.
+func (p *pipeStream) MsgRecv(msg Message) error {
+	select {
+	case <-p.ctx.Done():
+		return context.Canceled
+	case data, ok := <-p.dataCh:
+		if !ok {
+			return io.EOF
+		}
+		return msg.UnmarshalVT(data)
+	}
+}
+
+// CloseSend signals to the remote that we will no longer send any messages.
+func (p *pipeStream) CloseSend() error {
+	p.closeRemote()
+	return nil
+}
+
+// Close closes the stream.
+func (p *pipeStream) Close() error {
+	p.ctxCancel()
+	p.closeRemote()
+	return nil
+}
+
+// closeRemote closes the remote data channel.
+func (p *pipeStream) closeRemote() {
+	p.closeOnce.Do(func() {
+		close(p.other.dataCh)
+	})
+}
+
+// _ is a type assertion
+var _ Stream = ((*pipeStream)(nil))

package/srpc/stream.go

@@ -0,0 +1,24 @@
+package srpc
+
+import (
+	"context"
+)
+
+// Stream is a handle to an on-going bi-directional or one-directional stream RPC handle.
+type Stream interface {
+	// Context is canceled when the Stream is no longer valid.
+	Context() context.Context
+
+	// MsgSend sends the message to the remote.
+	MsgSend(msg Message) error
+
+	// MsgRecv receives an incoming message from the remote.
+	// Parses the message into the object at msg.
+	MsgRecv(msg Message) error
+
+	// CloseSend signals to the remote that we will no longer send any messages.
+	CloseSend() error
+
+	// Close closes the stream.
+	Close() error
+}

package/srpc/stream.ts

@@ -0,0 +1,11 @@
+import type { Packet } from './rpcproto'
+import type { Duplex } from 'it-stream-types'
+
+// PacketHandler handles incoming packets.
+export type PacketHandler = (packet: Packet) => Promise<void>
+
+// Stream is an open connection.
+export type Stream = Duplex<Uint8Array>
+
+// OpenStreamFunc is a function to start a new RPC by opening a Stream.
+export type OpenStreamFunc = () => Promise<Stream>

package/srpc/ts-proto-rpc.ts

@@ -0,0 +1,29 @@
+import type { Observable } from 'rxjs'
+
+// TsProtoRpc matches the Rpc interface generated by ts-proto.
+export interface TsProtoRpc {
+  // request fires a one-off unary RPC request.
+  request(
+    service: string,
+    method: string,
+    data: Uint8Array
+  ): Promise<Uint8Array>
+  // clientStreamingRequest fires a one-way client->server streaming request.
+  clientStreamingRequest(
+    service: string,
+    method: string,
+    data: Observable<Uint8Array>
+  ): Promise<Uint8Array>
+  // serverStreamingRequest fires a one-way server->client streaming request.
+  serverStreamingRequest(
+    service: string,
+    method: string,
+    data: Uint8Array
+  ): Observable<Uint8Array>
+  // bidirectionalStreamingRequest implements a two-way streaming request.
+  bidirectionalStreamingRequest(
+    service: string,
+    method: string,
+    data: Observable<Uint8Array>
+  ): Observable<Uint8Array>
+}

package/srpc/websocket.go

@@ -0,0 +1,68 @@
+package srpc
+
+import (
+	"context"
+	"io"
+
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p/p2p/muxer/mplex"
+	"nhooyr.io/websocket"
+)
+
+// WebSocketConn implements the p2p multiplexer over a WebSocket.
+type WebSocketConn struct {
+	// conn is the websocket conn
+	conn *websocket.Conn
+	// mconn is the muxed conn
+	mconn network.MuxedConn
+}
+
+// NewWebSocketConn constructs a new WebSocket connection.
+func NewWebSocketConn(ctx context.Context, conn *websocket.Conn, isServer bool) (*WebSocketConn, error) {
+	nc := websocket.NetConn(ctx, conn, websocket.MessageBinary)
+	muxedConn, err := mplex.DefaultTransport.NewConn(nc, isServer, network.NullScope)
+	if err != nil {
+		return nil, err
+	}
+	return &WebSocketConn{conn: conn, mconn: muxedConn}, nil
+}
+
+// GetWebSocket returns the web socket conn.
+func (w *WebSocketConn) GetWebSocket() *websocket.Conn {
+	return w.conn
+}
+
+// GetOpenStreamFunc returns the OpenStream func.
+func (w *WebSocketConn) GetOpenStreamFunc() OpenStreamFunc {
+	return w.OpenStream
+}
+
+// AcceptStream accepts an incoming stream.
+func (w *WebSocketConn) AcceptStream() (io.ReadWriteCloser, error) {
+	return w.mconn.AcceptStream()
+}
+
+// OpenStream tries to open a stream with the remote.
+func (w *WebSocketConn) OpenStream(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error) {
+	muxedStream, err := w.mconn.OpenStream(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	rw := NewPacketReadWriter(muxedStream, msgHandler)
+	go func() {
+		err := rw.ReadPump()
+		if err != nil {
+			_ = rw.Close()
+		}
+	}()
+	return rw, nil
+}
+
+// Close closes the writer.
+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

@@ -0,0 +1,22 @@
+import { Conn } from './conn.js'
+import { duplex } from 'it-ws'
+import { pipe } from 'it-pipe'
+import type WebSocket from 'isomorphic-ws'
+
+// WebSocketConn implements a connection with a WebSocket.
+export class WebSocketConn extends Conn {
+  // socket is the web socket
+  private socket: WebSocket
+
+  constructor(socket: WebSocket) {
+    super()
+    this.socket = socket
+    const socketDuplex = duplex(socket)
+    pipe(this.source, socketDuplex, this.sink)
+  }
+
+  // getSocket returns the websocket.
+  public getSocket(): WebSocket {
+    return this.socket
+  }
+}

package/srpc/writer.go

@@ -0,0 +1,9 @@
+package srpc
+
+// Writer is the interface used to write messages to the remote.
+type Writer interface {
+	// WritePacket writes a packet to the remote.
+	WritePacket(p *Packet) error
+	// Close closes the writer.
+	Close() error
+}