Introduce config map watcher for feature flags

pkg/apis/config/feature_flags.go

@@ -0,0 +1,90 @@
+/*
+Copyright 2020 The Tekton Authors
+
+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.
+*/
+
+package config
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+
+	corev1 "k8s.io/api/core/v1"
+)
+
+const (
+	disableHomeEnvOverwriteKey              = "disable-home-env-overwrite"
+	disableWorkingDirOverwriteKey           = "disable-working-directory-overwrite"
+	disableAffinityAssistantKey             = "disable-affinity-assistant"
+	runningInEnvWithInjectedSidecarsKey     = "running-in-environment-with-injected-sidecars"
+	DefaultDisableHomeEnvOverwrite          = false
+	DefaultDisableWorkingDirOverwrite       = false
+	DefaultDisableAffinityAssistant         = false
+	DefaultRunningInEnvWithInjectedSidecars = true
+)
+
+// FeatureFlags holds the features configurations
+// +k8s:deepcopy-gen=true
+type FeatureFlags struct {
+	DisableHomeEnvOverwrite          bool
+	DisableWorkingDirOverwrite       bool
+	DisableAffinityAssistant         bool
+	RunningInEnvWithInjectedSidecars bool
+}
+
+// GetFeatureFlagsConfigName returns the name of the configmap containing all
+// feature flags.
+func GetFeatureFlagsConfigName() string {
+	if e := os.Getenv("CONFIG_FEATURE_FLAGS_NAME"); e != "" {
+		return e
+	}
+	return "feature-flags"
+}
+
+// NewFeatureFlagsFromMap returns a Config given a map corresponding to a ConfigMap
+func NewFeatureFlagsFromMap(cfgMap map[string]string) (*FeatureFlags, error) {
+	setFeature := func(key string, defaultValue bool, feature *bool) error {
+		if cfg, ok := cfgMap[key]; ok {
+			value, err := strconv.ParseBool(cfg)
+			if err != nil {
+				return fmt.Errorf("failed parsing feature flags config %q: %v", cfg, err)
+			}
+			*feature = value
+			return nil
+		}
+		*feature = defaultValue
+		return nil
+	}
+
+	tc := FeatureFlags{}
+	if err := setFeature(disableHomeEnvOverwriteKey, DefaultDisableHomeEnvOverwrite, &tc.DisableHomeEnvOverwrite); err != nil {
+		return nil, err
+	}
+	if err := setFeature(disableWorkingDirOverwriteKey, DefaultDisableWorkingDirOverwrite, &tc.DisableWorkingDirOverwrite); err != nil {
+		return nil, err
+	}
+	if err := setFeature(disableAffinityAssistantKey, DefaultDisableAffinityAssistant, &tc.DisableAffinityAssistant); err != nil {
+		return nil, err
+	}
+	if err := setFeature(runningInEnvWithInjectedSidecarsKey, DefaultRunningInEnvWithInjectedSidecars, &tc.RunningInEnvWithInjectedSidecars); err != nil {
+		return nil, err
+	}
+	return &tc, nil
+}
+
+// NewFeatureFlagsFromConfigMap returns a Config for the given configmap
+func NewFeatureFlagsFromConfigMap(config *corev1.ConfigMap) (*FeatureFlags, error) {
+	return NewFeatureFlagsFromMap(config.Data)
+}

pkg/apis/config/feature_flags_test.go

