Adds field labels-exclusion-pattern in feature-flag to exclude labels

This adds a new field in feature-flag `labels-exclusion-pattern`
which by default is empty and takes regex pattern as input. If
defined this would filter out labels from propagating from el to
resources created for it such as deployment, service.

Signed-off-by: Shivam Mukhade <[email protected]>

config/config-feature-flags.yaml

@@ -24,3 +24,6 @@ data:
   # Setting this flag will determine which gated features are enabled.
   # Acceptable values are "stable" or "alpha".
   enable-api-fields: "stable"
+  # Setting this field with valid regex pattern matching the pattern will exclude labels from
+  # getting added to resources created by the EventListener such as the deployment
+  labels-exclusion-pattern: ""

docs/install.md

@@ -77,6 +77,11 @@ To customize the behavior of the Triggers Controller, modify the ConfigMap `feat
 most stable features to be used. Set it to "alpha" to allow alpha
 features (in addition to stable features) to be used. Note that this flag only applies to the v1beta1 apiVersion.
 
+- `labels-exclusion-pattern`: set this field with regex pattern which will 
+exclude labels matching the pattern from getting added to resources created 
+by the EventListener such as the deployment. By default, there is no value is set
+for this field so all labels added to the EventListener are propagated down.
+
 For example:
 
 ```yaml
@@ -86,3 +91,4 @@ metadata:
   name: feature-flags-triggers
 data:
   enable-api-fields: "alpha" # Allow "alpha" fields to be used in v1beta1 Triggers' resources. Defaults to "stable" features only.``
+  labels-exclusion-pattern: "^tekton-dev-"

pkg/apis/config/feature_flags.go

