Refactor template resolution into separate binding and template funcs.

pkg/sink/sink.go

@@ -78,55 +78,60 @@ func (r Sink) HandleEvent(response http.ResponseWriter, request *http.Request) {
 	}
 
 	eventID := template.UID()
-	r.Logger.Debugf("EventListener: %s in Namespace: %s handling event (EventID: %s) with payload: %s and header: %v",
+	eventLog := r.Logger.With(zap.String(triggersv1.EventIDLabelKey, eventID))
+	eventLog.Debugf("EventListener: %s in Namespace: %s handling event (EventID: %s) with payload: %s and header: %v",
 		r.EventListenerName, r.EventListenerNamespace, eventID, string(event), request.Header)
 
 	result := make(chan int, 10)
 	// Execute each Trigger
 
-	for _, trigger := range el.Spec.Triggers {
-		t := trigger
+	for _, t := range el.Spec.Triggers {
+		log := eventLog.With(zap.String(triggersv1.TriggerLabelKey, t.Name))
+
 		var interceptor interceptors.Interceptor
 		if t.Interceptor != nil {
 			switch {
 			case t.Interceptor.Webhook != nil:
-				interceptor = webhook.NewInterceptor(t.Interceptor.Webhook, r.HTTPClient, r.EventListenerNamespace, r.Logger)
+				interceptor = webhook.NewInterceptor(t.Interceptor.Webhook, r.HTTPClient, r.EventListenerNamespace, log)
 			case t.Interceptor.Github != nil:
-				interceptor = github.NewInterceptor(t.Interceptor.Github, r.KubeClientSet, r.EventListenerNamespace, r.Logger)
+				interceptor = github.NewInterceptor(t.Interceptor.Github, r.KubeClientSet, r.EventListenerNamespace, log)
 			case t.Interceptor.Gitlab != nil:
-				interceptor = gitlab.NewInterceptor(t.Interceptor.Gitlab, r.KubeClientSet, r.EventListenerNamespace, r.Logger)
+				interceptor = gitlab.NewInterceptor(t.Interceptor.Gitlab, r.KubeClientSet, r.EventListenerNamespace, log)
 			}
 		}
-		go func() {
+		go func(t triggersv1.EventListenerTrigger) {
 			finalPayload := event
 			if interceptor != nil {
 				payload, err := interceptor.ExecuteTrigger(event, request, &t, eventID)
 				if err != nil {
-					r.Logger.Error(err)
+					log.Error(err)
 					result <- http.StatusAccepted
 					return
 				}
 				finalPayload = payload
 			}
-			binding, err := template.ResolveBinding(t,
+			rt, err := template.ResolveTrigger(t,
 				r.TriggersClient.TektonV1alpha1().TriggerBindings(r.EventListenerNamespace).Get,
 				r.TriggersClient.TektonV1alpha1().TriggerTemplates(r.EventListenerNamespace).Get)
 			if err != nil {
-				r.Logger.Error(err)
+				log.Error(err)
 				result <- http.StatusAccepted
 				return
 			}
-			resources, err := template.NewResources(finalPayload, request.Header, binding)
+
+			params, err := template.ResolveParams(rt.TriggerBindings, finalPayload, request.Header, rt.TriggerTemplate.Spec.Params)
 			if err != nil {
-				r.Logger.Error(err)
+				log.Error(err)
 				result <- http.StatusAccepted
 				return
 			}
+			log.Info("params: %+v", params)
+			resources := template.ResolveResources(rt.TriggerTemplate, params)
 			if err := r.createResources(resources, t.Name, eventID); err != nil {
-				r.Logger.Error(err)
+				log.Error(err)
 			}
 			result <- http.StatusCreated
-		}()
+		}(t)
 	}
 
 	//The eventlistener waits until all the trigger executions (up-to the creation of the resources) and

pkg/template/event.go

@@ -22,19 +22,22 @@ import (
 	"strings"
 
 	pipelinev1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1alpha1"
+	triggersv1 "github.com/tektoncd/triggers/pkg/apis/triggers/v1alpha1"
 	"github.com/tidwall/gjson"
 	"golang.org/x/xerrors"
 )
 
-// bodyPathVarRegex determines valid body path variables
-// The body regular expression allows for a subset of GJSON syntax, the mininum
-// required to navigate through dictionaries, query arrays and support
-// namespaced label names e.g. tekton.dev/eventlistener
-var bodyPathVarRegex = regexp.MustCompile(`\$\(body(\.[[:alnum:]/_\-\.\\]+|\.#\([[:alnum:]=<>%!"\*_-]+\)#??)*\)`)
+var (
+	// bodyPathVarRegex determines valid body path variables
+	// The body regular expression allows for a subset of GJSON syntax, the mininum
+	// required to navigate through dictionaries, query arrays and support
+	// namespaced label names e.g. tekton.dev/eventlistener
+	bodyPathVarRegex = regexp.MustCompile(`\$\(body(\.[[:alnum:]/_\-\.\\]+|\.#\([[:alnum:]=<>%!"\*_-]+\)#??)*\)`)
 
-// The headers regular expression allows for simple navigation down a hierarchy
-// of dictionaries
-var headerVarRegex = regexp.MustCompile(`\$\(header(\.[[:alnum:]_\-]+)?\)`)
+	// The headers regular expression allows for simple navigation down a hierarchy
+	// of dictionaries
+	headerVarRegex = regexp.MustCompile(`\$\(header(\.[[:alnum:]_\-]+)?\)`)
+)
 
 // getBodyPathFromVar returns the body path given an body path variable
 // $(body.my.path) -> my.path
@@ -54,6 +57,7 @@ func getHeaderFromVar(headerVar string) string {
 	if headerVar == "$(header)" {
 		return ""
 	}
+
 	return strings.TrimSuffix(strings.TrimPrefix(headerVar, "$(header."), ")")
 }
 
@@ -160,29 +164,31 @@ func getHeaderValue(header map[string][]string, headerName string) (string, erro
 	return strings.Replace(headerValue, `"`, `\"`, -1), nil
 }
 
-// NewResources returns all resources defined when applying the event and
-// elParams to the TriggerTemplate and TriggerBinding in the ResolvedBinding.
-func NewResources(body []byte, header map[string][]string, binding ResolvedBinding) ([]json.RawMessage, error) {
-	params, err := MergeBindingParams(binding.TriggerBindings)
+// ResolveParams takes a given trigger binding and produces the resulting
+// resource params.
+func ResolveParams(bindings []*triggersv1.TriggerBinding, body []byte, header map[string][]string, params []pipelinev1.ParamSpec) ([]pipelinev1.Param, error) {
+	out, err := MergeBindingParams(bindings)
 	if err != nil {
-		return []json.RawMessage{}, xerrors.Errorf("error merging TriggerBinding params: %v", err)
+		return nil, xerrors.Errorf("error merging trigger params: %v", err)
 	}
-	params, err = ApplyBodyToParams(body, params)
+	out, err = ApplyBodyToParams(body, out)
 	if err != nil {
-		return []json.RawMessage{}, xerrors.Errorf("Error applying body to TriggerBinding params: %s", err)
+		return nil, xerrors.Errorf("error applying body to trigger params: %s", err)
 	}
-	params, err = ApplyHeaderToParams(header, params)
+	out, err = ApplyHeaderToParams(header, out)
 	if err != nil {
-		return []json.RawMessage{}, xerrors.Errorf("Error applying header to TriggerBinding params: %s", err)
+		return nil, xerrors.Errorf("error applying header to trigger params: %s", err)
 	}
 
-	params = MergeInDefaultParams(params, binding.TriggerTemplate.Spec.Params)
+	return MergeInDefaultParams(out, params), nil
+}
 
-	resources := make([]json.RawMessage, len(binding.TriggerTemplate.Spec.ResourceTemplates))
+func ResolveResources(template *triggersv1.TriggerTemplate, params []pipelinev1.Param) []json.RawMessage {
+	resources := make([]json.RawMessage, len(template.Spec.ResourceTemplates))
 	uid := UID()
-	for i := range binding.TriggerTemplate.Spec.ResourceTemplates {
-		resources[i] = ApplyParamsToResourceTemplate(params, binding.TriggerTemplate.Spec.ResourceTemplates[i].RawMessage)
+	for i := range template.Spec.ResourceTemplates {
+		resources[i] = ApplyParamsToResourceTemplate(params, template.Spec.ResourceTemplates[i].RawMessage)
 		resources[i] = ApplyUIDToResourceTemplate(resources[i], uid)
 	}
-	return resources, nil
+	return resources
 }

pkg/template/event_test.go

@@ -661,7 +661,7 @@ func Test_NewResources(t *testing.T) {
 	type args struct {
 		body    []byte
 		header  map[string][]string
-		binding ResolvedBinding
+		binding ResolvedTrigger
 	}
 	tests := []struct {
 		name string
@@ -672,7 +672,7 @@ func Test_NewResources(t *testing.T) {
 		args: args{
 			body:   json.RawMessage{},
 			header: map[string][]string{},
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace"),
 				TriggerBindings: []*triggersv1.TriggerBinding{bldr.TriggerBinding("tb", "namespace")},
 			},
@@ -683,7 +683,7 @@ func Test_NewResources(t *testing.T) {
 		args: args{
 			body:   json.RawMessage(`{"foo": "bar"}`),
 			header: map[string][]string{"one": {"1"}},
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace",
 					bldr.TriggerTemplateSpec(
 						bldr.TriggerTemplateParam("param1", "description", ""),
@@ -709,7 +709,7 @@ func Test_NewResources(t *testing.T) {
 		args: args{
 			body:   json.RawMessage(`{"foo": "bar"}`),
 			header: map[string][]string{"one": {"1"}},
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace",
 					bldr.TriggerTemplateSpec(
 						bldr.TriggerTemplateParam("param1", "description", ""),
@@ -739,7 +739,7 @@ func Test_NewResources(t *testing.T) {
 		name: "one resource template with one uid",
 		args: args{
 			body: json.RawMessage(`{"foo": "bar"}`),
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace",
 					bldr.TriggerTemplateSpec(
 						bldr.TriggerTemplateParam("param1", "description", ""),
@@ -762,7 +762,7 @@ func Test_NewResources(t *testing.T) {
 		name: "one resource template with three uid",
 		args: args{
 			body: json.RawMessage(`{"foo": "bar"}`),
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace",
 					bldr.TriggerTemplateSpec(
 						bldr.TriggerTemplateParam("param1", "description", ""),
@@ -785,7 +785,7 @@ func Test_NewResources(t *testing.T) {
 		name: "multiple resource templates with multiple uid",
 		args: args{
 			body: json.RawMessage(`{"foo": "bar"}`),
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace",
 					bldr.TriggerTemplateSpec(
 						bldr.TriggerTemplateParam("param1", "description", ""),
@@ -814,7 +814,7 @@ func Test_NewResources(t *testing.T) {
 		args: args{
 			body:   json.RawMessage(`{"foo": "bar"}`),
 			header: map[string][]string{"one": {"1"}},
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace",
 					bldr.TriggerTemplateSpec(
 						bldr.TriggerTemplateParam("param1", "description", ""),
@@ -845,12 +845,14 @@ func Test_NewResources(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// This seeds Uid() to return 'cbhtc'
 			rand.Seed(0)
-			got, err := NewResources(tt.args.body, tt.args.header, tt.args.binding)
+			params, err := ResolveParams(tt.args.binding.TriggerBindings, tt.args.body, tt.args.header, tt.args.binding.TriggerTemplate.Spec.Params)
 			if err != nil {
-				t.Errorf("NewResources() returned unexpected error: %s", err)
-			} else if diff := cmp.Diff(tt.want, got); diff != "" {
+				t.Fatalf("ResolveParams() returned unexpected error: %s", err)
+			}
+			got := ResolveResources(tt.args.binding.TriggerTemplate, params)
+			if diff := cmp.Diff(tt.want, got); diff != "" {
 				stringDiff := cmp.Diff(convertJSONRawMessagesToString(tt.want), convertJSONRawMessagesToString(got))
-				t.Errorf("NewResources(): -want +got: %s", stringDiff)
+				t.Errorf("ResolveResources(): -want +got: %s", stringDiff)
 			}
 		})
 	}
@@ -870,12 +872,12 @@ func Test_NewResources_error(t *testing.T) {
 		body     []byte
 		header   map[string][]string
 		elParams []pipelinev1.Param
-		binding  ResolvedBinding
+		binding  ResolvedTrigger
 	}{
 		{
 			name: "bodypath not found in body",
 			body: json.RawMessage(`{"foo": "bar"}`),
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace",
 					bldr.TriggerTemplateSpec(
 						bldr.TriggerTemplateParam("param1", "description", ""),
@@ -894,7 +896,7 @@ func Test_NewResources_error(t *testing.T) {
 			name:   "header not found in event",
 			body:   json.RawMessage(`{"foo": "bar"}`),
 			header: map[string][]string{"One": {"one"}},
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace",
 					bldr.TriggerTemplateSpec(
 						bldr.TriggerTemplateParam("param1", "description", ""),
@@ -917,7 +919,7 @@ func Test_NewResources_error(t *testing.T) {
 					Value: pipelinev1.ArrayOrString{StringVal: "value1", Type: pipelinev1.ParamTypeString},
 				},
 			},
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace",
 					bldr.TriggerTemplateSpec(
 						bldr.TriggerTemplateParam("param1", "description", ""),
@@ -934,7 +936,7 @@ func Test_NewResources_error(t *testing.T) {
 		},
 		{
 			name: "conflicting bindings",
-			binding: ResolvedBinding{
+			binding: ResolvedTrigger{
 				TriggerTemplate: bldr.TriggerTemplate("tt", "namespace",
 					bldr.TriggerTemplateSpec(
 						bldr.TriggerTemplateParam("param1", "description", ""),
@@ -957,7 +959,7 @@ func Test_NewResources_error(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := NewResources(tt.body, tt.header, tt.binding)
+			got, err := ResolveParams(tt.binding.TriggerBindings, tt.body, tt.header, tt.binding.TriggerTemplate.Spec.Params)
 			if err == nil {
 				t.Errorf("NewResources() did not return error when expected; got: %s", got)
 			}

pkg/template/resource.go

@@ -32,9 +32,9 @@ import (
 // uidMatch determines the uid variable within the resource template
 var uidMatch = []byte(`$(uid)`)
 
-// ResolvedBinding contains the dereferenced TriggerBindings and
+// ResolvedTrigger contains the dereferenced TriggerBindings and
 // TriggerTemplate after resolving the k8s ObjectRef.
-type ResolvedBinding struct {
+type ResolvedTrigger struct {
 	TriggerBindings []*triggersv1.TriggerBinding
 	TriggerTemplate *triggersv1.TriggerTemplate
 }
@@ -44,22 +44,22 @@ type getTriggerTemplate func(name string, options metav1.GetOptions) (*triggersv
 
 // ResolveBindings takes in a trigger containing object refs to bindings and
 // templates and resolves them to their underlying values.
-func ResolveBinding(trigger triggersv1.EventListenerTrigger, getTB getTriggerBinding, getTT getTriggerTemplate) (ResolvedBinding, error) {
+func ResolveTrigger(trigger triggersv1.EventListenerTrigger, getTB getTriggerBinding, getTT getTriggerTemplate) (ResolvedTrigger, error) {
 	tb := make([]*triggersv1.TriggerBinding, 0, len(trigger.Bindings))
 	for _, b := range trigger.Bindings {
 		tb2, err := getTB(b.Name, metav1.GetOptions{})
 		if err != nil {
-			return ResolvedBinding{}, xerrors.Errorf("error getting TriggerBinding %s: %s", b.Name, err)
+			return ResolvedTrigger{}, xerrors.Errorf("error getting TriggerBinding %s: %s", b.Name, err)
 		}
 		tb = append(tb, tb2)
 	}
 
 	ttName := trigger.Template.Name
 	tt, err := getTT(ttName, metav1.GetOptions{})
 	if err != nil {
-		return ResolvedBinding{}, xerrors.Errorf("Error getting TriggerTemplate %s: %s", ttName, err)
+		return ResolvedTrigger{}, xerrors.Errorf("Error getting TriggerTemplate %s: %s", ttName, err)
 	}
-	return ResolvedBinding{TriggerBindings: tb, TriggerTemplate: tt}, nil
+	return ResolvedTrigger{TriggerBindings: tb, TriggerTemplate: tt}, nil
 }
 
 // MergeInDefaultParams returns the params with the addition of all