starpc 0.8.2 → 0.8.5

package/echo/server.go

@@ -21,6 +21,11 @@ func NewEchoServer(rpcStreamMux srpc.Mux) *EchoServer {
 	return &EchoServer{rpcStreamMux: rpcStreamMux}
 }
 
+// Register registers the Echo server with the Mux.
+func (e *EchoServer) Register(mux srpc.Mux) error {
+	return SRPCRegisterEchoer(mux, e)
+}
+
 // Echo implements echo.SRPCEchoerServer
 func (*EchoServer) Echo(ctx context.Context, msg *EchoMsg) (*EchoMsg, error) {
 	return proto.Clone(msg).(*EchoMsg), nil

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.8.2",
+  "version": "0.8.5",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/accept.go

@@ -0,0 +1,29 @@
+package srpc
+
+import (
+	"context"
+	"net"
+)
+
+// AcceptMuxedListener accepts incoming connections from a net.Listener.
+//
+// Uses the default mplex muxer.
+func AcceptMuxedListener(ctx context.Context, lis net.Listener, srv *Server) error {
+	for {
+		nc, err := lis.Accept()
+		if err != nil {
+			return err
+		}
+
+		mc, err := NewMuxedConn(nc, true)
+		if err != nil {
+			_ = nc.Close()
+			continue
+		}
+
+		if err := srv.AcceptMuxedConn(ctx, mc); err != nil {
+			_ = nc.Close()
+			continue
+		}
+	}
+}

package/srpc/client-rpc.go

@@ -2,6 +2,7 @@ package srpc
 
 import (
 	"context"
+	"io"
 
 	"github.com/pkg/errors"
 )
@@ -86,6 +87,24 @@ func (r *ClientRPC) ReadAll() ([][]byte, error) {
 	}
 }
 
+// ReadOne reads a single message and returns.
+//
+// returns io.EOF if the stream ended.
+func (r *ClientRPC) ReadOne() ([]byte, error) {
+	select {
+	case <-r.ctx.Done():
+		return nil, context.Canceled
+	case data, ok := <-r.dataCh:
+		if !ok {
+			if err := r.serverErr; err != nil {
+				return nil, err
+			}
+			return nil, io.EOF
+		}
+		return data, nil
+	}
+}
+
 // Context is canceled when the ClientRPC is no longer valid.
 func (r *ClientRPC) Context() context.Context {
 	return r.ctx

package/srpc/client.go

@@ -2,7 +2,6 @@ package srpc
 
 import (
 	"context"
-	"io"
 
 	"github.com/pkg/errors"
 )
@@ -55,17 +54,12 @@ func (c *client) Invoke(rctx context.Context, service, method string, in, out Me
 	if err := clientRPC.Start(writer, true, firstMsg); err != nil {
 		return err
 	}
-	msgs, err := clientRPC.ReadAll()
+	msg, err := clientRPC.ReadOne()
 	if err != nil {
 		// this includes any server returned error.
 		return err
 	}
-	if len(msgs) == 0 {
-		// no reply? return eof.
-		return io.EOF
-	}
-	// parse first message to out
-	if err := out.UnmarshalVT(msgs[0]); err != nil {
+	if err := out.UnmarshalVT(msg); err != nil {
 		return errors.Wrap(ErrInvalidMessage, err.Error())
 	}
 	// done

package/srpc/packet-rw.go

@@ -2,6 +2,7 @@ package srpc
 
 import (
 	"bytes"
+	"context"
 	"encoding/binary"
 	"io"
 
@@ -34,7 +35,15 @@ func (r *PacketReaderWriter) WritePacket(p *Packet) error {
 	if err != nil {
 		return err
 	}
-	_, err = r.rw.Write(data)
+	var n int
+	written := 0
+	for written < len(data) {
+		n, err = r.rw.Write(data)
+		if err != nil {
+			return err
+		}
+		written += n
+	}
 	return err
 }
 
@@ -54,15 +63,18 @@ func (r *PacketReaderWriter) ReadPump(cb PacketHandler, closed CloseHandler) {
 func (r *PacketReaderWriter) ReadToHandler(cb PacketHandler) error {
 	var currLen uint32
 	buf := make([]byte, 2048)
-	for {
+	isOpen := true
+	for isOpen {
 		// read some data into the buffer
 		n, err := r.rw.Read(buf)
 		if err != nil {
-			if err == io.EOF {
-				err = nil
+			if err == io.EOF || err == context.Canceled {
+				isOpen = false
+			} else {
+				return err
 			}
-			return err
 		}
+
 		// push the data to r.buf
 		_, err = r.buf.Write(buf[:n])
 		if err != nil {
@@ -99,6 +111,9 @@ func (r *PacketReaderWriter) ReadToHandler(cb PacketHandler) error {
 			}
 		}
 	}
+
+	// closed
+	return nil
 }
 
 // Close closes the packet rw.

package/srpc/server-rpc.go

@@ -2,6 +2,7 @@ package srpc
 
 import (
 	"context"
+	"io"
 
 	"github.com/pkg/errors"
 )
@@ -66,12 +67,19 @@ func (r *ServerRPC) Wait(ctx context.Context) error {
 
 // HandleStreamClose handles the incoming stream closing w/ optional error.
 func (r *ServerRPC) HandleStreamClose(closeErr error) {
+	if r.dataChClosed {
+		return
+	}
 	if closeErr != nil {
 		if r.clientErr == nil {
 			r.clientErr = closeErr
 		}
-		r.Close()
+		if closeErr != io.EOF && closeErr != context.Canceled {
+			r.Close()
+		}
 	}
+	r.dataChClosed = true
+	close(r.dataCh)
 }
 
 // HandlePacket handles an incoming parsed message packet.
@@ -163,8 +171,8 @@ func (r *ServerRPC) invokeRPC() {
 	}
 	outPkt := NewCallDataPacket(nil, false, true, err)
 	_ = r.writer.WritePacket(outPkt)
-	r.ctxCancel()
 	_ = r.writer.Close()
+	r.ctxCancel()
 }
 
 // Close releases any resources held by the ServerRPC.
@@ -173,9 +181,9 @@ func (r *ServerRPC) Close() {
 	if r.clientErr == nil {
 		r.clientErr = context.Canceled
 	}
-	r.ctxCancel()
 	if r.service == "" {
 		// invokeRPC has not been called, otherwise it would call Close()
 		_ = r.writer.Close()
 	}
+	r.ctxCancel()
 }