starpc 0.8.4 → 0.8.5

package/package.json

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

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

@@ -35,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
 }
 

package/srpc/server-rpc.go

@@ -3,8 +3,6 @@ package srpc
 import (
 	"context"
 	"io"
-	"runtime"
-	"time"
 
 	"github.com/pkg/errors"
 )
@@ -173,14 +171,6 @@ func (r *ServerRPC) invokeRPC() {
 	}
 	outPkt := NewCallDataPacket(nil, false, true, err)
 	_ = r.writer.WritePacket(outPkt)
-
-	// HACK: some multiplexers will drop the last packet if Close is called too
-	// soon after Write. Add a brief delay to ensure the packet is written.
-	//
-	// See: https://github.com/lucas-clemente/quic-go/issues/3472
-	runtime.Gosched()
-	time.Sleep(time.Millisecond)
-
 	_ = r.writer.Close()
 	r.ctxCancel()
 }