@@ -19,6 +19,7 @@ package config
 import (
 	"fmt"
 	"os"
+	"regexp"
 	"strings"
 
 	corev1 "k8s.io/api/core/v1"
@@ -29,6 +30,8 @@ const (
 	AlphaAPIFieldValue     = "alpha"
 	enableAPIFieldsKey     = "enable-api-fields"
 	DefaultEnableAPIFields = StableAPIFieldValue
+
+	labelsExclusionPattern = "labels-exclusion-pattern"
 )
 
 // FeatureFlags holds the features configurations
@@ -37,6 +40,9 @@ type FeatureFlags struct {
 	// EnableAPIFields determines which gated features are enabled.
 	// Acceptable values are "stable" or "alpha". Defaults to "stable"
 	EnableAPIFields string
+	// LabelsExclusionPattern determines the regex pattern to use to exclude
+	// labels being propagated to resources created by the EventListener
+	LabelsExclusionPattern string
 }
 
 // GetFeatureFlagsConfigName returns the name of the configmap containing all
@@ -55,9 +61,29 @@ func NewFeatureFlagsFromMap(cfgMap map[string]string) (*FeatureFlags, error) {
 	if tc.EnableAPIFields, err = getEnabledAPI(cfgMap); err != nil {
 		return nil, err
 	}
+
+	if tc.LabelsExclusionPattern, err = getLabelsExclusionPattern(cfgMap); err != nil {
+		return nil, err
+	}
+
 	return &tc, nil
 }
 
+// getLabelsExclusionPattern gets the "labels-exclusion-pattern" flag based on the content of a given map.
+// If the feature gate is not defined then we ignore it, if the pattern is not
+// valid regex then we return error
+func getLabelsExclusionPattern(cfgMap map[string]string) (string, error) {
+
+	if pattern, ok := cfgMap[labelsExclusionPattern]; ok {
+		if _, err := regexp.Compile(pattern); err != nil {
+			return "", fmt.Errorf("invalid value for feature flag %q: %q", labelsExclusionPattern, pattern)
+		}
+		return pattern, nil
+	}
+
+	return "", nil
+}
+
 // getEnabledAPI gets the "enable-api-fields" flag based on the content of a given map.
 // If the feature gate is invalid or missing then an error is returned.
 func getEnabledAPI(cfgMap map[string]string) (string, error) {

pkg/apis/config/feature_flags_test.go

@@ -38,7 +38,8 @@ func TestNewFeatureFlagsFromConfigMap(t *testing.T) {
 		fileName: config.GetFeatureFlagsConfigName(),
 	}, {
 		expectedConfig: &config.FeatureFlags{
-			EnableAPIFields: "alpha",
+			EnableAPIFields:        "alpha",
+			LabelsExclusionPattern: "^abc-",
 		},
 		fileName: "feature-flags-all-flags-set",
 	}, {
@@ -101,6 +102,8 @@ func TestNewFeatureFlagsConfigMapErrors(t *testing.T) {
 		fileName string
 	}{{
 		fileName: "feature-flags-invalid-enable-api-fields",
+	}, {
+		fileName: "feature-flags-invalid-exclusion-pattern-fields",
 	}} {
 		t.Run(tc.fileName, func(t *testing.T) {
 			cm := test.ConfigMapFromTestFile(t, tc.fileName)

pkg/apis/config/store.go

@@ -73,7 +73,8 @@ func NewStore(logger configmap.Logger, onAfterStore ...func(name string, value i
 			"defaults/features/artifacts",
 			logger,
 			configmap.Constructors{
-				GetDefaultsConfigName(): NewDefaultsFromConfigMap,
+				GetFeatureFlagsConfigName(): NewFeatureFlagsFromConfigMap,
+				GetDefaultsConfigName():     NewDefaultsFromConfigMap,
 			},
 			onAfterStore...,
 		),
@@ -93,8 +94,13 @@ func (s *Store) Load() *Config {
 	if defaults == nil {
 		defaults, _ = NewDefaultsFromMap(map[string]string{})
 	}
+	featureFlags := s.UntypedLoad(GetFeatureFlagsConfigName())
+	if featureFlags == nil {
+		featureFlags, _ = NewFeatureFlagsFromMap(map[string]string{})
+	}
 
 	return &Config{
-		Defaults: defaults.(*Defaults).DeepCopy(),
+		Defaults:     defaults.(*Defaults).DeepCopy(),
+		FeatureFlags: featureFlags.(*FeatureFlags).DeepCopy(),
 	}
 }

pkg/apis/config/store_test.go

@@ -32,8 +32,11 @@ func TestStoreLoadWithContext(t *testing.T) {
 
 	expectedDefaults, _ := config.NewDefaultsFromConfigMap(defaultConfig)
 
+	expectedFeatureFlag, _ := config.NewFeatureFlagsFromConfigMap(defaultConfig)
+
 	expected := &config.Config{
-		Defaults: expectedDefaults,
+		Defaults:     expectedDefaults,
+		FeatureFlags: expectedFeatureFlag,
 	}
 
 	store := config.NewStore(logtesting.TestLogger(t))

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

@@ -19,3 +19,4 @@ metadata:
   namespace: tekton-pipelines
 data:
   enable-api-fields: "alpha"
+  labels-exclusion-pattern: "^abc-"

pkg/apis/config/testdata/feature-flags-invalid-exclusion-pattern-fields.yaml

@@ -0,0 +1,22 @@
+# Copyright 2021 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-triggers
+  namespace: tekton-pipelines
+data:
+  enable-api-fields: "stable"
+  labels-exclusion-pattern: "[0-9]++"

pkg/reconciler/eventlistener/eventlistener.go

@@ -118,7 +118,7 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, el *v1beta1.EventListene
 }
 
 func (r *Reconciler) reconcileService(ctx context.Context, el *v1beta1.EventListener) error {
-	service := resources.MakeService(el, r.config)
+	service := resources.MakeService(ctx, el, r.config)
 
 	existingService, err := r.serviceLister.Services(el.Namespace).Get(el.Status.Configuration.GeneratedResourceName)
 	switch {
@@ -178,7 +178,7 @@ func (r *Reconciler) reconcileService(ctx context.Context, el *v1beta1.EventList
 }
 
 func (r *Reconciler) reconcileDeployment(ctx context.Context, el *v1beta1.EventListener) error {
-	deployment, err := resources.MakeDeployment(el, r.configAcc, r.config)
+	deployment, err := resources.MakeDeployment(ctx, el, r.configAcc, r.config)
 	if err != nil {
 		logging.FromContext(ctx).Error(err)
 		return err
@@ -241,7 +241,7 @@ func (r *Reconciler) reconcileDeployment(ctx context.Context, el *v1beta1.EventL
 }
 
 func (r *Reconciler) reconcileCustomObject(ctx context.Context, el *v1beta1.EventListener) error {
-	data, err := resources.MakeCustomObject(el, r.configAcc, r.config)
+	data, err := resources.MakeCustomObject(ctx, el, r.configAcc, r.config)
 	if err != nil {
 		logging.FromContext(ctx).Errorf("unable to construct custom object", err)
 		return err

pkg/reconciler/eventlistener/resources/custom.go

@@ -18,6 +18,7 @@ package resources
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"os"
 
@@ -30,7 +31,7 @@ import (
 	"knative.dev/pkg/kmeta"
 )
 
-func MakeCustomObject(el *v1beta1.EventListener, configAcc reconcilersource.ConfigAccessor, c Config) (*unstructured.Unstructured, error) {
+func MakeCustomObject(ctx context.Context, el *v1beta1.EventListener, configAcc reconcilersource.ConfigAccessor, c Config) (*unstructured.Unstructured, error) {
 	original := &duckv1.WithPod{}
 	decoder := json.NewDecoder(bytes.NewBuffer(el.Spec.Resources.CustomResource.Raw))
 	if err := decoder.Decode(&original); err != nil {
@@ -77,7 +78,7 @@ func MakeCustomObject(el *v1beta1.EventListener, configAcc reconcilersource.Conf
 		}
 	})
 
-	podlabels := kmeta.UnionMaps(el.Labels, GenerateLabels(el.Name, c.StaticResourceLabels))
+	podlabels := kmeta.UnionMaps(FilterLabels(ctx, el.Labels), GenerateLabels(el.Name, c.StaticResourceLabels))
 
 	podlabels = kmeta.UnionMaps(podlabels, customObjectData.Labels)
 

pkg/reconciler/eventlistener/resources/custom_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package resources
 
 import (
+	"context"
 	"os"
 	"strconv"
 	"testing"
@@ -296,7 +297,7 @@ func TestCustomObject(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := MakeCustomObject(tt.el, &reconcilersource.EmptyVarsGenerator{}, config)
+			got, err := MakeCustomObject(context.Background(), tt.el, &reconcilersource.EmptyVarsGenerator{}, config)
 			if err != nil {
 				t.Fatalf("MakeCustomObject() = %v", err)
 			}
@@ -319,7 +320,7 @@ func TestCustomObjectError(t *testing.T) {
 
 	config := *MakeConfig()
 
-	got, err := MakeCustomObject(makeEL(func(el *v1beta1.EventListener) {
+	got, err := MakeCustomObject(context.Background(), makeEL(func(el *v1beta1.EventListener) {
 		el.Spec.Resources.CustomResource = &v1beta1.CustomResource{
 			RawExtension: runtime.RawExtension{
 				Raw: []byte(`garbage`),

pkg/reconciler/eventlistener/resources/deployment.go

@@ -17,6 +17,7 @@ limitations under the License.
 package resources
 
 import (
+	"context"
 	"os"
 	"strconv"
 
@@ -40,16 +41,19 @@ var (
 	}
 )
 
-func MakeDeployment(el *v1beta1.EventListener, configAcc reconcilersource.ConfigAccessor, c Config) (*appsv1.Deployment, error) {
+func MakeDeployment(ctx context.Context, el *v1beta1.EventListener, configAcc reconcilersource.ConfigAccessor, c Config) (*appsv1.Deployment, error) {
+
 	opt, err := addDeploymentBits(el, c)
 	if err != nil {
 		return nil, err
 	}
 
 	container := MakeContainer(el, configAcc, c, opt, addCertsForSecureConnection(c))
 
+	filteredLabels := FilterLabels(ctx, el.Labels)
+
 	var (
-		podlabels                 = kmeta.UnionMaps(el.Labels, GenerateLabels(el.Name, c.StaticResourceLabels))
+		podlabels                 = kmeta.UnionMaps(filteredLabels, GenerateLabels(el.Name, c.StaticResourceLabels))
 		serviceAccountName        = el.Spec.ServiceAccountName
 		replicas                  *int32
 		vol                       []corev1.Volume
@@ -94,7 +98,7 @@ func MakeDeployment(el *v1beta1.EventListener, configAcc reconcilersource.Config
 	}
 
 	return &appsv1.Deployment{
-		ObjectMeta: ObjectMeta(el, c.StaticResourceLabels),
+		ObjectMeta: ObjectMeta(el, filteredLabels, c.StaticResourceLabels),
 		Spec: appsv1.DeploymentSpec{
 			Replicas: replicas,
 			Selector: &metav1.LabelSelector{

pkg/reconciler/eventlistener/resources/deployment_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package resources
 
 import (
+	"context"
 	"os"
 	"testing"
 
@@ -291,7 +292,7 @@ func TestDeployment(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := MakeDeployment(tt.el, &reconcilersource.EmptyVarsGenerator{}, config)
+			got, err := MakeDeployment(context.Background(), tt.el, &reconcilersource.EmptyVarsGenerator{}, config)
 			if err != nil {
 				t.Fatalf("MakeDeployment() = %v", err)
 			}
@@ -307,7 +308,7 @@ func TestDeploymentError(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	got, err := MakeDeployment(makeEL(), &reconcilersource.EmptyVarsGenerator{}, *MakeConfig())
+	got, err := MakeDeployment(context.Background(), makeEL(), &reconcilersource.EmptyVarsGenerator{}, *MakeConfig())
 	if err == nil {
 		t.Fatalf("MakeDeployment() = %v, wanted error", got)
 	}

pkg/reconciler/eventlistener/resources/meta.go

@@ -17,6 +17,10 @@ limitations under the License.
 package resources
 
 import (
+	"context"
+	"regexp"
+
+	"github.com/tektoncd/triggers/pkg/apis/config"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"knative.dev/pkg/kmeta"
 
@@ -25,12 +29,12 @@ import (
 
 // ObjectMeta generates the object meta that should be used by all
 // resources generated by the EventListener reconciler
-func ObjectMeta(el *v1beta1.EventListener, staticResourceLabels map[string]string) metav1.ObjectMeta {
+func ObjectMeta(el *v1beta1.EventListener, filteredElLabels, staticResourceLabels map[string]string) metav1.ObjectMeta {
 	return metav1.ObjectMeta{
 		Namespace:       el.Namespace,
 		Name:            el.Status.Configuration.GeneratedResourceName,
 		OwnerReferences: []metav1.OwnerReference{*kmeta.NewControllerRef(el)},
-		Labels:          kmeta.UnionMaps(el.Labels, GenerateLabels(el.Name, staticResourceLabels)),
+		Labels:          kmeta.UnionMaps(filteredElLabels, GenerateLabels(el.Name, staticResourceLabels)),
 		Annotations:     el.Annotations,
 	}
 }
@@ -41,3 +45,24 @@ func GenerateLabels(eventListenerName string, staticResourceLabels map[string]st
 	resourceLabels["eventlistener"] = eventListenerName
 	return resourceLabels
 }
+
+// FilterLabels filters label based on regex pattern defined in
+// feature-flag `labels-exclusion-pattern`
+func FilterLabels(ctx context.Context, labels map[string]string) map[string]string {
+	cfg := config.FromContextOrDefaults(ctx)
+
+	if len(labels) == 0 || cfg.FeatureFlags.LabelsExclusionPattern == "" {
+		return labels
+	}
+
+	filteredLabels := make(map[string]string)
+	r := regexp.MustCompile(cfg.FeatureFlags.LabelsExclusionPattern)
+
+	for key, value := range labels {
+		if !r.MatchString(key) {
+			filteredLabels[key] = value
+		}
+	}
+
+	return filteredLabels
+}