Move to typical go project layout, fix golangci-lint warnings, update deps

vendor/github.com/alitto/pond/README.md

@@ -193,17 +193,28 @@ func main() {
 
 ### Pool Configuration Options
 
-- **MinWorkers**: Specifies the minimum number of worker goroutines that must be running at any given time. These goroutines are started when the pool is created. The default value is 0. Example:
+#### MinWorkers
+
+Specifies the minimum number of worker goroutines that must be running at any given time. These goroutines are started when the pool is created. The default value is 0. Example:
+
 ``` go
 // This will create a pool with 5 running worker goroutines 
 pool := pond.New(10, 1000, pond.MinWorkers(5))
 ```
-- **IdleTimeout**: Defines how long to wait before removing idle worker goroutines from the pool. The default value is 5 seconds. Example:
+
+#### IdleTimeout
+
+Defines how long to wait before removing idle worker goroutines from the pool. The default value is 5 seconds. Example:
+
 ``` go
 // This will create a pool that will remove workers 100ms after they become idle 
 pool := pond.New(10, 1000, pond.IdleTimeout(100 * time.Millisecond))
 ``` 
-- **PanicHandler**: Allows to configure a custom function to handle panics thrown by tasks submitted to the pool. The default handler just writes a message to standard output using `fmt.Printf` with the following contents: `Worker exits from a panic: [panic] \n Stack trace: [stack trace]`).  Example:
+
+#### PanicHandler
+
+Allows to configure a custom function to handle panics thrown by tasks submitted to the pool. The default handler just writes a message to standard output using `fmt.Printf` with the following contents: `Worker exits from a panic: [panic] \n Stack trace: [stack trace]`).  Example:
+
 ```go
 // Custom panic handler function
 panicHandler := func(p interface{}) {
@@ -213,17 +224,26 @@ panicHandler := func(p interface{}) {
 // This will create a pool that will handle panics using a custom panic handler
 pool := pond.New(10, 1000, pond.PanicHandler(panicHandler)))
 ```
-- **Strategy**: Configures the strategy used to resize the pool when backpressure is detected. You can create a custom strategy by implementing the `pond.ResizingStrategy` interface or choose one of the 3 presets:
-    - **Eager**: maximizes responsiveness at the expense of higher resource usage, which can reduce throughput under certain conditions. This strategy is meant for worker pools that will operate at a small percentage of their capacity most of the time and may occasionally receive bursts of tasks. This is the default strategy.
-	- **Balanced**: tries to find a balance between responsiveness and throughput. It's suitable for general purpose worker pools or those that will operate close to 50% of their capacity most of the time.
-	- **Lazy**: maximizes throughput at the expense of responsiveness. This strategy is meant for worker pools that will operate close to their max. capacity most of the time.
+
+#### Strategy
+
+Configures the strategy used to resize the pool when backpressure is detected. You can create a custom strategy by implementing the `pond.ResizingStrategy` interface or choose one of the 3 presets:
+
+- **Eager**: maximizes responsiveness at the expense of higher resource usage, which can reduce throughput under certain conditions. This strategy is meant for worker pools that will operate at a small percentage of their capacity most of the time and may occasionally receive bursts of tasks. This is the default strategy.
+- **Balanced**: tries to find a balance between responsiveness and throughput. It's suitable for general purpose worker pools or those that will operate close to 50% of their capacity most of the time.
+- **Lazy**: maximizes throughput at the expense of responsiveness. This strategy is meant for worker pools that will operate close to their max. capacity most of the time.
+
 ``` go
 // Example: create pools with different resizing strategies
 eagerPool := pond.New(10, 1000, pond.Strategy(pond.Eager()))
 balancedPool := pond.New(10, 1000, pond.Strategy(pond.Balanced()))
 lazyPool := pond.New(10, 1000, pond.Strategy(pond.Lazy()))
 ```
