refactor: move deployment limiter into context (#1841)

#### What this PR does / Why we need it:
Removes the global variable and puts deployment options into the
context, to prevent prop-drilling

#### Special notes for your reviewer:

Coverage check may fail because of these two lines inside the `if`
```go
if options.ConcurrentDeploymentsLimiter != nil {
	options.ConcurrentDeploymentsLimiter.Acquire()
	defer options.ConcurrentDeploymentsLimiter.Release()
}
```
The question is: do we want to test that?
Add a test that just checks if acquire/release was called? how: replace
the limiter struct inside the options with an interface and put a stub
into the context, so that the call can be checked.
Should we write an integration test for it? how: stubbed clients that
don't respond and we check if upserts were called
{limitedConcurrentCount} times

#### Does this PR introduce a user-facing change?
No

Author: Kirdock

pkg/deploy/deploy.go

@@ -62,17 +62,29 @@ type DeployConfigsOptions struct {
 }
 
 var (
-	lock                         sync.Mutex
-	concurrentDeploymentsLimiter *rest.ConcurrentRequestLimiter
-
+	lock    sync.Mutex
 	errSkip = errors.New("skip error")
 )
 
+type ctxDeploymentLimiterKey struct{}
+
+func newContextWithDeploymentLimiter(ctx context.Context, limiter *rest.ConcurrentRequestLimiter) context.Context {
+	return context.WithValue(ctx, ctxDeploymentLimiterKey{}, limiter)
+}
+
+func getDeploymentLimiterFromContext(ctx context.Context) *rest.ConcurrentRequestLimiter {
+	if limiter, ok := ctx.Value(ctxDeploymentLimiterKey{}).(*rest.ConcurrentRequestLimiter); ok {
+		return limiter
+	}
+	return nil
+}
+
 func DeployForAllEnvironments(ctx context.Context, projects []project.Project, environmentClients dynatrace.EnvironmentClients, opts DeployConfigsOptions) error {
 	maxConcurrentDeployments := environment.GetEnvValueIntLog(environment.ConcurrentDeploymentsEnvKey)
 	if maxConcurrentDeployments > 0 {
 		log.Info("%s set, limiting concurrent deployments to %d", environment.ConcurrentDeploymentsEnvKey, maxConcurrentDeployments)
-		concurrentDeploymentsLimiter = rest.NewConcurrentRequestLimiter(maxConcurrentDeployments)
+		limiter := rest.NewConcurrentRequestLimiter(maxConcurrentDeployments)
+		ctx = newContextWithDeploymentLimiter(ctx, limiter)
 	}
 	deploymentErrs := make(deployErrors.EnvironmentDeploymentErrors)
 
@@ -292,9 +304,9 @@ func (e ErrUnknownConfigType) Error() string {
 }
 
 func deployConfig(ctx context.Context, c *config.Config, clientset *client.ClientSet, resolvedEntities config.EntityLookup) (entities.ResolvedEntity, error) {
-	if concurrentDeploymentsLimiter != nil {
-		concurrentDeploymentsLimiter.Acquire()
-		defer concurrentDeploymentsLimiter.Release()
+	if limiter := getDeploymentLimiterFromContext(ctx); limiter != nil {
+		limiter.Acquire()
+		defer limiter.Release()
 	}
 
 	if c.Skip {