@@ -0,0 +1,105 @@
+/*
+Copyright 2020 The Tekton Authors
+
+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.
+*/
+
+package config
+
+import (
+	"os"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	test "github.com/tektoncd/pipeline/pkg/reconciler/testing"
+	"github.com/tektoncd/pipeline/test/diff"
+)
+
+func TestNewFeatureFlagsFromConfigMap(t *testing.T) {
+	type testCase struct {
+		expectedConfig *FeatureFlags
+		fileName       string
+	}
+
+	testCases := []testCase{
+		{
+			expectedConfig: &FeatureFlags{
+				RunningInEnvWithInjectedSidecars: DefaultRunningInEnvWithInjectedSidecars,
+			},
+			fileName: GetFeatureFlagsConfigName(),
+		},
+		{
+			expectedConfig: &FeatureFlags{
+				DisableHomeEnvOverwrite:          true,
+				DisableWorkingDirOverwrite:       true,
+				DisableAffinityAssistant:         true,
+				RunningInEnvWithInjectedSidecars: false,
+			},
+			fileName: "feature-flags-all-flags-set",
+		},
+	}
+
+	for _, tc := range testCases {
+		verifyConfigFileWithExpectedFeatureFlagsConfig(t, tc.fileName, tc.expectedConfig)
+	}
+}
+
+func TestNewFeatureFlagsFromEmptyConfigMap(t *testing.T) {
+	FeatureFlagsConfigEmptyName := "feature-flags-empty"
+	expectedConfig := &FeatureFlags{
+		RunningInEnvWithInjectedSidecars: true,
+	}
+	verifyConfigFileWithExpectedFeatureFlagsConfig(t, FeatureFlagsConfigEmptyName, expectedConfig)
+}
+
+func TestGetFeatureFlagsConfigName(t *testing.T) {
+	for _, tc := range []struct {
+		description         string
+		featureFlagEnvValue string
+		expected            string
+	}{{
+		description:         "Feature flags config value not set",
+		featureFlagEnvValue: "",
+		expected:            "feature-flags",
+	}, {
+		description:         "Feature flags config value set",
+		featureFlagEnvValue: "feature-flags-test",
+		expected:            "feature-flags-test",
+	}} {
+		t.Run(tc.description, func(t *testing.T) {
+			original := os.Getenv("CONFIG_FEATURE_FLAGS_NAME")
+			defer t.Cleanup(func() {
+				os.Setenv("CONFIG_FEATURE_FLAGS_NAME", original)
+			})
+			if tc.featureFlagEnvValue != "" {
+				os.Setenv("CONFIG_FEATURE_FLAGS_NAME", tc.featureFlagEnvValue)
+			}
+			got := GetFeatureFlagsConfigName()
+			want := tc.expected
+			if got != want {
+				t.Errorf("GetFeatureFlagsConfigName() = %s, want %s", got, want)
+			}
+		})
+	}
+}
+
+func verifyConfigFileWithExpectedFeatureFlagsConfig(t *testing.T, fileName string, expectedConfig *FeatureFlags) {
+	cm := test.ConfigMapFromTestFile(t, fileName)
+	if flags, err := NewFeatureFlagsFromConfigMap(cm); err == nil {
+		if d := cmp.Diff(flags, expectedConfig); d != "" {
+			t.Errorf("Diff:\n%s", diff.PrintWantGot(d))
+		}
+	} else {
+		t.Errorf("NewFeatureFlagsFromConfigMap(actual) = %v", err)
+	}
+}

pkg/apis/config/store.go

@@ -27,7 +27,8 @@ type cfgKey struct{}
 // Config holds the collection of configurations that we attach to contexts.
 // +k8s:deepcopy-gen=false
 type Config struct {
-	Defaults *Defaults
+	Defaults     *Defaults
+	FeatureFlags *FeatureFlags
 }
 
 // FromContext extracts a Config from the provided context.
@@ -46,8 +47,10 @@ func FromContextOrDefaults(ctx context.Context) *Config {
 		return cfg
 	}
 	defaults, _ := NewDefaultsFromMap(map[string]string{})
+	featureFlags, _ := NewFeatureFlagsFromMap(map[string]string{})
 	return &Config{
-		Defaults: defaults,
+		Defaults:     defaults,
+		FeatureFlags: featureFlags,
 	}
 }
 
