Repository: tektoncd/operator
Pull request #1116 (2022-10-18 12:28:05)

Fix clean manifest
make TARGET=openshift clean-manifest is not removing the templates generated for pipelines-as-code on openshift

this fixes removing that

# Submitter Checklist

These are the criteria that every PR should meet, please check them off as you
review them:

- [ ] Run `make test lint` before submitting a PR
- [ ] Includes [tests](https://github.com/tektoncd/community/blob/master/standards.md#principles) (if functionality changed/added)
- [ ] Includes [docs](https://github.com/tektoncd/community/blob/master/standards.md#principles) (if user facing)
- [ ] Commit messages follow [commit message best practices](https://github.com/tektoncd/community/blob/master/standards.md#commit-messages)

_See [the contribution guide](https://github.com/tektoncd/operator/blob/master/CONTRIBUTING.md) for more details._

# Release Notes

```release-note
Fix clean manifest make target
```

tekton-robot: [APPROVALNOTIFIER] This PR is **NOT APPROVED**

This pull-request has been approved by:
To complete the [pull request process](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process), please ask for approval from **piyush-garg** after the PR has been reviewed.

The full list of commands accepted by this bot can be found [here](https://prow.tekton.dev/command-help?repo=tektoncd%2Foperator).

<details open>
Needs approval from an approver in each of these files:

- **[OWNERS](https://github.com/tektoncd/operator/blob/main/OWNERS)**

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":["piyush-garg"]} -->

Patch:
diff --git a/Makefile b/Makefile
index 00c3f352d..9c83d3b30 100644
--- a/Makefile
+++ b/Makefile
@@ -69,6 +69,10 @@ ifeq ($(TARGET), openshift)
 	rm -rf ./cmd/$(TARGET)/operator/kodata/tekton-hub
 	rm -rf ./cmd/$(TARGET)/operator/kodata/tekton-addon/pipelines-as-code
 	rm -rf ./cmd/$(TARGET)/operator/kodata/tekton-addon/addons/02-clustertasks/source_external/
+	rm -rf ./cmd/openshift/operator/kodata/tekton-addon/pipelines-as-code-templates/go.yaml
+	rm -rf ./cmd/openshift/operator/kodata/tekton-addon/pipelines-as-code-templates/java.yaml
+	rm -rf ./cmd/openshift/operator/kodata/tekton-addon/pipelines-as-code-templates/nodejs.yaml
+	rm -rf ./cmd/openshift/operator/kodata/tekton-addon/pipelines-as-code-templates/python.yaml
 else
 	rm -rf ./cmd/$(TARGET)/operator/kodata/tekton*
 endif
diff --git a/config/openshift/base/operator.yaml b/config/openshift/base/operator.yaml
index 8b10aa8db..02271092a 100644
--- a/config/openshift/base/operator.yaml
+++ b/config/openshift/base/operator.yaml
@@ -52,6 +52,8 @@ spec:
           valueFrom:
             fieldRef:
               fieldPath: metadata.namespace
+        - name: PLATFORM
+          value: "openshift"
         - name: POD_NAME
           valueFrom:
             fieldRef:
diff --git a/go.mod b/go.mod
index 5e824b742..5e7af9f40 100644
--- a/go.mod
+++ b/go.mod
@@ -26,7 +26,7 @@ require (
 	golang.org/x/crypto v0.0.0-20220919173607-35f4265a4bc0
 	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4
 	gomodules.xyz/jsonpatch/v2 v2.2.0
-	google.golang.org/grpc v1.50.0
+	google.golang.org/grpc v1.50.1
 	google.golang.org/protobuf v1.28.1
 	gopkg.in/square/go-jose.v2 v2.6.0
 	gopkg.in/yaml.v3 v3.0.1
diff --git a/go.sum b/go.sum
index d9b9b03c3..21608dcbf 100644
--- a/go.sum
+++ b/go.sum
@@ -3783,8 +3783,8 @@ google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACu
 google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
 google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
 google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
-google.golang.org/grpc v1.50.0 h1:fPVVDxY9w++VjTZsYvXWqEf9Rqar/e+9zYfxKK+W+YU=
-google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
+google.golang.org/grpc v1.50.1 h1:DS/BukOZWp8s6p4Dt/tOaJaTQyPyOoCcrjroHuCeLzY=
+google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.2.0/go.mod h1:DNq5QpG7LJqD2AamLZ7zvKE0DEpVl2BSEVjFycAAjRY=
 google.golang.org/grpc/examples v0.0.0-20201130180447-c456688b1860/go.mod h1:Ly7ZA/ARzg8fnPU9TyZIxoz33sEUuWX7txiqs8lPTgE=
diff --git a/pkg/apis/operator/v1alpha1/tektonconfig_defaults.go b/pkg/apis/operator/v1alpha1/tektonconfig_defaults.go
index 95e94eb3d..255ca5f85 100644
--- a/pkg/apis/operator/v1alpha1/tektonconfig_defaults.go
+++ b/pkg/apis/operator/v1alpha1/tektonconfig_defaults.go
@@ -25,10 +25,14 @@ func (tc *TektonConfig) SetDefaults(ctx context.Context) {
 		tc.Spec.Profile = ProfileBasic
 	}
 
-	tc.Spec.Pipeline.PipelineProperties.setDefaults()
-	tc.Spec.Trigger.TriggersProperties.setDefaults()
+	tc.Spec.Pipeline.setDefaults()
+	tc.Spec.Trigger.setDefaults()
 
-	setAddonDefaults(&tc.Spec.Addon)
+	if IsOpenShiftPlatform() {
+		setAddonDefaults(&tc.Spec.Addon)
+	} else {
+		tc.Spec.Addon = Addon{}
+	}
 
 	// before adding webhook we had default value for pruner's keep as 1
 	// but we expect user to define all values now otherwise webhook reject
diff --git a/pkg/apis/operator/v1alpha1/tektonpipeline_defaults.go b/pkg/apis/operator/v1alpha1/tektonpipeline_defaults.go
index a8e975ad6..919888119 100644
--- a/pkg/apis/operator/v1alpha1/tektonpipeline_defaults.go
+++ b/pkg/apis/operator/v1alpha1/tektonpipeline_defaults.go
@@ -23,11 +23,19 @@ import (
 	"knative.dev/pkg/ptr"
 )
 
+const (
+	// openshift specific
+	enableMetricsKey                         = "enableMetrics"
+	enableMetricsDefaultValue                = "true"
+	openshiftDefaultDisableAffinityAssistant = true
+	ospDefaultSA                             = "pipeline"
+)
+
 func (tp *TektonPipeline) SetDefaults(ctx context.Context) {
-	tp.Spec.PipelineProperties.setDefaults()
+	tp.Spec.setDefaults()
 }
 
-func (p *PipelineProperties) setDefaults() {
+func (p *Pipeline) setDefaults() {
 	if p.DisableCredsInit == nil {
 		p.DisableCredsInit = ptr.Bool(config.DefaultDisableCredsInit)
 	}
@@ -71,4 +79,39 @@ func (p *PipelineProperties) setDefaults() {
 	if p.MetricsTaskrunLevel == "" {
 		p.MetricsTaskrunLevel = config.DefaultTaskrunLevel
 	}
+
+	// run platform specific defaulting
+	if IsOpenShiftPlatform() {
+		p.openshiftDefaulting()
+	}
+}
+
+func (p *Pipeline) openshiftDefaulting() {
+	if p.DefaultServiceAccount == "" {
+		p.DefaultServiceAccount = ospDefaultSA
+	}
+
+	if p.DisableAffinityAssistant == nil {
+		p.DisableAffinityAssistant = ptr.Bool(openshiftDefaultDisableAffinityAssistant)
+	}
+
+	// Add params with default values if not defined by user
+	var found = false
+	for i, param := range p.Params {
+		if param.Name == enableMetricsKey {
+			found = true
+			// If the value set is invalid then set key to default value
+			if param.Value != "false" && param.Value != "true" {
+				p.Params[i].Value = enableMetricsDefaultValue
+			}
+			break
+		}
+	}
+
+	if !found {
+		p.Params = append(p.Params, Param{
+			Name:  enableMetricsKey,
+			Value: enableMetricsDefaultValue,
+		})
+	}
 }
diff --git a/pkg/apis/operator/v1alpha1/tektontrigger_defaults.go b/pkg/apis/operator/v1alpha1/tektontrigger_defaults.go
index eb0ef519b..44ea2b423 100644
--- a/pkg/apis/operator/v1alpha1/tektontrigger_defaults.go
+++ b/pkg/apis/operator/v1alpha1/tektontrigger_defaults.go
@@ -28,22 +28,22 @@ var (
 )
 
 func (tt *TektonTrigger) SetDefaults(ctx context.Context) {
-	tt.Spec.TriggersProperties.setDefaults()
+	tt.Spec.Trigger.setDefaults()
 }
 
-func (p *TriggersProperties) setDefaults() {
-	if p.EnableApiFields == "" {
-		p.EnableApiFields = config.DefaultEnableAPIFields
+func (t *Trigger) setDefaults() {
+	if t.EnableApiFields == "" {
+		t.EnableApiFields = config.DefaultEnableAPIFields
 	}
 
 	// run platform specific defaulting
 	if IsOpenShiftPlatform() {
-		p.openshiftDefaulting()
+		t.openshiftDefaulting()
 	}
 }
 
-func (p *TriggersProperties) openshiftDefaulting() {
-	if p.DefaultServiceAccount == "" {
-		p.DefaultServiceAccount = DefaultOpenshiftSA
+func (t *Trigger) openshiftDefaulting() {
+	if t.DefaultServiceAccount == "" {
+		t.DefaultServiceAccount = DefaultOpenshiftSA
 	}
 }
diff --git a/pkg/reconciler/common/common.go b/pkg/reconciler/common/common.go
index 14518c46d..e6b141abf 100644
--- a/pkg/reconciler/common/common.go
+++ b/pkg/reconciler/common/common.go
@@ -27,11 +27,6 @@ import (
 	"knative.dev/pkg/apis"
 )
 
-var (
-	// DefaultSA is the default service account
-	DefaultSA = "pipeline"
-)
-
 const (
 	PipelineNotReady       = "tekton-pipelines not ready"
 	PipelineNotFound       = "tekton-pipelines not installed"
diff --git a/pkg/reconciler/kubernetes/tektonchain/tektonchain.go b/pkg/reconciler/kubernetes/tektonchain/tektonchain.go
index a08c5d3b2..d5a8c63ca 100644
--- a/pkg/reconciler/kubernetes/tektonchain/tektonchain.go
+++ b/pkg/reconciler/kubernetes/tektonchain/tektonchain.go
@@ -103,7 +103,7 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tc *v1alpha1.TektonChain
 
 	// find a valid TektonPipeline installation
 	if _, err := common.PipelineReady(r.pipelineInformer); err != nil {
-		if err.Error() == common.PipelineNotReady {
+		if err.Error() == common.PipelineNotReady || err == v1alpha1.DEPENDENCY_UPGRADE_PENDING_ERR {
 			tc.Status.MarkDependencyInstalling("TektonPipeline is still installing")
 			// wait for TektonPipeline status to change
 			return fmt.Errorf(common.PipelineNotReady)
diff --git a/pkg/reconciler/kubernetes/tektondashboard/tektondashboard.go b/pkg/reconciler/kubernetes/tektondashboard/tektondashboard.go
index 36008851a..a7f253f05 100644
--- a/pkg/reconciler/kubernetes/tektondashboard/tektondashboard.go
+++ b/pkg/reconciler/kubernetes/tektondashboard/tektondashboard.go
@@ -131,7 +131,7 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, td *v1alpha1.TektonDashb
 
 	// find the valid tekton-pipeline installation
 	if _, err := common.PipelineReady(r.pipelineInformer); err != nil {
-		if err.Error() == common.PipelineNotReady {
+		if err.Error() == common.PipelineNotReady || err == v1alpha1.DEPENDENCY_UPGRADE_PENDING_ERR {
 			td.Status.MarkDependencyInstalling("tekton-pipelines is still installing")
 			// wait for pipeline status to change
 			return v1alpha1.REQUEUE_EVENT_AFTER
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/check.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/check.go
index 4bdb323a7..56a25a657 100644
--- a/pkg/reconciler/kubernetes/tektoninstallerset/client/check.go
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/check.go
@@ -25,27 +25,16 @@ import (
 	"github.com/tektoncd/operator/pkg/reconciler/shared/hash"
 	"go.uber.org/zap"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/apimachinery/pkg/selection"
 	"knative.dev/pkg/logging"
 )
 
-func (i *InstallerSetClient) CheckSet(ctx context.Context, comp v1alpha1.TektonComponent, isType string) ([]v1alpha1.TektonInstallerSet, error) {
+func (i *InstallerSetClient) checkSet(ctx context.Context, comp v1alpha1.TektonComponent, isType string) ([]v1alpha1.TektonInstallerSet, error) {
 	logger := logging.FromContext(ctx)
 
-	labelSelector := labels.NewSelector()
-	createdReq, _ := labels.NewRequirement(v1alpha1.CreatedByKey, selection.Equals, []string{i.resourceKind})
-	if createdReq != nil {
-		labelSelector = labelSelector.Add(*createdReq)
-	}
-	typeReq, _ := labels.NewRequirement(v1alpha1.InstallerSetType, selection.Equals, []string{isType})
-	if typeReq != nil {
-		labelSelector = labelSelector.Add(*typeReq)
-	}
-
-	logger.Infof("%v/%v: checking installer sets with labels: %v", i.resourceKind, isType, labelSelector.String())
+	labelSelector := i.getSetLabels(isType)
+	logger.Infof("%v/%v: checking installer sets with labels: %v", i.resourceKind, isType, labelSelector)
 
-	is, err := i.clientSet.List(ctx, v1.ListOptions{LabelSelector: labelSelector.String()})
+	is, err := i.clientSet.List(ctx, v1.ListOptions{LabelSelector: labelSelector})
 	if err != nil {
 		return nil, err
 	}
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/cleanup.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/cleanup.go
index cbbfd333c..7c9c056d8 100644
--- a/pkg/reconciler/kubernetes/tektoninstallerset/client/cleanup.go
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/cleanup.go
@@ -21,116 +21,85 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/apimachinery/pkg/selection"
 	"knative.dev/pkg/logging"
 )
 
 var deletePropagationPolicy = v1.DeletePropagationForeground
 
-func (i *InstallerSetClient) CleanupAll(ctx context.Context) error {
-	labelSelector := labels.NewSelector()
-	createdReq, _ := labels.NewRequirement(v1alpha1.CreatedByKey, selection.Equals, []string{i.resourceKind})
-	if createdReq != nil {
-		labelSelector = labelSelector.Add(*createdReq)
-	}
-	err := i.clientSet.DeleteCollection(ctx, metav1.DeleteOptions{}, metav1.ListOptions{
-		LabelSelector: labelSelector.String(),
-	})
-	return err
-}
-
 func (i *InstallerSetClient) CleanupMainSet(ctx context.Context) error {
 	logger := logging.FromContext(ctx).With("kind", i.resourceKind, "type", InstallerTypeMain)
 
-	labelSelector := labels.NewSelector()
-	createdReq, _ := labels.NewRequirement(v1alpha1.CreatedByKey, selection.Equals, []string{i.resourceKind})
-	if createdReq != nil {
-		labelSelector = labelSelector.Add(*createdReq)
-	}
-	typeReq, _ := labels.NewRequirement(v1alpha1.InstallerSetType, selection.Equals, []string{InstallerTypeMain})
-	if typeReq != nil {
-		labelSelector = labelSelector.Add(*typeReq)
-	}
-
-	list, err := i.clientSet.List(ctx, metav1.ListOptions{LabelSelector: labelSelector.String()})
+	list, err := i.clientSet.List(ctx, metav1.ListOptions{LabelSelector: i.getSetLabels(InstallerTypeMain)})
 	if err != nil {
 		return err
 	}
 
 	if len(list.Items) != 2 {
 		logger.Error("found more than 2 installerSet for main, something fishy, cleaning up all")
-		return i.CleanupAll(ctx)
 	}
 
-	var static, deploy *v1alpha1.TektonInstallerSet
-	for i, is := range list.Items {
+	// delete all static installerSet first and then deployment one
+	for _, is := range list.Items {
 		if strings.Contains(is.GetName(), InstallerSubTypeStatic) {
-			static = &list.Items[i]
-		} else {
-			deploy = &list.Items[i]
+			logger.Infof("deleting main-static installer set: %s", is.GetName())
+			err = i.clientSet.Delete(ctx, is.GetName(), metav1.DeleteOptions{
+				PropagationPolicy: &deletePropagationPolicy,
+			})
+			if err != nil {
+				return fmt.Errorf("failed to delete main-static installer set for %s", is.GetName())
+			}
 		}
 	}
 
-	// delete static installerSet first and then deployment one
-	logger.Infof("deleting main-static installer set: %s", static.GetName())
-	err = i.clientSet.Delete(ctx, static.GetName(), metav1.DeleteOptions{
-		PropagationPolicy: &deletePropagationPolicy,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to delete main-static installer set for %s", static.GetName())
+	// now delete all deployment installerSet
+	for _, is := range list.Items {
+		if strings.Contains(is.GetName(), InstallerSubTypeDeployment) {
+			logger.Infof("deleting main-deployment installer set: %s", is.GetName())
+			err = i.clientSet.Delete(ctx, is.GetName(), metav1.DeleteOptions{
+				PropagationPolicy: &deletePropagationPolicy,
+			})
+			if err != nil {
+				return fmt.Errorf("failed to delete main-deployment installer set for %s", is.GetName())
+			}
+		}
 	}
+	return nil
+}
 
-	logger.Infof("deleting main-deployment installer set: %s", deploy.GetName())
-	err = i.clientSet.Delete(ctx, deploy.GetName(), metav1.DeleteOptions{
-		PropagationPolicy: &deletePropagationPolicy,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to delete main-deployment installer set for %s", deploy.GetName())
-	}
-	return err
+func (i *InstallerSetClient) CleanupSet(ctx context.Context, setType string) error {
+	return i.cleanup(ctx, setType)
 }
 
 func (i *InstallerSetClient) CleanupPreSet(ctx context.Context) error {
-	return i.Cleanup(ctx, InstallerTypePre)
+	return i.cleanup(ctx, InstallerTypePre)
 }
 
 func (i *InstallerSetClient) CleanupPostSet(ctx context.Context) error {
-	return i.Cleanup(ctx, InstallerTypePost)
+	return i.cleanup(ctx, InstallerTypePost)
 }
 
-func (i *InstallerSetClient) Cleanup(ctx context.Context, isType string) error {
+func (i *InstallerSetClient) cleanup(ctx context.Context, isType string) error {
 	logger := logging.FromContext(ctx).With("kind", i.resourceKind, "type", isType)
 
-	labelSelector := labels.NewSelector()
-	createdReq, _ := labels.NewRequirement(v1alpha1.CreatedByKey, selection.Equals, []string{i.resourceKind})
-	if createdReq != nil {
-		labelSelector = labelSelector.Add(*createdReq)
-	}
-	typeReq, _ := labels.NewRequirement(v1alpha1.InstallerSetType, selection.Equals, []string{isType})
-	if typeReq != nil {
-		labelSelector = labelSelector.Add(*typeReq)
-	}
-
-	list, err := i.clientSet.List(ctx, metav1.ListOptions{LabelSelector: labelSelector.String()})
+	list, err := i.clientSet.List(ctx, metav1.ListOptions{LabelSelector: i.getSetLabels(isType)})
 	if err != nil {
 		return err
 	}
 
 	if len(list.Items) != 1 {
 		logger.Errorf("found more than 1 installerSet for %s something fishy, cleaning up all", isType)
-		return i.CleanupAll(ctx)
 	}
 
-	logger.Infof("deleting %s installer set: %s", isType, list.Items[0].GetName())
-	err = i.clientSet.Delete(ctx, list.Items[0].GetName(), metav1.DeleteOptions{
-		PropagationPolicy: &deletePropagationPolicy,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to delete %s set: %s", isType, list.Items[0].GetName())
+	for _, is := range list.Items {
+		logger.Infof("deleting %s installer set: %s", isType, is.GetName())
+		err = i.clientSet.Delete(ctx, is.GetName(), metav1.DeleteOptions{
+			PropagationPolicy: &deletePropagationPolicy,
+		})
+		if err != nil {
+			return fmt.Errorf("failed to delete %s set: %s", isType, is.GetName())
+		}
 	}
-	return err
+	return nil
 }
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/client.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/client.go
index f461ed0cf..0da022430 100644
--- a/pkg/reconciler/kubernetes/tektoninstallerset/client/client.go
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/client.go
@@ -47,23 +47,19 @@ var (
 type FilterAndTransform func(ctx context.Context, manifest *mf.Manifest, comp v1alpha1.TektonComponent) (*mf.Manifest, error)
 
 type InstallerSetClient struct {
-	clientSet          clientSet.TektonInstallerSetInterface
-	releaseVersion     string
-	componentVersion   string
-	resourceKind       string
-	filterAndTransform FilterAndTransform
-	manifest           *mf.Manifest
-	metrics            Metrics
+	clientSet        clientSet.TektonInstallerSetInterface
+	releaseVersion   string
+	componentVersion string
+	resourceKind     string
+	metrics          Metrics
 }
 
-func NewInstallerSetClient(clientSet clientSet.TektonInstallerSetInterface, manifest *mf.Manifest, releaseVersion, componentVersion string, resourceKind string, filterAndTransform FilterAndTransform, metrics Metrics) *InstallerSetClient {
+func NewInstallerSetClient(clientSet clientSet.TektonInstallerSetInterface, releaseVersion, componentVersion string, resourceKind string, metrics Metrics) *InstallerSetClient {
 	return &InstallerSetClient{
-		clientSet:          clientSet,
-		releaseVersion:     releaseVersion,
-		resourceKind:       resourceKind,
-		filterAndTransform: filterAndTransform,
-		manifest:           manifest,
-		metrics:            metrics,
-		componentVersion:   componentVersion,
+		clientSet:        clientSet,
+		releaseVersion:   releaseVersion,
+		resourceKind:     resourceKind,
+		metrics:          metrics,
+		componentVersion: componentVersion,
 	}
 }
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/create.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/create.go
index 2ad4d2576..9f2b47bdd 100644
--- a/pkg/reconciler/kubernetes/tektoninstallerset/client/create.go
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/create.go
@@ -28,12 +28,12 @@ import (
 	"knative.dev/pkg/logging"
 )
 
-func (i *InstallerSetClient) Create(ctx context.Context, comp v1alpha1.TektonComponent, manifest *mf.Manifest, isType string) ([]v1alpha1.TektonInstallerSet, error) {
+func (i *InstallerSetClient) create(ctx context.Context, comp v1alpha1.TektonComponent, manifest *mf.Manifest, filterAndTransform FilterAndTransform, isType string) ([]v1alpha1.TektonInstallerSet, error) {
 	logger := logging.FromContext(ctx).With("kind", i.resourceKind, "type", isType)
 
 	switch isType {
 	case InstallerTypeMain:
-		sets, err := i.makeMainSets(ctx, comp, manifest)
+		sets, err := i.makeMainSets(ctx, comp, manifest, filterAndTransform)
 		if err != nil {
 			logger.Errorf("installer set creation failed for main type: %v", err)
 			return sets, err
@@ -44,7 +44,7 @@ func (i *InstallerSetClient) Create(ctx context.Context, comp v1alpha1.TektonCom
 		kind := strings.ToLower(strings.TrimPrefix(i.resourceKind, "Tekton"))
 		isName := fmt.Sprintf("%s-%s-", kind, isType)
 
-		iS, err := i.makeInstallerSet(ctx, comp, manifest, isName, isType)
+		iS, err := i.makeInstallerSet(ctx, comp, manifest, filterAndTransform, isName, isType)
 		if err != nil {
 			return nil, err
 		}
@@ -65,14 +65,14 @@ func (i *InstallerSetClient) Create(ctx context.Context, comp v1alpha1.TektonCom
 	return nil, nil
 }
 
-func (i *InstallerSetClient) makeMainSets(ctx context.Context, comp v1alpha1.TektonComponent, manifest *mf.Manifest) ([]v1alpha1.TektonInstallerSet, error) {
-	staticManifest := manifest.Filter(mf.Not(mf.ByKind("Deployment")))
-	deploymentManifest := manifest.Filter(mf.ByKind("Deployment"))
+func (i *InstallerSetClient) makeMainSets(ctx context.Context, comp v1alpha1.TektonComponent, manifest *mf.Manifest, filterAndTransform FilterAndTransform) ([]v1alpha1.TektonInstallerSet, error) {
+	staticManifest := manifest.Filter(mf.Not(mf.ByKind("Deployment")), mf.Not(mf.ByKind("Service")))
+	deploymentManifest := manifest.Filter(mf.Any(mf.ByKind("Deployment"), mf.ByKind("Service")))
 
 	kind := strings.ToLower(strings.TrimPrefix(i.resourceKind, "Tekton"))
 	staticName := fmt.Sprintf("%s-%s-%s-", kind, InstallerTypeMain, InstallerSubTypeStatic)
 
-	staticIS, err := i.makeInstallerSet(ctx, comp, &staticManifest, staticName, InstallerTypeMain)
+	staticIS, err := i.makeInstallerSet(ctx, comp, &staticManifest, filterAndTransform, staticName, InstallerTypeMain)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +82,7 @@ func (i *InstallerSetClient) makeMainSets(ctx context.Context, comp v1alpha1.Tek
 	}
 
 	deployName := fmt.Sprintf("%s-%s-%s-", kind, InstallerTypeMain, InstallerSubTypeDeployment)
-	deploymentIS, err := i.makeInstallerSet(ctx, comp, &deploymentManifest, deployName, InstallerTypeMain)
+	deploymentIS, err := i.makeInstallerSet(ctx, comp, &deploymentManifest, filterAndTransform, deployName, InstallerTypeMain)
 	if err != nil {
 		return nil, err
 	}
@@ -94,13 +94,13 @@ func (i *InstallerSetClient) makeMainSets(ctx context.Context, comp v1alpha1.Tek
 	return []v1alpha1.TektonInstallerSet{*staticIS, *deploymentIS}, nil
 }
 
-func (i *InstallerSetClient) makeInstallerSet(ctx context.Context, comp v1alpha1.TektonComponent, manifest *mf.Manifest, isName, isType string) (*v1alpha1.TektonInstallerSet, error) {
+func (i *InstallerSetClient) makeInstallerSet(ctx context.Context, comp v1alpha1.TektonComponent, manifest *mf.Manifest, filterAndTransform FilterAndTransform, isName, isType string) (*v1alpha1.TektonInstallerSet, error) {
 	specHash, err := hash.Compute(comp.GetSpec())
 	if err != nil {
 		return nil, err
 	}
 
-	transformedMf, err := i.filterAndTransform(ctx, manifest, comp)
+	transformedMf, err := filterAndTransform(ctx, manifest, comp)
 	if err != nil {
 		return nil, err
 	}
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/labels.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/labels.go
new file mode 100644
index 000000000..ef5f2f43f
--- /dev/null
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/labels.go
@@ -0,0 +1,36 @@
+/*
+Copyright 2022 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 client
+
+import (
+	"github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/selection"
+)
+
+func (i *InstallerSetClient) getSetLabels(setType string) string {
+	labelSelector := labels.NewSelector()
+	createdReq, _ := labels.NewRequirement(v1alpha1.CreatedByKey, selection.Equals, []string{i.resourceKind})
+	if createdReq != nil {
+		labelSelector = labelSelector.Add(*createdReq)
+	}
+	typeReq, _ := labels.NewRequirement(v1alpha1.InstallerSetType, selection.Equals, []string{setType})
+	if typeReq != nil {
+		labelSelector = labelSelector.Add(*typeReq)
+	}
+	return labelSelector.String()
+}
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/main.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/main.go
index fc930a80e..028ef6ed0 100644
--- a/pkg/reconciler/kubernetes/tektoninstallerset/client/main.go
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/main.go
@@ -19,6 +19,7 @@ package client
 import (
 	"context"
 
+	mf "github.com/manifestival/manifestival"
 	"github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
 	"knative.dev/pkg/logging"
 )
@@ -28,11 +29,19 @@ const (
 	metricsUpgrade = "Upgrade"
 )
 
-func (i *InstallerSetClient) MainSet(ctx context.Context, comp v1alpha1.TektonComponent) error {
+func (i *InstallerSetClient) PreSet(ctx context.Context, comp v1alpha1.TektonComponent, manifest *mf.Manifest, filterAndTransform FilterAndTransform) error {
+	return i.createSet(ctx, comp, InstallerTypePre, manifest, filterAndTransform)
+}
+
+func (i *InstallerSetClient) PostSet(ctx context.Context, comp v1alpha1.TektonComponent, manifest *mf.Manifest, filterAndTransform FilterAndTransform) error {
+	return i.createSet(ctx, comp, InstallerTypePost, manifest, filterAndTransform)
+}
+
+func (i *InstallerSetClient) MainSet(ctx context.Context, comp v1alpha1.TektonComponent, manifest *mf.Manifest, filterAndTransform FilterAndTransform) error {
 	logger := logging.FromContext(ctx)
 	setType := InstallerTypeMain
 
-	sets, err := i.CheckSet(ctx, comp, InstallerTypeMain)
+	sets, err := i.checkSet(ctx, comp, setType)
 	if err == nil {
 		logger.Infof("%v/%v: found %v installer sets", i.resourceKind, setType, len(sets))
 	}
@@ -40,9 +49,10 @@ func (i *InstallerSetClient) MainSet(ctx context.Context, comp v1alpha1.TektonCo
 	switch err {
 	case ErrNotFound:
 		logger.Infof("%v/%v: installer set not found, creating", i.resourceKind, setType)
-		sets, err = i.Create(ctx, comp, i.manifest, InstallerTypeMain)
+		sets, err = i.create(ctx, comp, manifest, filterAndTransform, setType)
 		if err != nil {
-			return nil
+			logger.Errorf("%v/%v: failed to create main installer set: %v", i.resourceKind, setType, err)
+			return err
 		}
 		if comp.GetStatus().GetCondition(v1alpha1.InstallerSetAvailable).IsUnknown() {
 			i.metrics.LogMetrics(metricsNew, i.componentVersion, logger)
@@ -52,7 +62,7 @@ func (i *InstallerSetClient) MainSet(ctx context.Context, comp v1alpha1.TektonCo
 		logger.Infof("%v/%v: installer set not in valid state : %v, cleaning up!", i.resourceKind, setType, err)
 		if err := i.CleanupMainSet(ctx); err != nil {
 			logger.Errorf("%v/%v: failed to cleanup main installer set: %v", i.resourceKind, setType, err)
-			return nil
+			return err
 		}
 		if err == ErrVersionDifferent {
 			i.metrics.LogMetrics(metricsUpgrade, i.componentVersion, logger)
@@ -65,10 +75,10 @@ func (i *InstallerSetClient) MainSet(ctx context.Context, comp v1alpha1.TektonCo
 
 	case ErrUpdateRequired:
 		logger.Infof("%v/%v: updating installer set", i.resourceKind, setType)
-		sets, err = i.Update(ctx, comp, sets, i.manifest, InstallerTypeMain)
+		sets, err = i.update(ctx, comp, sets, manifest, filterAndTransform, setType)
 		if err != nil {
 			logger.Errorf("%v/%v: update failed : %v", i.resourceKind, setType, err)
-			return nil
+			return err
 		}
 	case ErrSetsInDeletionState:
 		logger.Infof("%v/%v: %v", i.resourceKind, setType, err)
@@ -81,12 +91,60 @@ func (i *InstallerSetClient) MainSet(ctx context.Context, comp v1alpha1.TektonCo
 	for _, set := range sets {
 		if !set.Status.IsReady() {
 			logger.Infof("%v/%v: installer set %v no yet ready, wait !", i.resourceKind, setType, set.GetName())
-			return nil
+			return v1alpha1.REQUEUE_EVENT_AFTER
 		}
 	}
 
 	//Mark InstallerSet Ready
 	comp.GetStatus().MarkInstallerSetReady()
+
+	return nil
+}
+
+func (i *InstallerSetClient) createSet(ctx context.Context, comp v1alpha1.TektonComponent, setType string, manifest *mf.Manifest, filterAndTransform FilterAndTransform) error {
+	logger := logging.FromContext(ctx)
+
+	sets, err := i.checkSet(ctx, comp, setType)
+	if err == nil {
+		logger.Infof("%v/%v: found %v installer sets", i.resourceKind, setType, len(sets))
+	}
+
+	switch err {
+	case ErrNotFound:
+		logger.Infof("%v/%v: installer set not found, creating", i.resourceKind, setType)
+		sets, err = i.create(ctx, comp, manifest, filterAndTransform, setType)
+		if err != nil {
+			logger.Errorf("%v/%v: failed to create installer set: %v", i.resourceKind, setType, err)
+			return err
+		}
+
+	case ErrInvalidState, ErrNsDifferent, ErrVersionDifferent:
+		logger.Infof("%v/%v: installer set not in valid state : %v, cleaning up!", i.resourceKind, setType, err)
+		if err := i.CleanupSet(ctx, setType); err != nil {
+			logger.Errorf("%v/%v: failed to cleanup installer set: %v", i.resourceKind, setType, err)
+			return nil
+		}
+		logger.Infof("%v/%v: returning, will create installer sets in further reconcile", i.resourceKind, setType)
+		return v1alpha1.REQUEUE_EVENT_AFTER
+
+	case ErrUpdateRequired:
+		logger.Infof("%v/%v: updating installer set", i.resourceKind, setType)
+		sets, err = i.update(ctx, comp, sets, manifest, filterAndTransform, setType)
+		if err != nil {
+			logger.Errorf("%v/%v: update failed : %v", i.resourceKind, setType, err)
+			return err
+		}
+	case ErrSetsInDeletionState:
+		logger.Infof("%v/%v: %v", i.resourceKind, setType, err)
+		return v1alpha1.REQUEUE_EVENT_AFTER
+	}
+
+	for _, set := range sets {
+		if !set.Status.IsReady() {
+			logger.Infof("%v/%v: installer set %v no yet ready, wait !", i.resourceKind, setType, set.GetName())
+			return v1alpha1.REQUEUE_EVENT_AFTER
+		}
+	}
 	return nil
 }
 
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/update.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/update.go
index 8dc1711a0..69fc0f684 100644
--- a/pkg/reconciler/kubernetes/tektoninstallerset/client/update.go
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/update.go
@@ -29,12 +29,12 @@ import (
 	"knative.dev/pkg/logging"
 )
 
-func (i *InstallerSetClient) Update(ctx context.Context, comp v1alpha1.TektonComponent, toBeUpdatedIS []v1alpha1.TektonInstallerSet, manifest *mf.Manifest, isType string) ([]v1alpha1.TektonInstallerSet, error) {
+func (i *InstallerSetClient) update(ctx context.Context, comp v1alpha1.TektonComponent, toBeUpdatedIS []v1alpha1.TektonInstallerSet, manifest *mf.Manifest, filterAndTransform FilterAndTransform, isType string) ([]v1alpha1.TektonInstallerSet, error) {
 	logger := logging.FromContext(ctx).With("kind", i.resourceKind, "type", isType)
 
 	switch isType {
 	case InstallerTypeMain:
-		sets, err := i.updateMainSets(ctx, comp, toBeUpdatedIS, manifest)
+		sets, err := i.updateMainSets(ctx, comp, toBeUpdatedIS, manifest, filterAndTransform)
 		if err != nil {
 			logger.Errorf("installer set update failed for main type: %v", err)
 			return sets, err
@@ -43,7 +43,7 @@ func (i *InstallerSetClient) Update(ctx context.Context, comp v1alpha1.TektonCom
 
 	case InstallerTypePre, InstallerTypePost:
 		logger.Infof("updating installer set: %v", toBeUpdatedIS[0].GetName())
-		updatedSet, err := i.updateSet(ctx, comp, toBeUpdatedIS[0], manifest)
+		updatedSet, err := i.updateSet(ctx, comp, toBeUpdatedIS[0], manifest, filterAndTransform)
 		if err != nil {
 			return nil, fmt.Errorf("failed to update installerset : %v", err)
 		}
@@ -60,7 +60,7 @@ func (i *InstallerSetClient) Update(ctx context.Context, comp v1alpha1.TektonCom
 	return nil, nil
 }
 
-func (i *InstallerSetClient) updateMainSets(ctx context.Context, comp v1alpha1.TektonComponent, toBeUpdatedIS []v1alpha1.TektonInstallerSet, manifest *mf.Manifest) ([]v1alpha1.TektonInstallerSet, error) {
+func (i *InstallerSetClient) updateMainSets(ctx context.Context, comp v1alpha1.TektonComponent, toBeUpdatedIS []v1alpha1.TektonInstallerSet, manifest *mf.Manifest, filterAndTransform FilterAndTransform) ([]v1alpha1.TektonInstallerSet, error) {
 	logger := logging.FromContext(ctx)
 	logger.Infof("updating main installersets for %v", i.resourceKind)
 
@@ -79,7 +79,7 @@ func (i *InstallerSetClient) updateMainSets(ctx context.Context, comp v1alpha1.T
 			manifest = &deploymentManifest
 		}
 
-		updatedSet, err := i.updateSet(ctx, comp, is, manifest)
+		updatedSet, err := i.updateSet(ctx, comp, is, manifest, filterAndTransform)
 		if err != nil {
 			return nil, fmt.Errorf("failed to update installerset : %v", err)
 		}
@@ -90,7 +90,7 @@ func (i *InstallerSetClient) updateMainSets(ctx context.Context, comp v1alpha1.T
 	return updatedSets, nil
 }
 
-func (i *InstallerSetClient) updateSet(ctx context.Context, comp v1alpha1.TektonComponent, set v1alpha1.TektonInstallerSet, manifest *mf.Manifest) (*v1alpha1.TektonInstallerSet, error) {
+func (i *InstallerSetClient) updateSet(ctx context.Context, comp v1alpha1.TektonComponent, set v1alpha1.TektonInstallerSet, manifest *mf.Manifest, filterAndTransform FilterAndTransform) (*v1alpha1.TektonInstallerSet, error) {
 	var updatedSet *v1alpha1.TektonInstallerSet
 	retryErr := retry.RetryOnConflict(retry.DefaultRetry, func() error {
 		onCluster, err := i.clientSet.Get(ctx, set.GetName(), metav1.GetOptions{})
@@ -98,7 +98,7 @@ func (i *InstallerSetClient) updateSet(ctx context.Context, comp v1alpha1.Tekton
 			return err
 		}
 
-		manifest, err = i.filterAndTransform(ctx, manifest, comp)
+		manifest, err = filterAndTransform(ctx, manifest, comp)
 		if err != nil {
 			return err
 		}
diff --git a/pkg/reconciler/kubernetes/tektonpipeline/controller.go b/pkg/reconciler/kubernetes/tektonpipeline/controller.go
index 36593135b..30f9fabba 100644
--- a/pkg/reconciler/kubernetes/tektonpipeline/controller.go
+++ b/pkg/reconciler/kubernetes/tektonpipeline/controller.go
@@ -66,12 +66,11 @@ func NewExtendedController(generator common.ExtensionGenerator) injection.Contro
 		tisClient := operatorclient.Get(ctx).OperatorV1alpha1().TektonInstallerSets()
 
 		c := &Reconciler{
-			kubeClientSet:   kubeclient.Get(ctx),
-			extension:       generator(ctx),
-			manifest:        manifest,
-			pipelineVersion: pipelineVer,
-			installerSetClient: client.NewInstallerSetClient(tisClient, &manifest,
-				operatorVer, pipelineVer, v1alpha1.KindTektonPipeline, filterAndTransform(generator(ctx)), metrics),
+			kubeClientSet:      kubeclient.Get(ctx),
+			extension:          generator(ctx),
+			manifest:           manifest,
+			pipelineVersion:    pipelineVer,
+			installerSetClient: client.NewInstallerSetClient(tisClient, operatorVer, pipelineVer, v1alpha1.KindTektonPipeline, metrics),
 		}
 		impl := tektonPipelineReconciler.NewImpl(ctx, c)
 
diff --git a/pkg/reconciler/kubernetes/tektonpipeline/reconcile.go b/pkg/reconciler/kubernetes/tektonpipeline/reconcile.go
index 6ef81f439..8512b61ae 100644
--- a/pkg/reconciler/kubernetes/tektonpipeline/reconcile.go
+++ b/pkg/reconciler/kubernetes/tektonpipeline/reconcile.go
@@ -81,20 +81,35 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tp *v1alpha1.TektonPipel
 	}
 
 	if err := r.extension.PreReconcile(ctx, tp); err != nil {
-		tp.Status.MarkPreReconcilerFailed(fmt.Sprintf("PreReconciliation failed: %s", err.Error()))
+		msg := fmt.Sprintf("PreReconciliation failed: %s", err.Error())
+		logger.Error(msg)
+		if err == v1alpha1.REQUEUE_EVENT_AFTER {
+			return nil
+		}
+		tp.Status.MarkPreReconcilerFailed(msg)
 		return err
 	}
 
 	// Mark PreReconcile Complete
 	tp.Status.MarkPreReconcilerComplete()
 
-	if err := r.installerSetClient.MainSet(ctx, tp); err != nil {
-		logger.Errorf("failed for main set: %v", err)
+	if err := r.installerSetClient.MainSet(ctx, tp, &r.manifest, filterAndTransform(r.extension)); err != nil {
+		msg := fmt.Sprintf("Main Reconcilation failed: %s", err.Error())
+		logger.Error(msg)
+		if err == v1alpha1.REQUEUE_EVENT_AFTER {
+			return nil
+		}
+		tp.Status.MarkInstallerSetNotReady(msg)
 		return err
 	}
 
 	if err := r.extension.PostReconcile(ctx, tp); err != nil {
-		tp.Status.MarkPostReconcilerFailed(fmt.Sprintf("PostReconciliation failed: %s", err.Error()))
+		msg := fmt.Sprintf("PostReconciliation failed: %s", err.Error())
+		logger.Error(msg)
+		if err == v1alpha1.REQUEUE_EVENT_AFTER {
+			return nil
+		}
+		tp.Status.MarkPostReconcilerFailed(msg)
 		return err
 	}
 
diff --git a/pkg/reconciler/kubernetes/tektonresult/tektonresult.go b/pkg/reconciler/kubernetes/tektonresult/tektonresult.go
index c8fdf005a..8f72f5af6 100644
--- a/pkg/reconciler/kubernetes/tektonresult/tektonresult.go
+++ b/pkg/reconciler/kubernetes/tektonresult/tektonresult.go
@@ -121,7 +121,7 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tr *v1alpha1.TektonResul
 	// find the valid tekton-pipeline installation
 	tp, err := common.PipelineReady(r.pipelineInformer)
 	if err != nil {
-		if err.Error() == common.PipelineNotReady {
+		if err.Error() == common.PipelineNotReady || err == v1alpha1.DEPENDENCY_UPGRADE_PENDING_ERR {
 			tr.Status.MarkDependencyInstalling("tekton-pipelines is still installing")
 			// wait for pipeline status to change
 			return fmt.Errorf(common.PipelineNotReady)
diff --git a/pkg/reconciler/kubernetes/tektontrigger/controller.go b/pkg/reconciler/kubernetes/tektontrigger/controller.go
index a52063c02..6844cadac 100644
--- a/pkg/reconciler/kubernetes/tektontrigger/controller.go
+++ b/pkg/reconciler/kubernetes/tektontrigger/controller.go
@@ -68,12 +68,11 @@ func NewExtendedController(generator common.ExtensionGenerator) injection.Contro
 		tisClient := operatorclient.Get(ctx).OperatorV1alpha1().TektonInstallerSets()
 
 		c := &Reconciler{
-			pipelineInformer: tektonPipelineinformer.Get(ctx),
-			installerSetClient: client.NewInstallerSetClient(tisClient, &manifest,
-				operatorVer, triggersVer, v1alpha1.KindTektonTrigger, filterAndTransform(generator(ctx)), metrics),
-			extension:       generator(ctx),
-			manifest:        manifest,
-			triggersVersion: triggersVer,
+			pipelineInformer:   tektonPipelineinformer.Get(ctx),
+			installerSetClient: client.NewInstallerSetClient(tisClient, operatorVer, triggersVer, v1alpha1.KindTektonTrigger, metrics),
+			extension:          generator(ctx),
+			manifest:           manifest,
+			triggersVersion:    triggersVer,
 		}
 		impl := tektonTriggerreconciler.NewImpl(ctx, c)
 
diff --git a/pkg/reconciler/kubernetes/tektontrigger/reconcile.go b/pkg/reconciler/kubernetes/tektontrigger/reconcile.go
index bd96b0190..5a8264b48 100644
--- a/pkg/reconciler/kubernetes/tektontrigger/reconcile.go
+++ b/pkg/reconciler/kubernetes/tektontrigger/reconcile.go
@@ -70,7 +70,7 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tt *v1alpha1.TektonTrigg
 	//Make sure TektonPipeline is installed before proceeding with
 	//TektonTrigger
 	if _, err := common.PipelineReady(r.pipelineInformer); err != nil {
-		if err.Error() == common.PipelineNotReady {
+		if err.Error() == common.PipelineNotReady || err == v1alpha1.DEPENDENCY_UPGRADE_PENDING_ERR {
 			tt.Status.MarkDependencyInstalling("tekton-pipelines is still installing")
 			// wait for pipeline status to change
 			return v1alpha1.REQUEUE_EVENT_AFTER
@@ -85,20 +85,35 @@ func (r *Reconciler) ReconcileKind(ctx context.Context, tt *v1alpha1.TektonTrigg
 	tt.SetDefaults(ctx)
 
 	if err := r.extension.PreReconcile(ctx, tt); err != nil {
-		tt.Status.MarkPreReconcilerFailed(fmt.Sprintf("PreReconciliation failed: %s", err.Error()))
+		msg := fmt.Sprintf("PreReconciliation failed: %s", err.Error())
+		logger.Error(msg)
+		if err == v1alpha1.REQUEUE_EVENT_AFTER {
+			return nil
+		}
+		tt.Status.MarkPreReconcilerFailed(msg)
 		return err
 	}
 
 	//Mark PreReconcile Complete
 	tt.Status.MarkPreReconcilerComplete()
 
-	if err := r.installerSetClient.MainSet(ctx, tt); err != nil {
-		logger.Errorf("failed for main set: %v", err)
+	if err := r.installerSetClient.MainSet(ctx, tt, &r.manifest, filterAndTransform(r.extension)); err != nil {
+		msg := fmt.Sprintf("Main Reconcilation failed: %s", err.Error())
+		logger.Error(msg)
+		if err == v1alpha1.REQUEUE_EVENT_AFTER {
+			return nil
+		}
+		tt.Status.MarkInstallerSetNotReady(msg)
 		return err
 	}
 
 	if err := r.extension.PostReconcile(ctx, tt); err != nil {
-		tt.Status.MarkPostReconcilerFailed(fmt.Sprintf("PostReconciliation failed: %s", err.Error()))
+		msg := fmt.Sprintf("PostReconciliation failed: %s", err.Error())
+		logger.Error(msg)
+		if err == v1alpha1.REQUEUE_EVENT_AFTER {
+			return nil
+		}
+		tt.Status.MarkPostReconcilerFailed(msg)
 		return err
 	}
 
diff --git a/pkg/reconciler/openshift/tektonconfig/extension.go b/pkg/reconciler/openshift/tektonconfig/extension.go
index 88489dd6a..4fd9f9396 100644
--- a/pkg/reconciler/openshift/tektonconfig/extension.go
+++ b/pkg/reconciler/openshift/tektonconfig/extension.go
@@ -27,7 +27,6 @@ import (
 	operatorclient "github.com/tektoncd/operator/pkg/client/injection/client"
 	"github.com/tektoncd/operator/pkg/reconciler/common"
 	"github.com/tektoncd/operator/pkg/reconciler/openshift/tektonconfig/extension"
-	openshiftPipeline "github.com/tektoncd/operator/pkg/reconciler/openshift/tektonpipeline"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
 	kubeclient "knative.dev/pkg/client/injection/kube/client"
@@ -63,7 +62,6 @@ func (oe openshiftExtension) PreReconcile(ctx context.Context, tc v1alpha1.Tekto
 	}
 
 	// set openshift specific defaults
-	openshiftPipeline.SetDefault(&config.Spec.Pipeline)
 	r.setDefault()
 
 	// below code helps to retain state of pre-existing SA at the time of upgrade
diff --git a/pkg/reconciler/openshift/tektonpipeline/extension.go b/pkg/reconciler/openshift/tektonpipeline/extension.go
index b69063403..0f153f057 100644
--- a/pkg/reconciler/openshift/tektonpipeline/extension.go
+++ b/pkg/reconciler/openshift/tektonpipeline/extension.go
@@ -21,79 +21,37 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/go-logr/zapr"
-	mfc "github.com/manifestival/client-go-client"
 	mf "github.com/manifestival/manifestival"
 	"github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
-	"github.com/tektoncd/operator/pkg/client/clientset/versioned"
 	operatorclient "github.com/tektoncd/operator/pkg/client/injection/client"
 	"github.com/tektoncd/operator/pkg/reconciler/common"
+	"github.com/tektoncd/operator/pkg/reconciler/kubernetes/tektoninstallerset/client"
 	occommon "github.com/tektoncd/operator/pkg/reconciler/openshift/common"
-	"go.uber.org/zap"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"knative.dev/pkg/injection"
 	"knative.dev/pkg/logging"
-	"knative.dev/pkg/ptr"
 )
 
 const (
-	// DefaultDisableAffinityAssistant is default value of disable affinity assistant flag
-	DefaultDisableAffinityAssistant = true
-	monitoringLabel                 = "openshift.io/cluster-monitoring=true"
-
-	enableMetricsKey          = "enableMetrics"
-	enableMetricsDefaultValue = "true"
-
-	versionKey = "VERSION"
-
-	prePipelineInstallerSet  = "PrePipeline"
-	postPipelineInstallerSet = "PostPipeline"
-)
-
-var (
-	preReconcileSelector = metav1.LabelSelector{
-		MatchLabels: map[string]string{
-			v1alpha1.CreatedByKey:     createdByValue,
-			v1alpha1.InstallerSetType: prePipelineInstallerSet,
-		},
-	}
-	postReconcileSelector = metav1.LabelSelector{
-		MatchLabels: map[string]string{
-			v1alpha1.CreatedByKey:     createdByValue,
-			v1alpha1.InstallerSetType: postPipelineInstallerSet,
-		},
-	}
+	monitoringLabel  = "openshift.io/cluster-monitoring=true"
+	enableMetricsKey = "enableMetrics"
+	versionKey       = "VERSION"
 )
 
 func OpenShiftExtension(ctx context.Context) common.Extension {
 	logger := logging.FromContext(ctx)
-	mfclient, err := mfc.NewClient(injection.GetConfig(ctx))
-	if err != nil {
-		logger.Fatalw("error creating client from injected config", zap.Error(err))
-	}
-	mflogger := zapr.NewLogger(logger.Named("manifestival").Desugar())
-	manifest, err := mf.ManifestFrom(mf.Slice{}, mf.UseClient(mfclient), mf.UseLogger(mflogger))
-	if err != nil {
-		logger.Fatalw("error creating initial manifest", zap.Error(err))
-	}
-
 	version := os.Getenv(versionKey)
 	if version == "" {
 		logger.Fatal("Failed to find version from env")
 	}
 
 	ext := openshiftExtension{
-		operatorClientSet: operatorclient.Get(ctx),
-		manifest:          manifest,
-		version:           version,
+		installerSetClient: client.NewInstallerSetClient(operatorclient.Get(ctx).OperatorV1alpha1().TektonInstallerSets(),
+			version, "pre-pipeline", v1alpha1.KindTektonPipeline, nil),
 	}
 	return ext
 }
 
 type openshiftExtension struct {
-	operatorClientSet versioned.Interface
-	manifest          mf.Manifest
-	version           string
+	installerSetClient *client.InstallerSetClient
 }
 
 func (oe openshiftExtension) Transformers(comp v1alpha1.TektonComponent) []mf.Transformer {
@@ -113,149 +71,90 @@ func (oe openshiftExtension) Transformers(comp v1alpha1.TektonComponent) []mf.Tr
 	return trns
 }
 func (oe openshiftExtension) PreReconcile(ctx context.Context, comp v1alpha1.TektonComponent) error {
-	koDataDir := os.Getenv(common.KoEnvKey)
-	tp := comp.(*v1alpha1.TektonPipeline)
-
-	SetDefault(&tp.Spec.Pipeline)
-
-	preReconcilerLS, err := common.LabelSelector(preReconcileSelector)
+	manifest, err := preManifest()
 	if err != nil {
 		return err
 	}
-	exist, err := checkIfInstallerSetExist(ctx, oe.operatorClientSet, oe.version, tp, preReconcilerLS)
-	if err != nil {
+	if err := oe.installerSetClient.PreSet(ctx, comp, manifest, filterAndTransform()); err != nil {
 		return err
 	}
-
-	// If installer set doesn't exist then create a new one
-	if !exist {
-
-		// make sure that openshift-pipelines namespace exists
-		namespaceLocation := filepath.Join(koDataDir, "tekton-namespace")
-		if err := common.AppendManifest(&oe.manifest, namespaceLocation); err != nil {
-			return err
-		}
-
-		// add inject CA bundles manifests
-		cabundlesLocation := filepath.Join(koDataDir, "cabundles")
-		if err := common.AppendManifest(&oe.manifest, cabundlesLocation); err != nil {
-			return err
-		}
-
-		// add pipelines-scc
-		pipelinesSCCLocation := filepath.Join(koDataDir, "tekton-pipeline", "00-prereconcile")
-		if err := common.AppendManifest(&oe.manifest, pipelinesSCCLocation); err != nil {
-			return err
-		}
-
-		if err := common.Transform(ctx, &oe.manifest, tp); err != nil {
-			return err
-		}
-
-		if err := createInstallerSet(ctx, oe.operatorClientSet, tp, oe.manifest, oe.version,
-			prePipelineInstallerSet); err != nil {
-			return err
-		}
-	}
-
 	return nil
 }
 
 func (oe openshiftExtension) PostReconcile(ctx context.Context, comp v1alpha1.TektonComponent) error {
-	koDataDir := os.Getenv(common.KoEnvKey)
 	pipeline := comp.(*v1alpha1.TektonPipeline)
 
-	postReconcilerLS, err := common.LabelSelector(postReconcileSelector)
-	if err != nil {
-		return err
-	}
 	// Install monitoring if metrics is enabled
 	value := findParam(pipeline.Spec.Params, enableMetricsKey)
 
 	if value == "true" {
-		exist, err := checkIfInstallerSetExist(ctx, oe.operatorClientSet, oe.version, pipeline, postReconcilerLS)
+		manifest, err := postManifest()
 		if err != nil {
 			return err
 		}
-
-		if !exist {
-
-			monitoringLocation := filepath.Join(koDataDir, "openshift-monitoring")
-			if err := common.AppendManifest(&oe.manifest, monitoringLocation); err != nil {
-				return err
-			}
-
-			if err := common.Transform(ctx, &oe.manifest, pipeline); err != nil {
-				return err
-			}
-
-			if err := createInstallerSet(ctx, oe.operatorClientSet, pipeline, oe.manifest, oe.version,
-				postPipelineInstallerSet); err != nil {
-				return err
-			}
+		if err := oe.installerSetClient.PostSet(ctx, comp, manifest, filterAndTransform()); err != nil {
+			return err
 		}
-
 	} else {
-		return deleteInstallerSet(ctx, oe.operatorClientSet, pipeline, postPipelineInstallerSet, postReconcilerLS)
+		if err := oe.installerSetClient.CleanupPostSet(ctx); err != nil {
+			return err
+		}
 	}
 
 	return nil
 }
 func (oe openshiftExtension) Finalize(ctx context.Context, comp v1alpha1.TektonComponent) error {
-	pipeline := comp.(*v1alpha1.TektonPipeline)
-	postReconcilerLS, err := common.LabelSelector(postReconcileSelector)
-	if err != nil {
+	if err := oe.installerSetClient.CleanupPostSet(ctx); err != nil {
 		return err
 	}
-	if err := deleteInstallerSet(ctx, oe.operatorClientSet, pipeline,
-		postPipelineInstallerSet, postReconcilerLS); err != nil {
-		return err
-	}
-	preReconcilerLS, err := common.LabelSelector(preReconcileSelector)
-	if err != nil {
-		return err
-	}
-	if err := deleteInstallerSet(ctx, oe.operatorClientSet, pipeline,
-		prePipelineInstallerSet, preReconcilerLS); err != nil {
+	if err := oe.installerSetClient.CleanupPreSet(ctx); err != nil {
 		return err
 	}
 	return nil
 }
 
-func SetDefault(pipeline *v1alpha1.Pipeline) {
+func preManifest() (*mf.Manifest, error) {
+	koDataDir := os.Getenv(common.KoEnvKey)
+	manifest := &mf.Manifest{}
 
-	// Set default service account as pipeline
-	if pipeline.DefaultServiceAccount == "" {
-		pipeline.DefaultServiceAccount = common.DefaultSA
+	// make sure that openshift-pipelines namespace exists
+	namespaceLocation := filepath.Join(koDataDir, "tekton-namespace")
+	if err := common.AppendManifest(manifest, namespaceLocation); err != nil {
+		return nil, err
 	}
 
-	// Set `disable-affinity-assistant` to true if not set in CR
-	// webhook will not set any value but by default in pipelines configmap it will be false
-	if pipeline.DisableAffinityAssistant == nil {
-		pipeline.DisableAffinityAssistant = ptr.Bool(DefaultDisableAffinityAssistant)
+	// add inject CA bundles manifests
+	cabundlesLocation := filepath.Join(koDataDir, "cabundles")
+	if err := common.AppendManifest(manifest, cabundlesLocation); err != nil {
+		return nil, err
 	}
 
-	// Add params with default values if not defined by user
-	var found = false
-	for i, p := range pipeline.Params {
-		if p.Name == enableMetricsKey {
-			found = true
-			// If the value set is invalid then set key to default value
-			// Not returning an error if the values is invalid as
-			// we validate in reconciler and this would affect the
-			// rest of the installation
-			if p.Value != "false" && p.Value != "true" {
-				pipeline.Params[i].Value = enableMetricsDefaultValue
-			}
-			break
-		}
+	// add pipelines-scc
+	pipelinesSCCLocation := filepath.Join(koDataDir, "tekton-pipeline", "00-prereconcile")
+	if err := common.AppendManifest(manifest, pipelinesSCCLocation); err != nil {
+		return nil, err
 	}
 
-	if !found {
-		pipeline.Params = append(pipeline.Params, v1alpha1.Param{
-			Name:  enableMetricsKey,
-			Value: enableMetricsDefaultValue,
-		})
+	return manifest, nil
+}
+
+func postManifest() (*mf.Manifest, error) {
+	koDataDir := os.Getenv(common.KoEnvKey)
+	manifest := &mf.Manifest{}
+
+	monitoringLocation := filepath.Join(koDataDir, "openshift-monitoring")
+	if err := common.AppendManifest(manifest, monitoringLocation); err != nil {
+		return nil, err
+	}
+	return manifest, nil
+}
+
+func filterAndTransform() client.FilterAndTransform {
+	return func(ctx context.Context, manifest *mf.Manifest, comp v1alpha1.TektonComponent) (*mf.Manifest, error) {
+		if err := common.Transform(ctx, manifest, comp); err != nil {
+			return nil, err
+		}
+		return manifest, nil
 	}
 }
 
diff --git a/pkg/reconciler/openshift/tektonpipeline/installerset.go b/pkg/reconciler/openshift/tektonpipeline/installerset.go
deleted file mode 100644
index 02e8e85fd..000000000
--- a/pkg/reconciler/openshift/tektonpipeline/installerset.go
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
-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
-
-    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 tektonpipeline
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	mf "github.com/manifestival/manifestival"
-	"github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
-	clientset "github.com/tektoncd/operator/pkg/client/clientset/versioned"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-const createdByValue = "TektonPipeline"
-
-// checkIfInstallerSetExist checks if installer set exists for a component and return true/false based on it
-// and if installer set which already exist is of older version/ or if target namespace is different then it
-// deletes and return false to create a new installer set
-func checkIfInstallerSetExist(ctx context.Context, oc clientset.Interface, relVersion string,
-	tp *v1alpha1.TektonPipeline, ls string) (bool, error) {
-
-	// Check if installer set is already created
-	installerSets, err := oc.OperatorV1alpha1().TektonInstallerSets().
-		List(ctx, metav1.ListOptions{
-			LabelSelector: ls,
-		})
-	if err != nil {
-		return false, err
-	}
-	if len(installerSets.Items) == 0 {
-		// only scenario where this function returns
-		// false, nil
-		return false, nil
-	}
-
-	// if the List query returns more than 1 InstallerSets,
-	// then delete all of them as we are expecting only one
-	// If there are more than one then it means the state is
-	// corrupted/unexpected. So to get back to desired state
-	// delete all installerSets that match the labelSelector
-	if len(installerSets.Items) > 1 {
-		err = oc.OperatorV1alpha1().TektonInstallerSets().
-			DeleteCollection(ctx, metav1.DeleteOptions{}, metav1.ListOptions{
-				LabelSelector: ls,
-			})
-
-		if err != nil {
-			return false, err
-		}
-		return false, v1alpha1.RECONCILE_AGAIN_ERR
-	}
-
-	// if the InstallerSet already exists then check then validate it:
-	// Check release version and target namespace
-	// If anyone of this is not as expected then delete existing
-	// InstallerSet and return false
-
-	version, vOk := installerSets.Items[0].Labels[v1alpha1.ReleaseVersionKey]
-	namespace, nOk := installerSets.Items[0].Annotations[v1alpha1.TargetNamespaceKey]
-
-	if vOk && nOk {
-		if version == relVersion && namespace == tp.Spec.TargetNamespace {
-			// only scenarion where this function returns
-			// true
-			return true, nil
-		}
-	}
-
-	// release version/ target namespace information doesn't exist in InstallerSet
-	// or is different from expected
-	// deleted existing InstallerSet and return false
-
-	err = oc.OperatorV1alpha1().TektonInstallerSets().
-		Delete(ctx, installerSets.Items[0].GetName(), metav1.DeleteOptions{})
-	if err != nil {
-		return false, err
-	}
-
-	return false, v1alpha1.RECONCILE_AGAIN_ERR
-}
-
-func createInstallerSet(ctx context.Context, oc clientset.Interface, tp *v1alpha1.TektonPipeline,
-	manifest mf.Manifest, releaseVersion, component string) error {
-
-	is := makeInstallerSet(tp, manifest, component, releaseVersion)
-
-	createdIs, err := oc.OperatorV1alpha1().TektonInstallerSets().
-		Create(ctx, is, metav1.CreateOptions{})
-	if err != nil {
-		return err
-	}
-
-	if len(tp.Status.ExtentionInstallerSets) == 0 {
-		tp.Status.ExtentionInstallerSets = map[string]string{}
-	}
-
-	//// Update the status of pipeline with created installerSet name
-	tp.Status.ExtentionInstallerSets[component] = createdIs.Name
-	return nil
-}
-
-func makeInstallerSet(tp *v1alpha1.TektonPipeline, manifest mf.Manifest, installerSetType, releaseVersion string) *v1alpha1.TektonInstallerSet {
-	ownerRef := *metav1.NewControllerRef(tp, tp.GetGroupVersionKind())
-	return &v1alpha1.TektonInstallerSet{
-		ObjectMeta: metav1.ObjectMeta{
-			GenerateName: fmt.Sprintf("%s-", strings.ToLower(installerSetType)),
-			Labels: map[string]string{
-				v1alpha1.CreatedByKey:      createdByValue,
-				v1alpha1.ReleaseVersionKey: releaseVersion,
-				v1alpha1.InstallerSetType:  installerSetType,
-			},
-			Annotations: map[string]string{
-				v1alpha1.ReleaseVersionKey:  releaseVersion,
-				v1alpha1.TargetNamespaceKey: tp.Spec.TargetNamespace,
-			},
-			OwnerReferences: []metav1.OwnerReference{ownerRef},
-		},
-		Spec: v1alpha1.TektonInstallerSetSpec{
-			Manifests: manifest.Resources(),
-		},
-	}
-}
-
-func deleteInstallerSet(ctx context.Context, oc clientset.Interface, ta *v1alpha1.TektonPipeline, component, labelSelector string) error {
-
-	// delete the installer set
-	err := oc.OperatorV1alpha1().TektonInstallerSets().
-		DeleteCollection(ctx, metav1.DeleteOptions{},
-			metav1.ListOptions{
-				LabelSelector: labelSelector,
-			})
-	if err != nil {
-		return err
-	}
-
-	// clear the name of installer set from TektonPipeline status
-	delete(ta.Status.ExtentionInstallerSets, component)
-	return nil
-}
diff --git a/vendor/google.golang.org/grpc/dialoptions.go b/vendor/google.golang.org/grpc/dialoptions.go
index 60403bc16..9372dc322 100644
--- a/vendor/google.golang.org/grpc/dialoptions.go
+++ b/vendor/google.golang.org/grpc/dialoptions.go
@@ -29,6 +29,7 @@ import (
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/internal"
 	internalbackoff "google.golang.org/grpc/internal/backoff"
+	"google.golang.org/grpc/internal/binarylog"
 	"google.golang.org/grpc/internal/transport"
 	"google.golang.org/grpc/keepalive"
 	"google.golang.org/grpc/resolver"
@@ -36,12 +37,13 @@ import (
 )
 
 func init() {
-	internal.AddExtraDialOptions = func(opt ...DialOption) {
+	internal.AddGlobalDialOptions = func(opt ...DialOption) {
 		extraDialOptions = append(extraDialOptions, opt...)
 	}
-	internal.ClearExtraDialOptions = func() {
+	internal.ClearGlobalDialOptions = func() {
 		extraDialOptions = nil
 	}
+	internal.WithBinaryLogger = withBinaryLogger
 }
 
 // dialOptions configure a Dial call. dialOptions are set by the DialOption
@@ -61,6 +63,7 @@ type dialOptions struct {
 	timeout                     time.Duration
 	scChan                      <-chan ServiceConfig
 	authority                   string
+	binaryLogger                binarylog.Logger
 	copts                       transport.ConnectOptions
 	callOptions                 []CallOption
 	channelzParentID            *channelz.Identifier
@@ -401,6 +404,14 @@ func WithStatsHandler(h stats.Handler) DialOption {
 	})
 }
 
+// withBinaryLogger returns a DialOption that specifies the binary logger for
+// this ClientConn.
+func withBinaryLogger(bl binarylog.Logger) DialOption {
+	return newFuncDialOption(func(o *dialOptions) {
+		o.binaryLogger = bl
+	})
+}
+
 // FailOnNonTempDialError returns a DialOption that specifies if gRPC fails on
 // non-temporary dial errors. If f is true, and dialer returns a non-temporary
 // error, gRPC will fail the connection to the network address and won't try to
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/binarylog.go b/vendor/google.golang.org/grpc/internal/binarylog/binarylog.go
index e3dfe204f..809d73cca 100644
--- a/vendor/google.golang.org/grpc/internal/binarylog/binarylog.go
+++ b/vendor/google.golang.org/grpc/internal/binarylog/binarylog.go
@@ -37,7 +37,7 @@ type Logger interface {
 // binLogger is the global binary logger for the binary. One of this should be
 // built at init time from the configuration (environment variable or flags).
 //
-// It is used to get a methodLogger for each individual method.
+// It is used to get a MethodLogger for each individual method.
 var binLogger Logger
 
 var grpclogLogger = grpclog.Component("binarylog")
@@ -56,11 +56,11 @@ func GetLogger() Logger {
 	return binLogger
 }
 
-// GetMethodLogger returns the methodLogger for the given methodName.
+// GetMethodLogger returns the MethodLogger for the given methodName.
 //
 // methodName should be in the format of "/service/method".
 //
-// Each methodLogger returned by this method is a new instance. This is to
+// Each MethodLogger returned by this method is a new instance. This is to
 // generate sequence id within the call.
 func GetMethodLogger(methodName string) MethodLogger {
 	if binLogger == nil {
@@ -117,7 +117,7 @@ func (l *logger) setDefaultMethodLogger(ml *MethodLoggerConfig) error {
 
 // Set method logger for "service/*".
 //
-// New methodLogger with same service overrides the old one.
+// New MethodLogger with same service overrides the old one.
 func (l *logger) setServiceMethodLogger(service string, ml *MethodLoggerConfig) error {
 	if _, ok := l.config.Services[service]; ok {
 		return fmt.Errorf("conflicting service rules for service %v found", service)
@@ -131,7 +131,7 @@ func (l *logger) setServiceMethodLogger(service string, ml *MethodLoggerConfig)
 
 // Set method logger for "service/method".
 //
-// New methodLogger with same method overrides the old one.
+// New MethodLogger with same method overrides the old one.
 func (l *logger) setMethodMethodLogger(method string, ml *MethodLoggerConfig) error {
 	if _, ok := l.config.Blacklist[method]; ok {
 		return fmt.Errorf("conflicting blacklist rules for method %v found", method)
@@ -161,11 +161,11 @@ func (l *logger) setBlacklist(method string) error {
 	return nil
 }
 
-// getMethodLogger returns the methodLogger for the given methodName.
+// getMethodLogger returns the MethodLogger for the given methodName.
 //
 // methodName should be in the format of "/service/method".
 //
-// Each methodLogger returned by this method is a new instance. This is to
+// Each MethodLogger returned by this method is a new instance. This is to
 // generate sequence id within the call.
 func (l *logger) GetMethodLogger(methodName string) MethodLogger {
 	s, m, err := grpcutil.ParseMethod(methodName)
@@ -174,16 +174,16 @@ func (l *logger) GetMethodLogger(methodName string) MethodLogger {
 		return nil
 	}
 	if ml, ok := l.config.Methods[s+"/"+m]; ok {
-		return newMethodLogger(ml.Header, ml.Message)
+		return NewTruncatingMethodLogger(ml.Header, ml.Message)
 	}
 	if _, ok := l.config.Blacklist[s+"/"+m]; ok {
 		return nil
 	}
 	if ml, ok := l.config.Services[s]; ok {
-		return newMethodLogger(ml.Header, ml.Message)
+		return NewTruncatingMethodLogger(ml.Header, ml.Message)
 	}
 	if l.config.All == nil {
 		return nil
 	}
-	return newMethodLogger(l.config.All.Header, l.config.All.Message)
+	return NewTruncatingMethodLogger(l.config.All.Header, l.config.All.Message)
 }
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/env_config.go b/vendor/google.golang.org/grpc/internal/binarylog/env_config.go
index ab589a76b..c5579e650 100644
--- a/vendor/google.golang.org/grpc/internal/binarylog/env_config.go
+++ b/vendor/google.golang.org/grpc/internal/binarylog/env_config.go
@@ -57,7 +57,7 @@ func NewLoggerFromConfigString(s string) Logger {
 	return l
 }
 
-// fillMethodLoggerWithConfigString parses config, creates methodLogger and adds
+// fillMethodLoggerWithConfigString parses config, creates TruncatingMethodLogger and adds
 // it to the right map in the logger.
 func (l *logger) fillMethodLoggerWithConfigString(config string) error {
 	// "" is invalid.
diff --git a/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go b/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go
index 24df0a1a0..179f4a26d 100644
--- a/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go
+++ b/vendor/google.golang.org/grpc/internal/binarylog/method_logger.go
@@ -52,7 +52,9 @@ type MethodLogger interface {
 	Log(LogEntryConfig)
 }
 
-type methodLogger struct {
+// TruncatingMethodLogger is a method logger that truncates headers and messages
+// based on configured fields.
+type TruncatingMethodLogger struct {
 	headerMaxLen, messageMaxLen uint64
 
 	callID          uint64
@@ -61,8 +63,9 @@ type methodLogger struct {
 	sink Sink // TODO(blog): make this plugable.
 }
 
-func newMethodLogger(h, m uint64) *methodLogger {
-	return &methodLogger{
+// NewTruncatingMethodLogger returns a new truncating method logger.
+func NewTruncatingMethodLogger(h, m uint64) *TruncatingMethodLogger {
+	return &TruncatingMethodLogger{
 		headerMaxLen:  h,
 		messageMaxLen: m,
 
@@ -75,8 +78,8 @@ func newMethodLogger(h, m uint64) *methodLogger {
 
 // Build is an internal only method for building the proto message out of the
 // input event. It's made public to enable other library to reuse as much logic
-// in methodLogger as possible.
-func (ml *methodLogger) Build(c LogEntryConfig) *pb.GrpcLogEntry {
+// in TruncatingMethodLogger as possible.
+func (ml *TruncatingMethodLogger) Build(c LogEntryConfig) *pb.GrpcLogEntry {
 	m := c.toProto()
 	timestamp, _ := ptypes.TimestampProto(time.Now())
 	m.Timestamp = timestamp
@@ -95,11 +98,11 @@ func (ml *methodLogger) Build(c LogEntryConfig) *pb.GrpcLogEntry {
 }
 
 // Log creates a proto binary log entry, and logs it to the sink.
-func (ml *methodLogger) Log(c LogEntryConfig) {
+func (ml *TruncatingMethodLogger) Log(c LogEntryConfig) {
 	ml.sink.Write(ml.Build(c))
 }
 
-func (ml *methodLogger) truncateMetadata(mdPb *pb.Metadata) (truncated bool) {
+func (ml *TruncatingMethodLogger) truncateMetadata(mdPb *pb.Metadata) (truncated bool) {
 	if ml.headerMaxLen == maxUInt {
 		return false
 	}
@@ -129,7 +132,7 @@ func (ml *methodLogger) truncateMetadata(mdPb *pb.Metadata) (truncated bool) {
 	return truncated
 }
 
-func (ml *methodLogger) truncateMessage(msgPb *pb.Message) (truncated bool) {
+func (ml *TruncatingMethodLogger) truncateMessage(msgPb *pb.Message) (truncated bool) {
 	if ml.messageMaxLen == maxUInt {
 		return false
 	}
diff --git a/vendor/google.golang.org/grpc/internal/envconfig/observability.go b/vendor/google.golang.org/grpc/internal/envconfig/observability.go
new file mode 100644
index 000000000..821dd0a7c
--- /dev/null
+++ b/vendor/google.golang.org/grpc/internal/envconfig/observability.go
@@ -0,0 +1,36 @@
+/*
+ *
+ * Copyright 2022 gRPC 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 envconfig
+
+import "os"
+
+const (
+	envObservabilityConfig     = "GRPC_GCP_OBSERVABILITY_CONFIG"
+	envObservabilityConfigFile = "GRPC_GCP_OBSERVABILITY_CONFIG_FILE"
+)
+
+var (
+	// ObservabilityConfig is the json configuration for the gcp/observability
+	// package specified directly in the envObservabilityConfig env var.
+	ObservabilityConfig = os.Getenv(envObservabilityConfig)
+	// ObservabilityConfigFile is the json configuration for the
+	// gcp/observability specified in a file with the location specified in
+	// envObservabilityConfigFile env var.
+	ObservabilityConfigFile = os.Getenv(envObservabilityConfigFile)
+)
diff --git a/vendor/google.golang.org/grpc/internal/internal.go b/vendor/google.golang.org/grpc/internal/internal.go
index 87cacb5b8..fd0ee3dca 100644
--- a/vendor/google.golang.org/grpc/internal/internal.go
+++ b/vendor/google.golang.org/grpc/internal/internal.go
@@ -63,24 +63,31 @@ var (
 	// xDS-enabled server invokes this method on a grpc.Server when a particular
 	// listener moves to "not-serving" mode.
 	DrainServerTransports interface{} // func(*grpc.Server, string)
-	// AddExtraServerOptions adds an array of ServerOption that will be
+	// AddGlobalServerOptions adds an array of ServerOption that will be
 	// effective globally for newly created servers. The priority will be: 1.
 	// user-provided; 2. this method; 3. default values.
-	AddExtraServerOptions interface{} // func(opt ...ServerOption)
-	// ClearExtraServerOptions clears the array of extra ServerOption. This
+	AddGlobalServerOptions interface{} // func(opt ...ServerOption)
+	// ClearGlobalServerOptions clears the array of extra ServerOption. This
 	// method is useful in testing and benchmarking.
-	ClearExtraServerOptions func()
-	// AddExtraDialOptions adds an array of DialOption that will be effective
+	ClearGlobalServerOptions func()
+	// AddGlobalDialOptions adds an array of DialOption that will be effective
 	// globally for newly created client channels. The priority will be: 1.
 	// user-provided; 2. this method; 3. default values.
-	AddExtraDialOptions interface{} // func(opt ...DialOption)
-	// ClearExtraDialOptions clears the array of extra DialOption. This
+	AddGlobalDialOptions interface{} // func(opt ...DialOption)
+	// ClearGlobalDialOptions clears the array of extra DialOption. This
 	// method is useful in testing and benchmarking.
-	ClearExtraDialOptions func()
+	ClearGlobalDialOptions func()
 	// JoinServerOptions combines the server options passed as arguments into a
 	// single server option.
 	JoinServerOptions interface{} // func(...grpc.ServerOption) grpc.ServerOption
 
+	// WithBinaryLogger returns a DialOption that specifies the binary logger
+	// for a ClientConn.
+	WithBinaryLogger interface{} // func(binarylog.Logger) grpc.DialOption
+	// BinaryLogger returns a ServerOption that can set the binary logger for a
+	// server.
+	BinaryLogger interface{} // func(binarylog.Logger) grpc.ServerOption
+
 	// NewXDSResolverWithConfigForTesting creates a new xds resolver builder using
 	// the provided xds bootstrap config instead of the global configuration from
 	// the supported environment variables.  The resolver.Builder is meant to be
diff --git a/vendor/google.golang.org/grpc/server.go b/vendor/google.golang.org/grpc/server.go
index 6ef3df67d..f4dde72b4 100644
--- a/vendor/google.golang.org/grpc/server.go
+++ b/vendor/google.golang.org/grpc/server.go
@@ -73,12 +73,13 @@ func init() {
 	internal.DrainServerTransports = func(srv *Server, addr string) {
 		srv.drainServerTransports(addr)
 	}
-	internal.AddExtraServerOptions = func(opt ...ServerOption) {
-		extraServerOptions = opt
+	internal.AddGlobalServerOptions = func(opt ...ServerOption) {
+		extraServerOptions = append(extraServerOptions, opt...)
 	}
-	internal.ClearExtraServerOptions = func() {
+	internal.ClearGlobalServerOptions = func() {
 		extraServerOptions = nil
 	}
+	internal.BinaryLogger = binaryLogger
 	internal.JoinServerOptions = newJoinServerOption
 }
 
@@ -156,6 +157,7 @@ type serverOptions struct {
 	streamInt             StreamServerInterceptor
 	chainUnaryInts        []UnaryServerInterceptor
 	chainStreamInts       []StreamServerInterceptor
+	binaryLogger          binarylog.Logger
 	inTapHandle           tap.ServerInHandle
 	statsHandlers         []stats.Handler
 	maxConcurrentStreams  uint32
@@ -469,6 +471,14 @@ func StatsHandler(h stats.Handler) ServerOption {
 	})
 }
 
+// binaryLogger returns a ServerOption that can set the binary logger for the
+// server.
+func binaryLogger(bl binarylog.Logger) ServerOption {
+	return newFuncServerOption(func(o *serverOptions) {
+		o.binaryLogger = bl
+	})
+}
+
 // UnknownServiceHandler returns a ServerOption that allows for adding a custom
 // unknown service handler. The provided method is a bidi-streaming RPC service
 // handler that will be invoked instead of returning the "unimplemented" gRPC
@@ -1216,9 +1226,16 @@ func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.
 			}
 		}()
 	}
-
-	binlog := binarylog.GetMethodLogger(stream.Method())
-	if binlog != nil {
+	var binlogs []binarylog.MethodLogger
+	if ml := binarylog.GetMethodLogger(stream.Method()); ml != nil {
+		binlogs = append(binlogs, ml)
+	}
+	if s.opts.binaryLogger != nil {
+		if ml := s.opts.binaryLogger.GetMethodLogger(stream.Method()); ml != nil {
+			binlogs = append(binlogs, ml)
+		}
+	}
+	if len(binlogs) != 0 {
 		ctx := stream.Context()
 		md, _ := metadata.FromIncomingContext(ctx)
 		logEntry := &binarylog.ClientHeader{
@@ -1238,7 +1255,9 @@ func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.
 		if peer, ok := peer.FromContext(ctx); ok {
 			logEntry.PeerAddr = peer.Addr
 		}
-		binlog.Log(logEntry)
+		for _, binlog := range binlogs {
+			binlog.Log(logEntry)
+		}
 	}
 
 	// comp and cp are used for compression.  decomp and dc are used for
@@ -1278,7 +1297,7 @@ func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.
 	}
 
 	var payInfo *payloadInfo
-	if len(shs) != 0 || binlog != nil {
+	if len(shs) != 0 || len(binlogs) != 0 {
 		payInfo = &payloadInfo{}
 	}
 	d, err := recvAndDecompress(&parser{r: stream}, stream, dc, s.opts.maxReceiveMessageSize, payInfo, decomp)
@@ -1304,10 +1323,13 @@ func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.
 				Length:     len(d),
 			})
 		}
-		if binlog != nil {
-			binlog.Log(&binarylog.ClientMessage{
+		if len(binlogs) != 0 {
+			cm := &binarylog.ClientMessage{
 				Message: d,
-			})
+			}
+			for _, binlog := range binlogs {
+				binlog.Log(cm)
+			}
 		}
 		if trInfo != nil {
 			trInfo.tr.LazyLog(&payload{sent: false, msg: v}, true)
@@ -1331,18 +1353,24 @@ func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.
 		if e := t.WriteStatus(stream, appStatus); e != nil {
 			channelz.Warningf(logger, s.channelzID, "grpc: Server.processUnaryRPC failed to write status: %v", e)
 		}
-		if binlog != nil {
+		if len(binlogs) != 0 {
 			if h, _ := stream.Header(); h.Len() > 0 {
 				// Only log serverHeader if there was header. Otherwise it can
 				// be trailer only.
-				binlog.Log(&binarylog.ServerHeader{
+				sh := &binarylog.ServerHeader{
 					Header: h,
-				})
+				}
+				for _, binlog := range binlogs {
+					binlog.Log(sh)
+				}
 			}
-			binlog.Log(&binarylog.ServerTrailer{
+			st := &binarylog.ServerTrailer{
 				Trailer: stream.Trailer(),
 				Err:     appErr,
-			})
+			}
+			for _, binlog := range binlogs {
+				binlog.Log(st)
+			}
 		}
 		return appErr
 	}
@@ -1368,26 +1396,34 @@ func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.
 				panic(fmt.Sprintf("grpc: Unexpected error (%T) from sendResponse: %v", st, st))
 			}
 		}
-		if binlog != nil {
+		if len(binlogs) != 0 {
 			h, _ := stream.Header()
-			binlog.Log(&binarylog.ServerHeader{
+			sh := &binarylog.ServerHeader{
 				Header: h,
-			})
-			binlog.Log(&binarylog.ServerTrailer{
+			}
+			st := &binarylog.ServerTrailer{
 				Trailer: stream.Trailer(),
 				Err:     appErr,
-			})
+			}
+			for _, binlog := range binlogs {
+				binlog.Log(sh)
+				binlog.Log(st)
+			}
 		}
 		return err
 	}
-	if binlog != nil {
+	if len(binlogs) != 0 {
 		h, _ := stream.Header()
-		binlog.Log(&binarylog.ServerHeader{
+		sh := &binarylog.ServerHeader{
 			Header: h,
-		})
-		binlog.Log(&binarylog.ServerMessage{
+		}
+		sm := &binarylog.ServerMessage{
 			Message: reply,
-		})
+		}
+		for _, binlog := range binlogs {
+			binlog.Log(sh)
+			binlog.Log(sm)
+		}
 	}
 	if channelz.IsOn() {
 		t.IncrMsgSent()
@@ -1399,11 +1435,14 @@ func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.
 	// Should the logging be in WriteStatus?  Should we ignore the WriteStatus
 	// error or allow the stats handler to see it?
 	err = t.WriteStatus(stream, statusOK)
-	if binlog != nil {
-		binlog.Log(&binarylog.ServerTrailer{
+	if len(binlogs) != 0 {
+		st := &binarylog.ServerTrailer{
 			Trailer: stream.Trailer(),
 			Err:     appErr,
-		})
+		}
+		for _, binlog := range binlogs {
+			binlog.Log(st)
+		}
 	}
 	return err
 }
@@ -1516,8 +1555,15 @@ func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transp
 		}()
 	}
 
-	ss.binlog = binarylog.GetMethodLogger(stream.Method())
-	if ss.binlog != nil {
+	if ml := binarylog.GetMethodLogger(stream.Method()); ml != nil {
+		ss.binlogs = append(ss.binlogs, ml)
+	}
+	if s.opts.binaryLogger != nil {
+		if ml := s.opts.binaryLogger.GetMethodLogger(stream.Method()); ml != nil {
+			ss.binlogs = append(ss.binlogs, ml)
+		}
+	}
+	if len(ss.binlogs) != 0 {
 		md, _ := metadata.FromIncomingContext(ctx)
 		logEntry := &binarylog.ClientHeader{
 			Header:     md,
@@ -1536,7 +1582,9 @@ func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transp
 		if peer, ok := peer.FromContext(ss.Context()); ok {
 			logEntry.PeerAddr = peer.Addr
 		}
-		ss.binlog.Log(logEntry)
+		for _, binlog := range ss.binlogs {
+			binlog.Log(logEntry)
+		}
 	}
 
 	// If dc is set and matches the stream's compression, use it.  Otherwise, try
@@ -1602,11 +1650,14 @@ func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transp
 			ss.mu.Unlock()
 		}
 		t.WriteStatus(ss.s, appStatus)
-		if ss.binlog != nil {
-			ss.binlog.Log(&binarylog.ServerTrailer{
+		if len(ss.binlogs) != 0 {
+			st := &binarylog.ServerTrailer{
 				Trailer: ss.s.Trailer(),
 				Err:     appErr,
-			})
+			}
+			for _, binlog := range ss.binlogs {
+				binlog.Log(st)
+			}
 		}
 		// TODO: Should we log an error from WriteStatus here and below?
 		return appErr
@@ -1617,11 +1668,14 @@ func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transp
 		ss.mu.Unlock()
 	}
 	err = t.WriteStatus(ss.s, statusOK)
-	if ss.binlog != nil {
-		ss.binlog.Log(&binarylog.ServerTrailer{
+	if len(ss.binlogs) != 0 {
+		st := &binarylog.ServerTrailer{
 			Trailer: ss.s.Trailer(),
 			Err:     appErr,
-		})
+		}
+		for _, binlog := range ss.binlogs {
+			binlog.Log(st)
+		}
 	}
 	return err
 }
diff --git a/vendor/google.golang.org/grpc/stream.go b/vendor/google.golang.org/grpc/stream.go
index 446a91e32..0c16cfb2e 100644
--- a/vendor/google.golang.org/grpc/stream.go
+++ b/vendor/google.golang.org/grpc/stream.go
@@ -301,7 +301,14 @@ func newClientStreamWithParams(ctx context.Context, desc *StreamDesc, cc *Client
 	if !cc.dopts.disableRetry {
 		cs.retryThrottler = cc.retryThrottler.Load().(*retryThrottler)
 	}
-	cs.binlog = binarylog.GetMethodLogger(method)
+	if ml := binarylog.GetMethodLogger(method); ml != nil {
+		cs.binlogs = append(cs.binlogs, ml)
+	}
+	if cc.dopts.binaryLogger != nil {
+		if ml := cc.dopts.binaryLogger.GetMethodLogger(method); ml != nil {
+			cs.binlogs = append(cs.binlogs, ml)
+		}
+	}
 
 	// Pick the transport to use and create a new stream on the transport.
 	// Assign cs.attempt upon success.
@@ -322,7 +329,7 @@ func newClientStreamWithParams(ctx context.Context, desc *StreamDesc, cc *Client
 		return nil, err
 	}
 
-	if cs.binlog != nil {
+	if len(cs.binlogs) != 0 {
 		md, _ := metadata.FromOutgoingContext(ctx)
 		logEntry := &binarylog.ClientHeader{
 			OnClientSide: true,
@@ -336,7 +343,9 @@ func newClientStreamWithParams(ctx context.Context, desc *StreamDesc, cc *Client
 				logEntry.Timeout = 0
 			}
 		}
-		cs.binlog.Log(logEntry)
+		for _, binlog := range cs.binlogs {
+			binlog.Log(logEntry)
+		}
 	}
 
 	if desc != unaryStreamDesc {
@@ -480,7 +489,7 @@ type clientStream struct {
 
 	retryThrottler *retryThrottler // The throttler active when the RPC began.
 
-	binlog binarylog.MethodLogger // Binary logger, can be nil.
+	binlogs []binarylog.MethodLogger
 	// serverHeaderBinlogged is a boolean for whether server header has been
 	// logged. Server header will be logged when the first time one of those
 	// happens: stream.Header(), stream.Recv().
@@ -744,7 +753,7 @@ func (cs *clientStream) Header() (metadata.MD, error) {
 		cs.finish(err)
 		return nil, err
 	}
-	if cs.binlog != nil && !cs.serverHeaderBinlogged {
+	if len(cs.binlogs) != 0 && !cs.serverHeaderBinlogged {
 		// Only log if binary log is on and header has not been logged.
 		logEntry := &binarylog.ServerHeader{
 			OnClientSide: true,
@@ -754,8 +763,10 @@ func (cs *clientStream) Header() (metadata.MD, error) {
 		if peer, ok := peer.FromContext(cs.Context()); ok {
 			logEntry.PeerAddr = peer.Addr
 		}
-		cs.binlog.Log(logEntry)
 		cs.serverHeaderBinlogged = true
+		for _, binlog := range cs.binlogs {
+			binlog.Log(logEntry)
+		}
 	}
 	return m, nil
 }
@@ -829,38 +840,44 @@ func (cs *clientStream) SendMsg(m interface{}) (err error) {
 		return a.sendMsg(m, hdr, payload, data)
 	}
 	err = cs.withRetry(op, func() { cs.bufferForRetryLocked(len(hdr)+len(payload), op) })
-	if cs.binlog != nil && err == nil {
-		cs.binlog.Log(&binarylog.ClientMessage{
+	if len(cs.binlogs) != 0 && err == nil {
+		cm := &binarylog.ClientMessage{
 			OnClientSide: true,
 			Message:      data,
-		})
+		}
+		for _, binlog := range cs.binlogs {
+			binlog.Log(cm)
+		}
 	}
 	return err
 }
 
 func (cs *clientStream) RecvMsg(m interface{}) error {
-	if cs.binlog != nil && !cs.serverHeaderBinlogged {
+	if len(cs.binlogs) != 0 && !cs.serverHeaderBinlogged {
 		// Call Header() to binary log header if it's not already logged.
 		cs.Header()
 	}
 	var recvInfo *payloadInfo
-	if cs.binlog != nil {
+	if len(cs.binlogs) != 0 {
 		recvInfo = &payloadInfo{}
 	}
 	err := cs.withRetry(func(a *csAttempt) error {
 		return a.recvMsg(m, recvInfo)
 	}, cs.commitAttemptLocked)
-	if cs.binlog != nil && err == nil {
-		cs.binlog.Log(&binarylog.ServerMessage{
+	if len(cs.binlogs) != 0 && err == nil {
+		sm := &binarylog.ServerMessage{
 			OnClientSide: true,
 			Message:      recvInfo.uncompressedBytes,
-		})
+		}
+		for _, binlog := range cs.binlogs {
+			binlog.Log(sm)
+		}
 	}
 	if err != nil || !cs.desc.ServerStreams {
 		// err != nil or non-server-streaming indicates end of stream.
 		cs.finish(err)
 
-		if cs.binlog != nil {
+		if len(cs.binlogs) != 0 {
 			// finish will not log Trailer. Log Trailer here.
 			logEntry := &binarylog.ServerTrailer{
 				OnClientSide: true,
@@ -873,7 +890,9 @@ func (cs *clientStream) RecvMsg(m interface{}) error {
 			if peer, ok := peer.FromContext(cs.Context()); ok {
 				logEntry.PeerAddr = peer.Addr
 			}
-			cs.binlog.Log(logEntry)
+			for _, binlog := range cs.binlogs {
+				binlog.Log(logEntry)
+			}
 		}
 	}
 	return err
@@ -894,10 +913,13 @@ func (cs *clientStream) CloseSend() error {
 		return nil
 	}
 	cs.withRetry(op, func() { cs.bufferForRetryLocked(0, op) })
-	if cs.binlog != nil {
-		cs.binlog.Log(&binarylog.ClientHalfClose{
+	if len(cs.binlogs) != 0 {
+		chc := &binarylog.ClientHalfClose{
 			OnClientSide: true,
-		})
+		}
+		for _, binlog := range cs.binlogs {
+			binlog.Log(chc)
+		}
 	}
 	// We never returned an error here for reasons.
 	return nil
@@ -930,10 +952,13 @@ func (cs *clientStream) finish(err error) {
 	//
 	// Only one of cancel or trailer needs to be logged. In the cases where
 	// users don't call RecvMsg, users must have already canceled the RPC.
-	if cs.binlog != nil && status.Code(err) == codes.Canceled {
-		cs.binlog.Log(&binarylog.Cancel{
+	if len(cs.binlogs) != 0 && status.Code(err) == codes.Canceled {
+		c := &binarylog.Cancel{
 			OnClientSide: true,
-		})
+		}
+		for _, binlog := range cs.binlogs {
+			binlog.Log(c)
+		}
 	}
 	if err == nil {
 		cs.retryThrottler.successfulRPC()
@@ -1005,6 +1030,7 @@ func (a *csAttempt) recvMsg(m interface{}, payInfo *payloadInfo) (err error) {
 			}
 			return io.EOF // indicates successful end of stream.
 		}
+
 		return toRPCErr(err)
 	}
 	if a.trInfo != nil {
@@ -1453,7 +1479,7 @@ type serverStream struct {
 
 	statsHandler []stats.Handler
 
-	binlog binarylog.MethodLogger
+	binlogs []binarylog.MethodLogger
 	// serverHeaderBinlogged indicates whether server header has been logged. It
 	// will happen when one of the following two happens: stream.SendHeader(),
 	// stream.Send().
@@ -1487,12 +1513,15 @@ func (ss *serverStream) SendHeader(md metadata.MD) error {
 	}
 
 	err = ss.t.WriteHeader(ss.s, md)
-	if ss.binlog != nil && !ss.serverHeaderBinlogged {
+	if len(ss.binlogs) != 0 && !ss.serverHeaderBinlogged {
 		h, _ := ss.s.Header()
-		ss.binlog.Log(&binarylog.ServerHeader{
+		sh := &binarylog.ServerHeader{
 			Header: h,
-		})
+		}
 		ss.serverHeaderBinlogged = true
+		for _, binlog := range ss.binlogs {
+			binlog.Log(sh)
+		}
 	}
 	return err
 }
@@ -1549,17 +1578,23 @@ func (ss *serverStream) SendMsg(m interface{}) (err error) {
 	if err := ss.t.Write(ss.s, hdr, payload, &transport.Options{Last: false}); err != nil {
 		return toRPCErr(err)
 	}
-	if ss.binlog != nil {
+	if len(ss.binlogs) != 0 {
 		if !ss.serverHeaderBinlogged {
 			h, _ := ss.s.Header()
-			ss.binlog.Log(&binarylog.ServerHeader{
+			sh := &binarylog.ServerHeader{
 				Header: h,
-			})
+			}
 			ss.serverHeaderBinlogged = true
+			for _, binlog := range ss.binlogs {
+				binlog.Log(sh)
+			}
 		}
-		ss.binlog.Log(&binarylog.ServerMessage{
+		sm := &binarylog.ServerMessage{
 			Message: data,
-		})
+		}
+		for _, binlog := range ss.binlogs {
+			binlog.Log(sm)
+		}
 	}
 	if len(ss.statsHandler) != 0 {
 		for _, sh := range ss.statsHandler {
@@ -1598,13 +1633,16 @@ func (ss *serverStream) RecvMsg(m interface{}) (err error) {
 		}
 	}()
 	var payInfo *payloadInfo
-	if len(ss.statsHandler) != 0 || ss.binlog != nil {
+	if len(ss.statsHandler) != 0 || len(ss.binlogs) != 0 {
 		payInfo = &payloadInfo{}
 	}
 	if err := recv(ss.p, ss.codec, ss.s, ss.dc, m, ss.maxReceiveMessageSize, payInfo, ss.decomp); err != nil {
 		if err == io.EOF {
-			if ss.binlog != nil {
-				ss.binlog.Log(&binarylog.ClientHalfClose{})
+			if len(ss.binlogs) != 0 {
+				chc := &binarylog.ClientHalfClose{}
+				for _, binlog := range ss.binlogs {
+					binlog.Log(chc)
+				}
 			}
 			return err
 		}
@@ -1625,10 +1663,13 @@ func (ss *serverStream) RecvMsg(m interface{}) (err error) {
 			})
 		}
 	}
-	if ss.binlog != nil {
-		ss.binlog.Log(&binarylog.ClientMessage{
+	if len(ss.binlogs) != 0 {
+		cm := &binarylog.ClientMessage{
 			Message: payInfo.uncompressedBytes,
-		})
+		}
+		for _, binlog := range ss.binlogs {
+			binlog.Log(cm)
+		}
 	}
 	return nil
 }
diff --git a/vendor/google.golang.org/grpc/version.go b/vendor/google.golang.org/grpc/version.go
index bfe4fafac..d472ca643 100644
--- a/vendor/google.golang.org/grpc/version.go
+++ b/vendor/google.golang.org/grpc/version.go
@@ -19,4 +19,4 @@
 package grpc
 
 // Version is the current grpc version.
-const Version = "1.50.0"
+const Version = "1.50.1"
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 339014735..80f0b09f3 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -1651,7 +1651,7 @@ google.golang.org/genproto/protobuf/api
 google.golang.org/genproto/protobuf/field_mask
 google.golang.org/genproto/protobuf/ptype
 google.golang.org/genproto/protobuf/source_context
-# google.golang.org/grpc v1.50.0
+# google.golang.org/grpc v1.50.1
 ## explicit; go 1.17
 google.golang.org/grpc
 google.golang.org/grpc/attributes


Test patch:
diff --git a/pkg/apis/operator/v1alpha1/tektonconfig_default_test.go b/pkg/apis/operator/v1alpha1/tektonconfig_default_test.go
index 58f0048a4..4aebfb1da 100644
--- a/pkg/apis/operator/v1alpha1/tektonconfig_default_test.go
+++ b/pkg/apis/operator/v1alpha1/tektonconfig_default_test.go
@@ -18,8 +18,10 @@ package v1alpha1
 
 import (
 	"context"
+	"os"
 	"testing"
 
+	"gotest.tools/v3/assert"
 	"knative.dev/pkg/ptr"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -73,7 +75,6 @@ func Test_SetDefaults_Pipeline_Properties(t *testing.T) {
 }
 
 func Test_SetDefaults_Addon_Params(t *testing.T) {
-
 	tc := &TektonConfig{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "name",
@@ -85,6 +86,8 @@ func Test_SetDefaults_Addon_Params(t *testing.T) {
 			},
 		},
 	}
+	assert.NilError(t, os.Setenv("PLATFORM", "openshift"))
+	defer os.Clearenv()
 
 	tc.SetDefaults(context.TODO())
 	if len(tc.Spec.Addon.Params) != 3 {
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/check_test.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/check_test.go
index 1ea895465..c51c7f20d 100644
--- a/pkg/reconciler/kubernetes/tektoninstallerset/client/check_test.go
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/check_test.go
@@ -249,10 +249,10 @@ func TestInstallerSetClient_Check(t *testing.T) {
 			fakeclient := fake.NewSimpleClientset(tt.resources)
 			tisClient := fakeclient.OperatorV1alpha1().TektonInstallerSets()
 
-			client := NewInstallerSetClient(tisClient, nil, releaseVersion, "test-version", v1alpha1.KindTektonTrigger,
-				filterAndTransform(common.NoExtension(ctx)), &testMetrics{})
+			client := NewInstallerSetClient(tisClient, releaseVersion, "test-version", v1alpha1.KindTektonTrigger,
+				&testMetrics{})
 
-			_, gotErr := client.CheckSet(ctx, comp, tt.setType)
+			_, gotErr := client.checkSet(ctx, comp, tt.setType)
 
 			if tt.wantErr != nil {
 				assert.Equal(t, gotErr, tt.wantErr)
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/cleanup_test.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/cleanup_test.go
index 266c8510d..4196c1b24 100644
--- a/pkg/reconciler/kubernetes/tektoninstallerset/client/cleanup_test.go
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/cleanup_test.go
@@ -22,7 +22,6 @@ import (
 
 	"github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
 	"github.com/tektoncd/operator/pkg/client/clientset/versioned/fake"
-	"github.com/tektoncd/operator/pkg/reconciler/common"
 	"gotest.tools/v3/assert"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -141,8 +140,7 @@ func TestInstallerSetClient_Cleanup(t *testing.T) {
 			fakeClient := fake.NewSimpleClientset(runObj...)
 			tisClient := fakeClient.OperatorV1alpha1().TektonInstallerSets()
 
-			client := NewInstallerSetClient(tisClient, nil, releaseVersion, "test-version", v1alpha1.KindTektonTrigger,
-				filterAndTransform(common.NoExtension(ctx)), &testMetrics{})
+			client := NewInstallerSetClient(tisClient, releaseVersion, "test-version", v1alpha1.KindTektonTrigger, &testMetrics{})
 
 			var gotErr error
 			switch tt.setType {
@@ -153,7 +151,7 @@ func TestInstallerSetClient_Cleanup(t *testing.T) {
 			case InstallerTypePost:
 				gotErr = client.CleanupPostSet(ctx)
 			default:
-				gotErr = client.CleanupAll(ctx)
+				t.Fatal("invaid set type")
 			}
 			assert.NilError(t, gotErr)
 
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/create_test.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/create_test.go
index 59a1c9136..5ebea064f 100644
--- a/pkg/reconciler/kubernetes/tektoninstallerset/client/create_test.go
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/create_test.go
@@ -99,8 +99,7 @@ func TestInstallerSetClient_Create(t *testing.T) {
 				t.Fatalf("Failed to generate manifest: %v", err)
 			}
 
-			client := NewInstallerSetClient(tisClient, &manifest, releaseVersion, "test-version", v1alpha1.KindTektonTrigger,
-				filterAndTransform(common.NoExtension(ctx)), &testMetrics{})
+			client := NewInstallerSetClient(tisClient, releaseVersion, "test-version", v1alpha1.KindTektonTrigger, &testMetrics{})
 
 			// fake.NewSimpleClientset() doesn't consider generate name when creating a resources
 			// so we write a fake client to test
@@ -109,11 +108,10 @@ func TestInstallerSetClient_Create(t *testing.T) {
 
 			if tt.setType == InstallerTypeMain {
 				fakeClient := fake2.NewFakeISClient()
-				client = NewInstallerSetClient(fakeClient, &manifest, releaseVersion, "test-version", v1alpha1.KindTektonTrigger,
-					filterAndTransform(common.NoExtension(ctx)), &testMetrics{})
+				client = NewInstallerSetClient(fakeClient, releaseVersion, "test-version", v1alpha1.KindTektonTrigger, &testMetrics{})
 			}
 
-			iSs, gotErr := client.Create(ctx, comp, &manifest, tt.setType)
+			iSs, gotErr := client.create(ctx, comp, &manifest, filterAndTransform(common.NoExtension(ctx)), tt.setType)
 
 			if tt.wantErr != nil {
 				assert.Equal(t, gotErr, tt.wantErr)
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/labels_test.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/labels_test.go
new file mode 100644
index 000000000..fcea41e9b
--- /dev/null
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/labels_test.go
@@ -0,0 +1,30 @@
+package client
+
+import (
+	"testing"
+
+	"github.com/tektoncd/operator/pkg/apis/operator/v1alpha1"
+	"gotest.tools/v3/assert"
+)
+
+/*
+Copyright 2022 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.
+*/
+
+func TestGetSetLabels(t *testing.T) {
+	client := NewInstallerSetClient(nil, "relVersion", "compVesion", v1alpha1.KindTektonPipeline, nil)
+	labelSelector := client.getSetLabels(InstallerTypeMain)
+	assert.Equal(t, labelSelector, "operator.tekton.dev/created-by=TektonPipeline,operator.tekton.dev/type=main")
+}
diff --git a/pkg/reconciler/kubernetes/tektoninstallerset/client/update_test.go b/pkg/reconciler/kubernetes/tektoninstallerset/client/update_test.go
index 5967e24e7..a6ce02dd6 100644
--- a/pkg/reconciler/kubernetes/tektoninstallerset/client/update_test.go
+++ b/pkg/reconciler/kubernetes/tektoninstallerset/client/update_test.go
@@ -160,10 +160,9 @@ func TestInstallerSetClient_Update(t *testing.T) {
 			fakeclient := fake.NewSimpleClientset(runObj...)
 			tisClient := fakeclient.OperatorV1alpha1().TektonInstallerSets()
 
-			client := NewInstallerSetClient(tisClient, &manifest, releaseVersion, "test-version", v1alpha1.KindTektonTrigger,
-				updateFilterAndTransform(common.NoExtension(ctx), updatedNs), &testMetrics{})
+			client := NewInstallerSetClient(tisClient, releaseVersion, "test-version", v1alpha1.KindTektonTrigger, &testMetrics{})
 
-			updatedISs, gotErr := client.Update(ctx, comp, tt.existingIS, &manifest, tt.setType)
+			updatedISs, gotErr := client.update(ctx, comp, tt.existingIS, &manifest, updateFilterAndTransform(common.NoExtension(ctx), updatedNs), tt.setType)
 			if tt.wantErr != nil {
 				assert.Equal(t, gotErr, tt.wantErr)
 				return