deprecate lifo, fifo queue limiters

limiter/queue_blocking.go

@@ -10,6 +10,8 @@ import (
 	"github.com/platinummonkey/go-concurrency-limits/core"
 )
 
+type EvictFunc func()
+
 // QueueOrdering defines the pattern for ordering requests on Pool
 type QueueOrdering string
 
@@ -34,7 +36,7 @@ func (e *queueElement) setListener(listener core.Listener) bool {
 		close(e.releaseChan)
 		return true
 	default:
-		// timeout has expired
+		// timeout has expired or context has been cancelled
 		return false
 	}
 }
@@ -68,12 +70,16 @@ func (q *queue) len() uint64 {
 	return uint64(q.list.Len())
 }
 
-func (q *queue) push(ctx context.Context) (func(), <-chan core.Listener) {
+func (q *queue) push(ctx context.Context) (EvictFunc, <-chan core.Listener) {
 	q.mu.Lock()
 	defer q.mu.Unlock()
 	releaseChan := make(chan core.Listener)
 
 	e := &queueElement{ctx: ctx, releaseChan: releaseChan}
+
+	// We always push to the front of the list regardless of
+	// queue order. As usage of the list will always assume
+	// Front == newest and Back == Oldest
 	listElement := q.list.PushFront(e)
 
 	return q.evictionFunc(listElement), releaseChan
@@ -88,7 +94,11 @@ func (q *queue) pop() *queueElement {
 	return ele
 }
 
-func (q *queue) peek() (func(), *queueElement) {
+// peek will return the next queue element to process
+// depending on the ordering configured in queue.
+// The element returned is not evicted from the queue
+// until EvictFunc is invoked
+func (q *queue) peek() (EvictFunc, *queueElement) {
 	q.mu.RLock()
 	defer q.mu.RUnlock()
 	if q.list.Len() > 0 {
@@ -106,7 +116,7 @@ func (q *queue) peek() (func(), *queueElement) {
 	return nil, nil
 }
 
-// QueueBlockingListener implements a blocking listener for the QueueBlockingListener
+// QueueBlockingListener implements a blocking listener for the QueueBlockingLimiter
 type QueueBlockingListener struct {
 	delegateListener core.Listener
 	limiter          *QueueBlockingLimiter
@@ -264,7 +274,8 @@ func (l *QueueBlockingLimiter) tryAcquire(ctx context.Context) core.Listener {
 	}
 
 	// Create a holder for a listener and block until a listener is released by another
-	// operation.  Holders will be unblocked in LIFO order
+	// operation.  Holders will be unblocked in LIFO or FIFO order depending on whatever
+	// ordering was configured when backlog was instantiated
 	evict, eventReleaseChan := l.backlog.push(ctx)
 
 	// We're using a nil chan so that we