@@ -67,10 +70,11 @@ type Store struct {
 func NewStore(logger configmap.Logger, onAfterStore ...func(name string, value interface{})) *Store {
 	store := &Store{
 		UntypedStore: configmap.NewUntypedStore(
-			"defaults",
+			"defaults/features",
 			logger,
 			configmap.Constructors{
-				GetDefaultsConfigName(): NewDefaultsFromConfigMap,
+				GetDefaultsConfigName():     NewDefaultsFromConfigMap,
+				GetFeatureFlagsConfigName(): NewFeatureFlagsFromConfigMap,
 			},
 			onAfterStore...,
 		),
@@ -86,7 +90,17 @@ func (s *Store) ToContext(ctx context.Context) context.Context {
 
 // Load creates a Config from the current config state of the Store.
 func (s *Store) Load() *Config {
+	defaults := s.UntypedLoad(GetDefaultsConfigName())
+	if defaults == nil {
+		defaults, _ = NewDefaultsFromMap(map[string]string{})
+	}
+	featureFlags := s.UntypedLoad(GetFeatureFlagsConfigName())
+	if featureFlags == nil {
+		featureFlags, _ = NewFeatureFlagsFromMap(map[string]string{})
+	}
+
 	return &Config{
-		Defaults: s.UntypedLoad(GetDefaultsConfigName()).(*Defaults).DeepCopy(),
+		Defaults:     defaults.(*Defaults).DeepCopy(),
+		FeatureFlags: featureFlags.(*FeatureFlags).DeepCopy(),
 	}
 }

pkg/apis/config/store_test.go

@@ -27,14 +27,24 @@ import (
 )
 
 func TestStoreLoadWithContext(t *testing.T) {
-	store := NewStore(logtesting.TestLogger(t))
 	defaultConfig := test.ConfigMapFromTestFile(t, "config-defaults")
+	featuresConfig := test.ConfigMapFromTestFile(t, "feature-flags-all-flags-set")
+
+	expectedDefaults, _ := NewDefaultsFromConfigMap(defaultConfig)
+	expectedFeatures, _ := NewFeatureFlagsFromConfigMap(featuresConfig)
+
+	expected := &Config{
+		Defaults:     expectedDefaults,
+		FeatureFlags: expectedFeatures,
+	}
+
+	store := NewStore(logtesting.TestLogger(t))
 	store.OnConfigChanged(defaultConfig)
+	store.OnConfigChanged(featuresConfig)
 
 	config := FromContext(store.ToContext(context.Background()))
 
-	expected, _ := NewDefaultsFromConfigMap(defaultConfig)
-	if d := cmp.Diff(config.Defaults, expected); d != "" {
-		t.Errorf("Unexpected default config %s", diff.PrintWantGot(d))
+	if d := cmp.Diff(config, expected); d != "" {
+		t.Errorf("Unexpected config %s", diff.PrintWantGot(d))
 	}
 }

pkg/apis/config/testdata/feature-flags-all-flags-set.yaml

@@ -0,0 +1,24 @@
+# Copyright 2020 The Tekton Authors
+#
+# 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
+#
+#     https://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.
+
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: feature-flags
+  namespace: tekton-pipelines
+data:
+  disable-home-env-overwrite: "true"
+  disable-working-directory-overwrite: "true"
+  disable-affinity-assistant: "true"
+  running-in-environment-with-injected-sidecars: "false"

pkg/apis/config/testdata/feature-flags-empty.yaml

@@ -0,0 +1,26 @@
+# Copyright 2020 The Tekton Authors
+#
+# 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
+#
+#     https://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.
+
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: feature-flags
+  namespace: tekton-pipelines
+data:
+  _example: |
+    ################################
+    #                              #
+    #    EXAMPLE CONFIGURATION     #
+    #                              #
+    ################################

pkg/apis/config/testdata/feature-flags.yaml

@@ -0,0 +1,24 @@
+# Copyright 2020 The Tekton Authors
+#
+# 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
+#
+#     https://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.
+
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: feature-flags
+  namespace: tekton-pipelines
+data:
+  disable-home-env-overwrite: "false"
+  disable-working-directory-overwrite: "false"
+  disable-affinity-assistant: "false"
+  running-in-environment-with-injected-sidecars: "true"