-- **Context**: Configures a parent context on this pool to stop all workers when it is cancelled. The default value `context.Background()`. Example:
+
+#### Context
+
+Configures a parent context on this pool to stop all workers when it is cancelled. The default value `context.Background()`. Example:
+
 ``` go
 // This creates a pool that is stopped when myCtx is cancelled 
 pool := pond.New(10, 1000, pond.Context(myCtx))

vendor/github.com/alitto/pond/codecov.yml

@@ -0,0 +1,8 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 90%
+    patch:
+      default:
+        target: 90%

vendor/github.com/alitto/pond/pond.go

@@ -318,8 +318,14 @@ func (p *WorkerPool) SubmitBefore(task func(), deadline time.Duration) {
 // Stop causes this pool to stop accepting new tasks and signals all workers to exit.
 // Tasks being executed by workers will continue until completion (unless the process is terminated).
 // Tasks in the queue will not be executed.
-func (p *WorkerPool) Stop() {
-	go p.stop(false)
+// This method returns a context object that is cancelled when the pool has stopped completely.
+func (p *WorkerPool) Stop() context.Context {
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		p.stop(false)
+		cancel()
+	}()
+	return ctx
 }
 
 // StopAndWait causes this pool to stop accepting new tasks and then waits for all tasks in the queue
@@ -371,6 +377,7 @@ func (p *WorkerPool) stop(waitForQueuedTasksToComplete bool) {
 	p.tasksCloseOnce.Do(func() {
 		close(p.tasks)
 	})
+
 }
 
 // purge represents the work done by the purger goroutine
@@ -420,7 +427,7 @@ func (p *WorkerPool) maybeStartWorker(firstTask func()) bool {
 	}
 
 	// Launch worker goroutine
-	go worker(p.context, &p.workersWaitGroup, firstTask, p.tasks, p.executeTask)
+	go worker(p.context, &p.workersWaitGroup, firstTask, p.tasks, p.executeTask, &p.tasksWaitGroup)
 
 	return true
 }

vendor/github.com/alitto/pond/worker.go

@@ -6,7 +6,7 @@ import (
 )
 
 // worker represents a worker goroutine
-func worker(context context.Context, waitGroup *sync.WaitGroup, firstTask func(), tasks <-chan func(), taskExecutor func(func(), bool)) {
+func worker(context context.Context, waitGroup *sync.WaitGroup, firstTask func(), tasks <-chan func(), taskExecutor func(func(), bool), taskWaitGroup *sync.WaitGroup) {
 
 	// If provided, execute the first task immediately, before listening to the tasks channel
 	if firstTask != nil {
@@ -20,16 +20,43 @@ func worker(context context.Context, waitGroup *sync.WaitGroup, firstTask func()
 	for {
 		select {
 		case <-context.Done():
-			// Pool context was cancelled, exit
+			// Pool context was cancelled, empty tasks channel and exit
+			drainTasks(tasks, taskWaitGroup)
 			return
 		case task, ok := <-tasks:
-			if task == nil || !ok {
-				// We have received a signal to exit
+			// Prioritize context.Done statement (https://stackoverflow.com/questions/46200343/force-priority-of-go-select-statement)
+			select {
+			case <-context.Done():
+				if task != nil && ok {
+					// We have received a task, ignore it
+					taskWaitGroup.Done()
+				}
+				// Pool context was cancelled, empty tasks channel and exit
+				drainTasks(tasks, taskWaitGroup)
 				return
-			}
+			default:
+				if task == nil || !ok {
+					// We have received a signal to exit
+					return
+				}
 
-			// We have received a task, execute it
-			taskExecutor(task, false)
+				// We have received a task, execute it
+				taskExecutor(task, false)
+			}
+		}
+	}
+}
+
+// drainPendingTasks discards queued tasks and decrements the corresponding wait group
+func drainTasks(tasks <-chan func(), tasksWaitGroup *sync.WaitGroup) {
+	for {
+		select {
+		case task, ok := <-tasks:
+			if task != nil && ok {
+				tasksWaitGroup.Done()
+			}
+		default:
+			return
 		}
 	}
 }