functions: common concurrency stream for sync and async (#314)

* functions: add bounded concurrency

* functions: plug runners to sync and async interfaces

* functions: update documentation about the new env var

* functions: fix test flakiness

* functions: the runner is self-regulated, no need to set a number of runners

* functions: push the execution to the background on incoming requests

* functions: ensure async tasks are always on

* functions: add prioritization to tasks consumption

Ensure that Sync tasks are consumed before Async tasks. Also, fixes
termination races problems for free.

* functions: remove stale comments

* functions: improve mem availability calculation

* functions: parallel run for async tasks

* functions: check for memory availability before pulling async task

* functions: comment about rnr.hasAvailableMemory and sync.Cond

* functions: implement memory check for async runners using Cond vars

* functions: code grooming

- remove unnecessary goroutines
- fix stale docs
- reorganize import group

* Revert "functions: implement memory check for async runners using Cond vars"

This reverts commit 922e64032201a177c03ce6a46240925e3d35430d.

* Revert "functions: comment about rnr.hasAvailableMemory and sync.Cond"

This reverts commit 49ad7d52d341f12da9603b1a1df9d145871f0e0a.

* functions: set a minimum memory availability for sync

* functions: simplify the implementation by removing the priority queue

* functions: code grooming

- code deduplication
- review waitgroups Waits

api/runner/worker.go

@@ -0,0 +1,52 @@
+package runner
+
+import (
+	"context"
+	"sync"
+
+	"github.com/iron-io/runner/drivers"
+)
+
+type TaskRequest struct {
+	Ctx      context.Context
+	Config   *Config
+	Response chan TaskResponse
+}
+
+type TaskResponse struct {
+	Result drivers.RunResult
+	Err    error
+}
+
+// StartWorkers handle incoming tasks and spawns self-regulating container
+// workers.
+func StartWorkers(ctx context.Context, rnr *Runner, tasks <-chan TaskRequest) {
+	var wg sync.WaitGroup
+	for {
+		select {
+		case <-ctx.Done():
+			wg.Wait()
+			return
+		case task := <-tasks:
+			wg.Add(1)
+			go func(task TaskRequest) {
+				defer wg.Done()
+				result, err := rnr.Run(task.Ctx, task.Config)
+				select {
+				case task.Response <- TaskResponse{result, err}:
+					close(task.Response)
+				default:
+				}
+			}(task)
+		}
+	}
+
+}
+
+func RunTask(tasks chan TaskRequest, ctx context.Context, cfg *Config) (drivers.RunResult, error) {
+	tresp := make(chan TaskResponse)
+	treq := TaskRequest{Ctx: ctx, Config: cfg, Response: tresp}
+	tasks <- treq
+	resp := <-treq.Response
+	return resp.Result, resp.Err
+}