[Feature] Propagate env variables to members (#1100)

Author: informalict

CHANGELOG.md

@@ -28,7 +28,8 @@
 - (Feature) Sensitive information protection
 - (Bugfix) Propagate SecurityContext to the ID Containers
 - (Bugfix) Fix for enabling all features
-
+- (Feature) Propagate feature and predefined env variables to members
+ 
 ## [1.2.15](https://github.com/arangodb/kube-arangodb/tree/1.2.15) (2022-07-20)
 - (Bugfix) Ensure pod names not too long
 - (Refactor) Use cached member's clients

chart/kube-arangodb/templates/deployment-operator/role.yaml

@@ -27,7 +27,7 @@ rules:
       verbs: ["*"]
 {{- end }}
     - apiGroups: [""]
-      resources: ["pods", "services", "endpoints", "persistentvolumeclaims", "events", "secrets", "serviceaccounts"]
+      resources: ["pods", "services", "endpoints", "persistentvolumeclaims", "events", "secrets", "serviceaccounts", "configmaps"]
       verbs: ["*"]
     - apiGroups: ["apps"]
       resources: ["deployments", "replicasets"]

cmd/cmd.go

@@ -27,6 +27,7 @@ import (
 	"net"
 	"net/http"
 	"os"
+	"reflect"
 	"strconv"
 	"strings"
 	"time"
@@ -120,6 +121,8 @@ var (
 		versionOnly                 bool // Run only version endpoint, explicitly disabled with other
 		enableK2KClusterSync        bool // Run k2kClusterSync operator
 
+		operatorFeatureConfigMap string // ConfigMap name
+
 		scalingIntegrationEnabled bool
 
 		alpineImage, metricsExporterImage, arangoImage string
@@ -320,6 +323,9 @@ func executeMain(cmd *cobra.Command, args []string) {
 		if err != nil {
 			logger.Err(err).Fatal("Failed to create operator config & deps")
 		}
+		if err := ensureFeaturesConfigMap(context.Background(), client.Kubernetes().CoreV1().ConfigMaps(namespace), cfg); err != nil {
+			logger.Err(err).Error("Failed to create features config map")
+		}
 		o, err := operator.NewOperator(cfg, deps)
 		if err != nil {
 			logger.Err(err).Fatal("Failed to create operator")
@@ -531,3 +537,53 @@ func createRecorder(kubecli kubernetes.Interface, name, namespace string) record
 	apps.AddToScheme(combinedScheme)
 	return eventBroadcaster.NewRecorder(combinedScheme, core.EventSource{Component: name})
 }
+
+// ensureFeaturesConfigMap creates or updates config map with enabled features.
+func ensureFeaturesConfigMap(ctx context.Context, client typedCore.ConfigMapInterface, cfg operator.Config) error {
+	ft := features.GetFeatureMap()
+
+	featuresCM := make(map[string]string, len(ft))
+
+	for k, v := range ft {
+		if v {
+			featuresCM[k] = features.Enabled
+		} else {
+			featuresCM[k] = features.Disabled
+		}
+	}
+
+	nctx, c := globals.GetGlobalTimeouts().Kubernetes().WithTimeout(ctx)
+	defer c()
+	if cm, err := client.Get(nctx, features.ConfigMapName(), meta.GetOptions{}); err != nil {
+		if !deploymentApi.IsNotFound(err) {
+			return err
+		}
+
+		nctx, c := globals.GetGlobalTimeouts().Kubernetes().WithTimeout(ctx)
+		defer c()
+		if _, err := client.Create(nctx, &core.ConfigMap{
+			ObjectMeta: meta.ObjectMeta{
+				Name:      features.ConfigMapName(),
+				Namespace: cfg.Namespace,
+			},
+			Data: make(map[string]string),
+		}, meta.CreateOptions{}); err != nil {
+			return err
+		}
+
+		return nil
+	} else if !reflect.DeepEqual(cm.Data, featuresCM) {
+		q := cm.DeepCopy()
+		q.Data = featuresCM
+
+		nctx, c := globals.GetGlobalTimeouts().Kubernetes().WithTimeout(ctx)
+		defer c()
+		if _, err := client.Update(nctx, q, meta.UpdateOptions{}); err != nil {
+			return err
+		}
+
+		return nil
+	}
+
+	return nil
+}

pkg/deployment/deployment_pod_volumes_test.go

@@ -172,7 +172,6 @@ func TestEnsurePod_ArangoDB_Volumes(t *testing.T) {
 				},
 			},
 		},
-
 		{
 			Name: "DBserver POD with Volume Mount",
 			ArangoDeployment: &api.ArangoDeployment{

pkg/deployment/deployment_suite_test.go

@@ -26,6 +26,7 @@ import (
 	"os"
 	"path/filepath"
 	"sort"
+	"strconv"
 	"strings"
 	"testing"
 
@@ -44,9 +45,11 @@ import (
 	"github.com/arangodb/kube-arangodb/pkg/apis/shared"
 	"github.com/arangodb/kube-arangodb/pkg/deployment/acs"
 	"github.com/arangodb/kube-arangodb/pkg/deployment/client"
+	"github.com/arangodb/kube-arangodb/pkg/deployment/features"
 	"github.com/arangodb/kube-arangodb/pkg/deployment/resources"
 	"github.com/arangodb/kube-arangodb/pkg/deployment/resources/inspector"
 	arangofake "github.com/arangodb/kube-arangodb/pkg/generated/clientset/versioned/fake"
+	"github.com/arangodb/kube-arangodb/pkg/util"
 	"github.com/arangodb/kube-arangodb/pkg/util/arangod/conn"
 	"github.com/arangodb/kube-arangodb/pkg/util/constants"
 	"github.com/arangodb/kube-arangodb/pkg/util/k8sutil"
@@ -608,6 +611,8 @@ func (testCase *testCaseStruct) createTestPodData(deployment *Deployment, group
 
 		deployment.currentObject.Status.Members.Update(member, group)
 	}
+
+	testCase.createTestEnvVariables(deployment, group)
 }
 
 func finalizers(group api.ServerGroup) []string {
@@ -786,3 +791,81 @@ func addLifecycle(name string, uuidRequired bool, license string, group api.Serv
 		}
 	}
 }
+
+func (testCase *testCaseStruct) createTestEnvVariables(deployment *Deployment, group api.ServerGroup) {
+	if group == api.ServerGroupSyncMasters || group == api.ServerGroupSyncWorkers {
+		return
+	}
+
+	// Set up environment variables.
+	for i, container := range testCase.ExpectedPod.Spec.Containers {
+		if container.Name != api.ServerGroupReservedContainerNameServer {
+			continue
+		}
+
+		testCase.ExpectedPod.Spec.Containers[i].EnvFrom = []core.EnvFromSource{
+			{
+				ConfigMapRef: &core.ConfigMapEnvSource{
+					LocalObjectReference: core.LocalObjectReference{
+						Name: features.ConfigMapName(),
+					},
+					Optional: util.NewBool(true),
+				},
+			},
+		}
+
+		var version, enterprise string
+		if len(deployment.currentObjectStatus.Images) > 0 {
+			version = string(deployment.currentObjectStatus.Images[0].ArangoDBVersion)
+			enterprise = strconv.FormatBool(deployment.currentObjectStatus.Images[0].Enterprise)
+		}
+
+		if version == "" {
+			version = testVersion
+		}
+		if enterprise == "" {
+			enterprise = "false"
+		}
+
+		if !isEnvExist(testCase.ExpectedPod.Spec.Containers[i].Env, resources.ArangoDBOverrideServerGroupEnv) {
+			testCase.ExpectedPod.Spec.Containers[i].Env = append(testCase.ExpectedPod.Spec.Containers[i].Env,
+				core.EnvVar{
+					Name:  resources.ArangoDBOverrideServerGroupEnv,
+					Value: group.AsRole(),
+				})
+		}
+		if !isEnvExist(testCase.ExpectedPod.Spec.Containers[i].Env, resources.ArangoDBOverrideDeploymentModeEnv) {
+			testCase.ExpectedPod.Spec.Containers[i].Env = append(testCase.ExpectedPod.Spec.Containers[i].Env,
+				core.EnvVar{
+					Name:  resources.ArangoDBOverrideDeploymentModeEnv,
+					Value: string(testCase.ArangoDeployment.Spec.GetMode()),
+				})
+		}
+
+		if !isEnvExist(testCase.ExpectedPod.Spec.Containers[i].Env, resources.ArangoDBOverrideVersionEnv) {
+			testCase.ExpectedPod.Spec.Containers[i].Env = append(testCase.ExpectedPod.Spec.Containers[i].Env,
+				core.EnvVar{
+					Name:  resources.ArangoDBOverrideVersionEnv,
+					Value: version,
+				})
+		}
+
+		if !isEnvExist(testCase.ExpectedPod.Spec.Containers[i].Env, resources.ArangoDBOverrideEnterpriseEnv) {
+			testCase.ExpectedPod.Spec.Containers[i].Env = append(testCase.ExpectedPod.Spec.Containers[i].Env,
+				core.EnvVar{
+					Name:  resources.ArangoDBOverrideEnterpriseEnv,
+					Value: enterprise,
+				})
+		}
+	}
+}
+
+func isEnvExist(envs []core.EnvVar, name string) bool {
+	for _, env := range envs {
+		if env.Name == name {
+			return true
+		}
+	}
+
+	return false
+}

pkg/deployment/features/config.go

@@ -0,0 +1,31 @@
+//
+// DISCLAIMER
+//
+// Copyright 2016-2022 ArangoDB GmbH, Cologne, Germany
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Copyright holder is ArangoDB GmbH, Cologne, Germany
+//
+
+package features
+
+const (
+	DefaultFeaturesConfigMap = "arangodb-operator-feature-config-map"
+)
+
+var configMapName = DefaultFeaturesConfigMap
+
+func ConfigMapName() string {
+	return configMapName
+}

pkg/deployment/features/features.go

@@ -22,6 +22,11 @@ package features
 
 import "github.com/arangodb/go-driver"
 
+const (
+	Enabled  = "true"
+	Disabled = "false"
+)
+
 var _ Feature = &feature{}
 
 type Feature interface {

pkg/deployment/features/local.go

@@ -22,13 +22,18 @@ package features
 
 import (
 	"fmt"
+	"os"
 	"sync"
 
 	"github.com/spf13/cobra"
 
 	"github.com/arangodb/go-driver"
+
+	"github.com/arangodb/kube-arangodb/pkg/util"
 )
 
+const prefixArg = "deployment.feature"
+
 var features = map[string]Feature{}
 var featuresLock sync.Mutex
 var enableAll = false
@@ -54,6 +59,9 @@ var internalCMD = &cobra.Command{
 	Run:   cmdRun,
 }
 
+// Init initializes all registered features.
+// If a feature is not provided via process's argument, then it is taken from environment variable
+// or from enabled by default setting.
 func Init(cmd *cobra.Command) error {
 	featuresLock.Lock()
 	defer featuresLock.Unlock()
@@ -62,7 +70,8 @@ func Init(cmd *cobra.Command) error {
 
 	f := cmd.Flags()
 
-	f.BoolVar(&enableAll, "deployment.feature.all", false, "Enable ALL Features")
+	featureArgName := GetFeatureArgName("all")
+	f.BoolVar(&enableAll, featureArgName, isEnabledFeatureFromEnv(featureArgName), "Enable ALL Features")
 
 	for _, feature := range features {
 		z := ""
@@ -79,21 +88,25 @@ func Init(cmd *cobra.Command) error {
 			}
 		}
 
-		featureName := fmt.Sprintf("deployment.feature.%s", feature.Name())
-		f.BoolVar(feature.EnabledPointer(), featureName, feature.EnabledByDefault(), z)
+		featureArgName = GetFeatureArgName(feature.Name())
+		enabled := feature.EnabledByDefault() || isEnabledFeatureFromEnv(featureArgName)
+		f.BoolVar(feature.EnabledPointer(), featureArgName, enabled, z)
+
 		if ok, reason := feature.Deprecated(); ok {
-			if err := f.MarkDeprecated(featureName, reason); err != nil {
+			if err := f.MarkDeprecated(featureArgName, reason); err != nil {
 				return err
 			}
 		}
 
 		if feature.Hidden() {
-			if err := f.MarkHidden(featureName); err != nil {
+			if err := f.MarkHidden(featureArgName); err != nil {
 				return err
 			}
 		}
 	}
 
+	f.StringVar(&configMapName, "features-config-map-name", DefaultFeaturesConfigMap, "Name of the Feature Map ConfigMap")
+
 	return nil
 }
 
@@ -127,6 +140,39 @@ func cmdRun(_ *cobra.Command, _ []string) {
 	}
 }
 
+// Supported returns false when:
+// - feature is disabled.
+// - a given version is lower than minimum feature version.
+// - feature expects enterprise but a given enterprise arg is not true.
 func Supported(f Feature, v driver.Version, enterprise bool) bool {
-	return f.Enabled() && ((f.EnterpriseRequired() && enterprise) || !f.EnterpriseRequired()) && v.CompareTo(f.Version()) >= 0
+	if !f.Enabled() {
+		return false
+	}
+
+	if f.EnterpriseRequired() && !enterprise {
+		// This feature requires enterprise version but current version is not enterprise.
+		return false
+	}
+
+	return v.CompareTo(f.Version()) >= 0
+}
+
+// GetFeatureMap returns all features' arguments names.
+func GetFeatureMap() map[string]bool {
+	args := make(map[string]bool, len(features))
+	for _, f := range features {
+		args[GetFeatureArgName(f.Name())] = f.Enabled()
+	}
+
+	return args
+}
+
+// GetFeatureArgName returns feature process argument name.
+func GetFeatureArgName(featureName string) string {
+	return fmt.Sprintf("%s.%s", prefixArg, featureName)
+}
+
+// isEnabledFeatureFromEnv returns true if argument is enabled as an environment variable.
+func isEnabledFeatureFromEnv(arg string) bool {
+	return os.Getenv(util.NormalizeEnv(arg)) == Enabled
 }