clean up channel use

peer/queue/sync.go

@@ -9,31 +9,42 @@ import (
 // ChanQueue makes any PeerQueue synchronizable through channels.
 type ChanQueue struct {
 	Queue   PeerQueue
-	EnqChan chan *peer.Peer
-	DeqChan chan *peer.Peer
+	EnqChan chan<- *peer.Peer
+	DeqChan <-chan *peer.Peer
 }
 
 // NewChanQueue creates a ChanQueue by wrapping pq.
 func NewChanQueue(ctx context.Context, pq PeerQueue) *ChanQueue {
-	cq := &ChanQueue{
-		Queue:   pq,
-		EnqChan: make(chan *peer.Peer, 10),
-		DeqChan: make(chan *peer.Peer, 10),
-	}
-	go cq.process(ctx)
+	cq := &ChanQueue{Queue: pq}
+	cq.process(ctx)
 	return cq
 }
 
 func (cq *ChanQueue) process(ctx context.Context) {
+
+	// construct the channels here to be able to use them bidirectionally
+	enqChan := make(chan *peer.Peer, 10)
+	deqChan := make(chan *peer.Peer, 10)
+
+	cq.EnqChan = enqChan
+	cq.DeqChan = deqChan
+
+	go func() {
+		defer close(deqChan)
+
 		var next *peer.Peer
+		var item *peer.Peer
+		var more bool
 
 		for {
-
 			if cq.Queue.Len() == 0 {
 				select {
-			case next = <-cq.EnqChan:
+				case next, more = <-enqChan:
+					if !more {
+						return
+					}
+
 				case <-ctx.Done():
-				close(cq.DeqChan)
 					return
 				}
 
@@ -42,17 +53,22 @@ func (cq *ChanQueue) process(ctx context.Context) {
 			}
 
 			select {
-		case item := <-cq.EnqChan:
+			case item, more = <-enqChan:
+				if !more {
+					return
+				}
+
 				cq.Queue.Enqueue(item)
 				cq.Queue.Enqueue(next)
 				next = nil
 
-		case cq.DeqChan <- next:
+			case deqChan <- next:
 				next = nil
 
 			case <-ctx.Done():
-			close(cq.DeqChan)
 				return
 			}
 		}
+
+	}()
 }