starpc 0.33.1 → 0.33.4

package/package.json

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

package/srpc/client-rpc.go

@@ -32,21 +32,26 @@ func (r *ClientRPC) Start(writer PacketWriter, writeFirstMsg bool, firstMsg []by
 		return context.Canceled
 	}
 
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-	defer r.bcast.Broadcast()
-	r.writer = writer
 	var firstMsgEmpty bool
-	if writeFirstMsg {
-		firstMsgEmpty = len(firstMsg) == 0
-	}
-	pkt := NewCallStartPacket(r.service, r.method, firstMsg, firstMsgEmpty)
-	if err := writer.WritePacket(pkt); err != nil {
-		r.ctxCancel()
-		_ = writer.Close()
-		return err
-	}
-	return nil
+	var err error
+	r.bcast.HoldLock(func(broadcast func(), getWaitCh func() <-chan struct{}) {
+		r.writer = writer
+
+		if writeFirstMsg {
+			firstMsgEmpty = len(firstMsg) == 0
+		}
+
+		pkt := NewCallStartPacket(r.service, r.method, firstMsg, firstMsgEmpty)
+		err = writer.WritePacket(pkt)
+		if err != nil {
+			r.ctxCancel()
+			_ = writer.Close()
+		}
+
+		broadcast()
+	})
+
+	return err
 }
 
 // HandlePacketData handles an incoming unparsed message packet.
