You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
59 lines
1.5 KiB
59 lines
1.5 KiB
package p2p
|
|
|
|
import "sync"
|
|
|
|
// queue does QoS scheduling for Envelopes, enqueueing and dequeueing according
|
|
// to some policy. Queues are used at contention points, i.e.:
|
|
//
|
|
// - Receiving inbound messages to a single channel from all peers.
|
|
// - Sending outbound messages to a single peer from all channels.
|
|
type queue interface {
|
|
// enqueue returns a channel for submitting envelopes.
|
|
enqueue() chan<- Envelope
|
|
|
|
// dequeue returns a channel ordered according to some queueing policy.
|
|
dequeue() <-chan Envelope
|
|
|
|
// close closes the queue. After this call enqueue() will block, so the
|
|
// caller must select on closed() as well to avoid blocking forever. The
|
|
// enqueue() and dequeue() channels will not be closed.
|
|
close()
|
|
|
|
// closed returns a channel that's closed when the scheduler is closed.
|
|
closed() <-chan struct{}
|
|
}
|
|
|
|
// fifoQueue is a simple unbuffered lossless queue that passes messages through
|
|
// in the order they were received, and blocks until message is received.
|
|
type fifoQueue struct {
|
|
queueCh chan Envelope
|
|
closeCh chan struct{}
|
|
closeOnce sync.Once
|
|
}
|
|
|
|
var _ queue = (*fifoQueue)(nil)
|
|
|
|
func newFIFOQueue(size int) *fifoQueue {
|
|
return &fifoQueue{
|
|
queueCh: make(chan Envelope, size),
|
|
closeCh: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
func (q *fifoQueue) enqueue() chan<- Envelope {
|
|
return q.queueCh
|
|
}
|
|
|
|
func (q *fifoQueue) dequeue() <-chan Envelope {
|
|
return q.queueCh
|
|
}
|
|
|
|
func (q *fifoQueue) close() {
|
|
q.closeOnce.Do(func() {
|
|
close(q.closeCh)
|
|
})
|
|
}
|
|
|
|
func (q *fifoQueue) closed() <-chan struct{} {
|
|
return q.closeCh
|
|
}
|