Add EventListener Selector for TriggerCRD

EventListener have NamespaceSelector field which gives us namespaces from where EventListener fetches Trigger object to process events.
tektoncd · Sep 28, 2020 · 260a928 · 260a928
1 parent c8123cf
commit 260a928
Show file tree

Hide file tree

Showing 17 changed files with 595 additions and 231 deletions.
diff --git a/cmd/triggerrun/cmd/root.go b/cmd/triggerrun/cmd/root.go
@@ -125,7 +125,7 @@ func trigger(triggerFile, httpPath, action string, writer io.Writer) error {
 			}
 		case "create":
 			{
-				err := r.CreateResources("", resources, tri.Name, eventID, eventLog)
+				err := r.CreateResources(tri.Namespace, "", resources, tri.Name, eventID, eventLog)
 				if err != nil {
 					return fmt.Errorf("fail to create resources: %w", err)
 				}
@@ -191,15 +191,9 @@ func processTriggerSpec(kubeClient kubernetes.Interface, client triggersclientse
 		return nil, errors.New("trigger is not defined")
 	}
 
-	//convert trigger to eventListener
-	el, err := triggersv1.ToEventListenerTrigger(tri.Spec)
-	if err != nil {
-		return nil, fmt.Errorf("fail to convert Trigger to EvenetListener: %w", err)
-	}
-
-	log := eventLog.With(zap.String(triggersv1.TriggerLabelKey, el.Name))
+	log := eventLog.With(zap.String(triggersv1.TriggerLabelKey, r.EventListenerName))
 
-	finalPayload, header, err := r.ExecuteInterceptors(&el, request, body, log)
+	finalPayload, header, err := r.ExecuteInterceptors(*tri, request, body, log)
 	if err != nil {
 		log.Error(err)
 		return nil, err
@@ -209,7 +203,7 @@ func processTriggerSpec(kubeClient kubernetes.Interface, client triggersclientse
 		tri.Namespace = "default"
 	}
 
-	rt, err := template.ResolveTrigger(el,
+	rt, err := template.ResolveTrigger(*tri,
 		client.TriggersV1alpha1().TriggerBindings(tri.Namespace).Get,
 		client.TriggersV1alpha1().ClusterTriggerBindings().Get,
 		client.TriggersV1alpha1().TriggerTemplates(tri.Namespace).Get)

diff --git a/pkg/apis/triggers/v1alpha1/event_listener_types.go b/pkg/apis/triggers/v1alpha1/event_listener_types.go
@@ -58,6 +58,7 @@ type EventListenerSpec struct {
 	ServiceType        corev1.ServiceType     `json:"serviceType,omitempty"`
 	Replicas           *int32                 `json:"replicas,omitempty"`
 	PodTemplate        PodTemplate            `json:"podTemplate,omitempty"`
+	NamespaceSelector  NamespaceSelector      `json:"namespaceSelector,omitempty"`
 	Resources          Resources              `json:"resources,omitempty"`
 }
 
@@ -152,6 +153,17 @@ type EventListenerConfig struct {
 	GeneratedResourceName string `json:"generatedName"`
 }
 
+// NamespaceSelector is a selector for selecting either all namespaces or a
+// list of namespaces.
+// +k8s:openapi-gen=true
+type NamespaceSelector struct {
+	// Boolean describing whether all namespaces are selected in contrast to a
+	// list restricting them.
+	Any bool `json:"any,omitempty"`
+	// List of namespace names.
+	MatchNames []string `json:"matchNames,omitempty"`
+}
+
 // The conditions that are internally resolved by the EventListener reconciler
 const (
 	// ServiceExists is the ConditionType set on the EventListener, which

diff --git a/pkg/apis/triggers/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/triggers/v1alpha1/zz_generated.deepcopy.go
diff --git a/pkg/interceptors/bitbucket/bitbucket.go b/pkg/interceptors/bitbucket/bitbucket.go
@@ -31,18 +31,18 @@ import (
 )
 
 type Interceptor struct {
-	KubeClientSet          kubernetes.Interface
-	Logger                 *zap.SugaredLogger
-	Bitbucket              *triggersv1.BitbucketInterceptor
-	EventListenerNamespace string
+	KubeClientSet    kubernetes.Interface
+	Logger           *zap.SugaredLogger
+	Bitbucket        *triggersv1.BitbucketInterceptor
+	TriggerNamespace string
 }
 
 func NewInterceptor(bh *triggersv1.BitbucketInterceptor, k kubernetes.Interface, ns string, l *zap.SugaredLogger) interceptors.Interceptor {
 	return &Interceptor{
-		Logger:                 l,
-		Bitbucket:              bh,
-		KubeClientSet:          k,
-		EventListenerNamespace: ns,
+		Logger:           l,
+		Bitbucket:        bh,
+		KubeClientSet:    k,
+		TriggerNamespace: ns,
 	}
 }
 
@@ -64,7 +64,7 @@ func (w *Interceptor) ExecuteTrigger(request *http.Request) (*http.Response, err
 		if header == "" {
 			return nil, errors.New("no X-Hub-Signature header set")
 		}
-		secretToken, err := interceptors.GetSecretToken(request, w.KubeClientSet, w.Bitbucket.SecretRef, w.EventListenerNamespace)
+		secretToken, err := interceptors.GetSecretToken(request, w.KubeClientSet, w.Bitbucket.SecretRef, w.TriggerNamespace)
 		if err != nil {
 			return nil, err
 		}

diff --git a/pkg/interceptors/bitbucket/bitbucket_test.go b/pkg/interceptors/bitbucket/bitbucket_test.go
@@ -240,10 +240,10 @@ func TestInterceptor_ExecuteTrigger_Signature(t *testing.T) {
 				}
 			}
 			w := &Interceptor{
-				KubeClientSet:          kubeClient,
-				Bitbucket:              tt.Bitbucket,
-				Logger:                 logger,
-				EventListenerNamespace: metav1.NamespaceDefault,
+				KubeClientSet:    kubeClient,
+				Bitbucket:        tt.Bitbucket,
+				Logger:           logger,
+				TriggerNamespace: metav1.NamespaceDefault,
 			}
 			resp, err := w.ExecuteTrigger(request)
 			if err != nil {

diff --git a/pkg/interceptors/cel/cel.go b/pkg/interceptors/cel/cel.go
@@ -45,10 +45,10 @@ import (
 // against the incoming body and headers to match, if the expression returns
 // a true value, then the interception is "successful".
 type Interceptor struct {
-	KubeClientSet          kubernetes.Interface
-	Logger                 *zap.SugaredLogger
-	CEL                    *triggersv1.CELInterceptor
-	EventListenerNamespace string
+	KubeClientSet    kubernetes.Interface
+	Logger           *zap.SugaredLogger
+	CEL              *triggersv1.CELInterceptor
+	TriggerNamespace string
 }
 
 var (
@@ -60,16 +60,16 @@ var (
 // NewInterceptor creates a prepopulated Interceptor.
 func NewInterceptor(cel *triggersv1.CELInterceptor, k kubernetes.Interface, ns string, l *zap.SugaredLogger) interceptors.Interceptor {
 	return &Interceptor{
-		Logger:                 l,
-		CEL:                    cel,
-		KubeClientSet:          k,
-		EventListenerNamespace: ns,
+		Logger:           l,
+		CEL:              cel,
+		KubeClientSet:    k,
+		TriggerNamespace: ns,
 	}
 }
 
 // ExecuteTrigger is an implementation of the Interceptor interface.
 func (w *Interceptor) ExecuteTrigger(request *http.Request) (*http.Response, error) {
-	env, err := makeCelEnv(request, w.EventListenerNamespace, w.KubeClientSet)
+	env, err := makeCelEnv(request, w.TriggerNamespace, w.KubeClientSet)
 	if err != nil {
 		return nil, fmt.Errorf("error creating cel environment: %w", err)
 	}

diff --git a/pkg/interceptors/github/github.go b/pkg/interceptors/github/github.go
@@ -31,18 +31,18 @@ import (
 )
 
 type Interceptor struct {
-	KubeClientSet          kubernetes.Interface
-	Logger                 *zap.SugaredLogger
-	GitHub                 *triggersv1.GitHubInterceptor
-	EventListenerNamespace string
+	KubeClientSet    kubernetes.Interface
+	Logger           *zap.SugaredLogger
+	GitHub           *triggersv1.GitHubInterceptor
+	TriggerNamespace string
 }
 
 func NewInterceptor(gh *triggersv1.GitHubInterceptor, k kubernetes.Interface, ns string, l *zap.SugaredLogger) interceptors.Interceptor {
 	return &Interceptor{
-		Logger:                 l,
-		GitHub:                 gh,
-		KubeClientSet:          k,
-		EventListenerNamespace: ns,
+		Logger:           l,
+		GitHub:           gh,
+		KubeClientSet:    k,
+		TriggerNamespace: ns,
 	}
 }
 
@@ -64,7 +64,7 @@ func (w *Interceptor) ExecuteTrigger(request *http.Request) (*http.Response, err
 		if header == "" {
 			return nil, errors.New("no X-Hub-Signature header set")
 		}
-		secretToken, err := interceptors.GetSecretToken(request, w.KubeClientSet, w.GitHub.SecretRef, w.EventListenerNamespace)
+		secretToken, err := interceptors.GetSecretToken(request, w.KubeClientSet, w.GitHub.SecretRef, w.TriggerNamespace)
 		if err != nil {
 			return nil, err
 		}

diff --git a/pkg/interceptors/github/github_test.go b/pkg/interceptors/github/github_test.go
@@ -240,10 +240,10 @@ func TestInterceptor_ExecuteTrigger_Signature(t *testing.T) {
 				}
 			}
 			w := &Interceptor{
-				KubeClientSet:          kubeClient,
-				GitHub:                 tt.GitHub,
-				Logger:                 logger,
-				EventListenerNamespace: metav1.NamespaceDefault,
+				KubeClientSet:    kubeClient,
+				GitHub:           tt.GitHub,
+				Logger:           logger,
+				TriggerNamespace: metav1.NamespaceDefault,
 			}
 			resp, err := w.ExecuteTrigger(request)
 			if err != nil {

diff --git a/pkg/interceptors/gitlab/gitlab.go b/pkg/interceptors/gitlab/gitlab.go
@@ -31,18 +31,18 @@ import (
 )
 
 type Interceptor struct {
-	KubeClientSet          kubernetes.Interface
-	Logger                 *zap.SugaredLogger
-	GitLab                 *triggersv1.GitLabInterceptor
-	EventListenerNamespace string
+	KubeClientSet    kubernetes.Interface
+	Logger           *zap.SugaredLogger
+	GitLab           *triggersv1.GitLabInterceptor
+	TriggerNamespace string
 }
 
 func NewInterceptor(gl *triggersv1.GitLabInterceptor, k kubernetes.Interface, ns string, l *zap.SugaredLogger) interceptors.Interceptor {
 	return &Interceptor{
-		Logger:                 l,
-		GitLab:                 gl,
-		KubeClientSet:          k,
-		EventListenerNamespace: ns,
+		Logger:           l,
+		GitLab:           gl,
+		KubeClientSet:    k,
+		TriggerNamespace: ns,
 	}
 }
 
@@ -54,7 +54,7 @@ func (w *Interceptor) ExecuteTrigger(request *http.Request) (*http.Response, err
 			return nil, errors.New("no X-GitLab-Token header set")
 		}
 
-		secretToken, err := interceptors.GetSecretToken(request, w.KubeClientSet, w.GitLab.SecretRef, w.EventListenerNamespace)
+		secretToken, err := interceptors.GetSecretToken(request, w.KubeClientSet, w.GitLab.SecretRef, w.TriggerNamespace)
 		if err != nil {
 			return nil, err
 		}

diff --git a/pkg/interceptors/gitlab/gitlab_test.go b/pkg/interceptors/gitlab/gitlab_test.go
@@ -223,10 +223,10 @@ func TestInterceptor_ExecuteTrigger(t *testing.T) {
 				}
 			}
 			w := &Interceptor{
-				KubeClientSet:          kubeClient,
-				GitLab:                 tt.GitLab,
-				Logger:                 logger,
-				EventListenerNamespace: metav1.NamespaceDefault,
+				KubeClientSet:    kubeClient,
+				GitLab:           tt.GitLab,
+				Logger:           logger,
+				TriggerNamespace: metav1.NamespaceDefault,
 			}
 			resp, err := w.ExecuteTrigger(request)
 			if err != nil {

diff --git a/pkg/interceptors/webhook/webhook.go b/pkg/interceptors/webhook/webhook.go
@@ -41,10 +41,10 @@ const (
 )
 
 type Interceptor struct {
-	HTTPClient             *http.Client
-	EventListenerNamespace string
-	Logger                 *zap.SugaredLogger
-	Webhook                *triggersv1.WebhookInterceptor
+	HTTPClient       *http.Client
+	TriggerNamespace string
+	Logger           *zap.SugaredLogger
+	Webhook          *triggersv1.WebhookInterceptor
 }
 
 func NewInterceptor(wh *triggersv1.WebhookInterceptor, c *http.Client, ns string, l *zap.SugaredLogger) interceptors.Interceptor {
@@ -53,15 +53,15 @@ func NewInterceptor(wh *triggersv1.WebhookInterceptor, c *http.Client, ns string
 		Timeout:   interceptorTimeout,
 	}
 	return &Interceptor{
-		HTTPClient:             timeoutClient,
-		EventListenerNamespace: ns,
-		Logger:                 l,
-		Webhook:                wh,
+		HTTPClient:       timeoutClient,
+		TriggerNamespace: ns,
+		Logger:           l,
+		Webhook:          wh,
 	}
 }
 
 func (w *Interceptor) ExecuteTrigger(request *http.Request) (*http.Response, error) {
-	u, err := getURI(w.Webhook.ObjectRef, w.EventListenerNamespace) // TODO: Cache this result or do this on initialization
+	u, err := getURI(w.Webhook.ObjectRef, w.TriggerNamespace) // TODO: Cache this result or do this on initialization
 	if err != nil {
 		return nil, err
 	}