@@ -60,14 +65,14 @@ func (r *ClientRPC) HandlePacketData(data []byte) error {
 
 // HandleStreamClose handles the stream closing optionally w/ an error.
 func (r *ClientRPC) HandleStreamClose(closeErr error) {
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-	defer r.bcast.Broadcast()
-	if closeErr != nil && r.remoteErr == nil {
-		r.remoteErr = closeErr
-	}
-	r.dataClosed = true
-	r.ctxCancel()
+	r.bcast.HoldLock(func(broadcast func(), getWaitCh func() <-chan struct{}) {
+		if closeErr != nil && r.remoteErr == nil {
+			r.remoteErr = closeErr
+		}
+		r.dataClosed = true
+		r.ctxCancel()
+		broadcast()
+	})
 }
 
 // HandlePacket handles an incoming parsed message packet.
@@ -102,8 +107,8 @@ func (r *ClientRPC) Close() {
 	if r.writer != nil {
 		_ = r.WriteCancel()
 	}
-	r.mtx.Lock()
-	r.closeLocked()
-	r.bcast.Broadcast()
-	r.mtx.Unlock()
+
+	r.bcast.HoldLock(func(broadcast func(), getWaitCh func() <-chan struct{}) {
+		r.closeLocked(broadcast)
+	})
 }

package/srpc/common-rpc.go

@@ -3,7 +3,6 @@ package srpc
 import (
 	"context"
 	"io"
-	"sync"
 
 	"github.com/aperturerobotics/util/broadcast"
 	"github.com/pkg/errors"
@@ -19,9 +18,7 @@ type commonRPC struct {
 	service string
 	// method is the rpc method
 	method string
-	// mtx guards below fields
-	mtx sync.Mutex
-	// bcast broadcasts when below fields change
+	// bcast guards below fields
 	bcast broadcast.Broadcast
 	// writer is the writer to write messages to
 	writer PacketWriter
@@ -45,21 +42,25 @@ func (c *commonRPC) Context() context.Context {
 	return c.ctx
 }
 
-// Wait waits for the RPC to finish.
+// Wait waits for the RPC to finish (remote end closed the stream).
 func (c *commonRPC) Wait(ctx context.Context) error {
 	for {
-		c.mtx.Lock()
-		if c.dataClosed {
-			err := c.remoteErr
-			c.mtx.Unlock()
+		var dataClosed bool
+		var err error
+		var waitCh <-chan struct{}
+		c.bcast.HoldLock(func(broadcast func(), getWaitCh func() <-chan struct{}) {
+			dataClosed, err = c.dataClosed, c.remoteErr
+			waitCh = getWaitCh()
+		})
+
+		if dataClosed {
 			return err
 		}
-		waiter := c.bcast.GetWaitCh()
-		c.mtx.Unlock()
+
 		select {
 		case <-ctx.Done():
 			return context.Canceled
-		case <-waiter:
+		case <-waitCh:
 		}
 	}
 }
@@ -68,39 +69,43 @@ func (c *commonRPC) Wait(ctx context.Context) error {
 //
 // returns io.EOF if the stream ended without a packet.
 func (c *commonRPC) ReadOne() ([]byte, error) {
+	var hasMsg bool
 	var msg []byte
 	var err error
 	var ctxDone bool
 	for {
-		c.mtx.Lock()
-		waiter := c.bcast.GetWaitCh()
-		if ctxDone && !c.dataClosed {
-			// context must have been canceled locally
-			c.closeLocked()
-			err = context.Canceled
-			c.mtx.Unlock()
-			return nil, err
-		}
-		if len(c.dataQueue) != 0 {
-			msg = c.dataQueue[0]
-			c.dataQueue[0] = nil
-			c.dataQueue = c.dataQueue[1:]
-			c.mtx.Unlock()
-			return msg, nil
-		}
-		if c.dataClosed || c.remoteErr != nil {
-			err = c.remoteErr
-			if err == nil {
-				err = io.EOF
+		var waitCh <-chan struct{}
+		c.bcast.HoldLock(func(broadcast func(), getWaitCh func() <-chan struct{}) {
+			if ctxDone && !c.dataClosed {
+				// context must have been canceled locally
+				c.closeLocked(broadcast)
+				err = context.Canceled
+				return
 			}
-			c.mtx.Unlock()
-			return nil, err
+
+			if len(c.dataQueue) != 0 {
+				msg = c.dataQueue[0]
+				hasMsg = true
+				c.dataQueue[0] = nil
+				c.dataQueue = c.dataQueue[1:]
+			} else if c.dataClosed || c.remoteErr != nil {
+				err = c.remoteErr
+				if err == nil {
+					err = io.EOF
+				}
+			}
+
+			waitCh = getWaitCh()
+		})
+
+		if hasMsg || err != nil {
+			return msg, err
 		}
-		c.mtx.Unlock()
+
 		select {
 		case <-c.ctx.Done():
 			ctxDone = true
-		case <-waiter:
+		case <-waitCh:
 		}
 	}
 }
@@ -116,17 +121,17 @@ func (c *commonRPC) WriteCallData(data []byte, complete bool, err error) error {
 
 // HandleStreamClose handles the incoming stream closing w/ optional error.
 func (c *commonRPC) HandleStreamClose(closeErr error) {
-	c.mtx.Lock()
-	defer c.mtx.Unlock()
-	if closeErr != nil && c.remoteErr == nil {
-		c.remoteErr = closeErr
-	}
-	c.dataClosed = true
-	c.ctxCancel()
-	if c.writer != nil {
-		_ = c.writer.Close()
-	}
-	c.bcast.Broadcast()
+	c.bcast.HoldLock(func(broadcast func(), getWaitCh func() <-chan struct{}) {
+		if closeErr != nil && c.remoteErr == nil {
+			c.remoteErr = closeErr
+		}
+		c.dataClosed = true
+		c.ctxCancel()
+		if c.writer != nil {
+			_ = c.writer.Close()
+		}
+		broadcast()
+	})
 }
 
 // HandleCallCancel handles the call cancel packet.
@@ -137,29 +142,31 @@ func (c *commonRPC) HandleCallCancel() error {
 
 // HandleCallData handles the call data packet.
 func (c *commonRPC) HandleCallData(pkt *CallData) error {
-	c.mtx.Lock()
-	defer c.mtx.Unlock()
+	var err error
+	c.bcast.HoldLock(func(broadcast func(), getWaitCh func() <-chan struct{}) {
+		if c.dataClosed {
+			err = ErrCompleted
+			return
+		}
 
-	if c.dataClosed {
-		return ErrCompleted
-	}
+		if data := pkt.GetData(); len(data) != 0 || pkt.GetDataIsZero() {
+			c.dataQueue = append(c.dataQueue, data)
+		}
 
-	if data := pkt.GetData(); len(data) != 0 || pkt.GetDataIsZero() {
-		c.dataQueue = append(c.dataQueue, data)
-	}
+		complete := pkt.GetComplete()
+		if err := pkt.GetError(); len(err) != 0 {
+			complete = true
+			c.remoteErr = errors.New(err)
+		}
 
-	complete := pkt.GetComplete()
-	if err := pkt.GetError(); len(err) != 0 {
-		complete = true
-		c.remoteErr = errors.New(err)
-	}
+		if complete {
+			c.dataClosed = true
+		}
 
-	if complete {
-		c.dataClosed = true
-	}
+		broadcast()
+	})
 
-	c.bcast.Broadcast()
-	return nil
+	return err
 }
 
 // WriteCancel writes a call cancel packet.
@@ -171,7 +178,7 @@ func (c *commonRPC) WriteCancel() error {
 }
 
 // closeLocked releases resources held by the RPC.
-func (c *commonRPC) closeLocked() {
+func (c *commonRPC) closeLocked(broadcast func()) {
 	c.dataClosed = true
 	if c.remoteErr == nil {
 		c.remoteErr = context.Canceled
@@ -179,6 +186,6 @@ func (c *commonRPC) closeLocked() {
 	if c.writer != nil {
 		_ = c.writer.Close()
 	}
-	c.bcast.Broadcast()
+	broadcast()
 	c.ctxCancel()
 }

package/srpc/server-rpc.go

@@ -57,27 +57,33 @@ func (r *ServerRPC) HandlePacket(msg *Packet) error {
 
 // HandleCallStart handles the call start packet.
 func (r *ServerRPC) HandleCallStart(pkt *CallStart) error {
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-	// process start: method and service
-	if r.method != "" || r.service != "" {
-		return errors.New("call start must be sent only once")
-	}
-	if r.dataClosed {
-		return ErrCompleted
-	}
-	service, method := pkt.GetRpcService(), pkt.GetRpcMethod()
-	r.service, r.method = service, method
+	var err error
 
-	// process first data packet, if included
-	if data := pkt.GetData(); len(data) != 0 || pkt.GetDataIsZero() {
-		r.dataQueue = append(r.dataQueue, data)
-	}
+	r.bcast.HoldLock(func(broadcast func(), getWaitCh func() <-chan struct{}) {
+		// process start: method and service
+		if r.method != "" || r.service != "" {
+			err = errors.New("call start must be sent only once")
+			return
+		}
+		if r.dataClosed {
+			err = ErrCompleted
+			return
+		}
+
+		service, method := pkt.GetRpcService(), pkt.GetRpcMethod()
+		r.service, r.method = service, method
+
+		// process first data packet, if included
+		if data := pkt.GetData(); len(data) != 0 || pkt.GetDataIsZero() {
+			r.dataQueue = append(r.dataQueue, data)
+		}
+
+		// invoke the rpc
+		broadcast()
+		go r.invokeRPC(service, method)
+	})
 
-	// invoke the rpc
-	r.bcast.Broadcast()
-	go r.invokeRPC(service, method)
-	return nil
+	return err
 }
 
 // invokeRPC invokes the RPC after CallStart is received.