Update kubernetes libs to latest (#2834)

- k8s.io/api v0.28.1
- k8s.io/apiextensions-apiserver v0.28.1
- k8s.io/apimachinery v0.28.1
- k8s.io/client-go v0.28.1
- k8s.io/metrics v0.28.1
- sigs.k8s.io/controller-runtime v0.16.1
- sigs.k8s.io/controller-tools v0.13.0

Signed-off-by: Sanket Sudake <sanketsudake@gmail.com>

pkg/apis/core/v1/canaryconfig_webhook .go

@@ -21,6 +21,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	"github.com/fission/fission/pkg/utils/loggerfactory"
 )
@@ -50,19 +51,19 @@ func (r *CanaryConfig) Default() {
 var _ webhook.Validator = &CanaryConfig{}
 
 // ValidateCreate implements webhook.Validator so a webhook will be registered for the type
-func (r *CanaryConfig) ValidateCreate() error {
+func (r *CanaryConfig) ValidateCreate() (admission.Warnings, error) {
 	canaryconfiglog.Debug("validate create", zap.String("name", r.Name))
-	return nil
+	return nil, nil
 }
 
 // ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
-func (r *CanaryConfig) ValidateUpdate(old runtime.Object) error {
+func (r *CanaryConfig) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
 	canaryconfiglog.Debug("validate update", zap.String("name", r.Name))
-	return nil
+	return nil, nil
 }
 
 // ValidateDelete implements webhook.Validator so a webhook will be registered for the type
-func (r *CanaryConfig) ValidateDelete() error {
+func (r *CanaryConfig) ValidateDelete() (admission.Warnings, error) {
 	canaryconfiglog.Debug("validate delete", zap.String("name", r.Name))
-	return nil
+	return nil, nil
 }

pkg/apis/core/v1/environment_webhook.go

@@ -21,6 +21,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	"github.com/fission/fission/pkg/utils/loggerfactory"
 )
@@ -49,24 +50,24 @@ func (r *Environment) Default() {
 var _ webhook.Validator = &Environment{}
 
 // ValidateCreate implements webhook.Validator so a webhook will be registered for the type
-func (r *Environment) ValidateCreate() error {
+func (r *Environment) ValidateCreate() (admission.Warnings, error) {
 	environmentlog.Debug("validate create", zap.String("name", r.Name))
 	err := r.Validate()
 	if err != nil {
 		err = AggregateValidationErrors("Environment", err)
-		return err
+		return nil, err
 	}
-	return nil
+	return nil, nil
 }
 
 // ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
-func (r *Environment) ValidateUpdate(old runtime.Object) error {
+func (r *Environment) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
 	environmentlog.Debug("validate update", zap.String("name", r.Name))
-	return nil
+	return nil, nil
 }
 
 // ValidateDelete implements webhook.Validator so a webhook will be registered for the type
-func (r *Environment) ValidateDelete() error {
+func (r *Environment) ValidateDelete() (admission.Warnings, error) {
 	environmentlog.Debug("validate delete", zap.String("name", r.Name))
-	return nil
+	return nil, nil
 }

pkg/apis/core/v1/function_webhook.go

@@ -23,6 +23,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	"github.com/fission/fission/pkg/utils/loggerfactory"
 )
@@ -50,55 +51,55 @@ func (r *Function) Default() {
 var _ webhook.Validator = &Function{}
 
 // ValidateCreate implements webhook.Validator so a webhook will be registered for the type
-func (r *Function) ValidateCreate() error {
+func (r *Function) ValidateCreate() (admission.Warnings, error) {
 	functionlog.Debug("validate create", zap.String("name", r.Name))
 
 	for _, cnfMap := range r.Spec.ConfigMaps {
 		if cnfMap.Namespace != r.ObjectMeta.Namespace {
 			err := fmt.Errorf("ConfigMap's [%s] and function's Namespace [%s] are different. ConfigMap needs to be present in the same namespace as function", cnfMap.Namespace, r.ObjectMeta.Namespace)
-			return AggregateValidationErrors("Function", err)
+			return nil, AggregateValidationErrors("Function", err)
 		}
 	}
 	for _, secret := range r.Spec.Secrets {
 		if secret.Namespace != r.ObjectMeta.Namespace {
 			err := fmt.Errorf("secret  [%s] and function's Namespace [%s] are different. Secret needs to be present in the same namespace as function", secret.Namespace, r.ObjectMeta.Namespace)
-			return AggregateValidationErrors("Function", err)
+			return nil, AggregateValidationErrors("Function", err)
 		}
 	}
 
 	err := r.Validate()
 	if err != nil {
-		return AggregateValidationErrors("Function", err)
+		return nil, AggregateValidationErrors("Function", err)
 	}
-	return nil
+	return nil, nil
 }
 
 // ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
-func (r *Function) ValidateUpdate(old runtime.Object) error {
+func (r *Function) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
 	functionlog.Debug("validate update", zap.String("name", r.Name))
 
 	for _, cnfMap := range r.Spec.ConfigMaps {
 		if cnfMap.Namespace != r.ObjectMeta.Namespace {
 			err := fmt.Errorf("ConfigMap's [%s] and function's Namespace [%s] are different. ConfigMap needs to be present in the same namespace as function", cnfMap.Namespace, r.ObjectMeta.Namespace)
-			return AggregateValidationErrors("Function", err)
+			return nil, AggregateValidationErrors("Function", err)
 		}
 	}
 	for _, secret := range r.Spec.Secrets {
 		if secret.Namespace != r.ObjectMeta.Namespace {
 			err := fmt.Errorf("secret  [%s] and function's Namespace [%s] are different. Secret needs to be present in the same namespace as function", secret.Namespace, r.ObjectMeta.Namespace)
-			return AggregateValidationErrors("Function", err)
+			return nil, AggregateValidationErrors("Function", err)
 		}
 	}
 
 	err := r.Validate()
 	if err != nil {
-		return AggregateValidationErrors("Function", err)
+		return nil, AggregateValidationErrors("Function", err)
 	}
-	return nil
+	return nil, nil
 }
 
 // ValidateDelete implements webhook.Validator so a webhook will be registered for the type
-func (r *Function) ValidateDelete() error {
+func (r *Function) ValidateDelete() (admission.Warnings, error) {
 	functionlog.Debug("validate delete", zap.String("name", r.Name))
-	return nil
+	return nil, nil
 }

pkg/apis/core/v1/httptrigger_webhook.go

@@ -21,6 +21,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	"github.com/fission/fission/pkg/utils/loggerfactory"
 )
@@ -49,31 +50,31 @@ func (r *HTTPTrigger) Default() {
 var _ webhook.Validator = &HTTPTrigger{}
 
 // ValidateCreate implements webhook.Validator so a webhook will be registered for the type
-func (t *HTTPTrigger) ValidateCreate() error {
+func (t *HTTPTrigger) ValidateCreate() (admission.Warnings, error) {
 	httptriggerlog.Debug("validate create", zap.String("name", t.Name))
 	err := t.Validate()
 	if err != nil {
 		err = AggregateValidationErrors("HTTPTrigger", err)
-		return err
+		return nil, err
 	}
-	return nil
+	return nil, nil
 }
 
 // ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
-func (r *HTTPTrigger) ValidateUpdate(old runtime.Object) error {
+func (r *HTTPTrigger) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
 	httptriggerlog.Debug("validate update", zap.String("name", r.Name))
 	err := r.Validate()
 	if err != nil {
 		err = AggregateValidationErrors("HTTPTrigger", err)
-		return err
+		return nil, err
 	}
 
-	return nil
+	return nil, nil
 }
 
 // ValidateDelete implements webhook.Validator so a webhook will be registered for the type
-func (r *HTTPTrigger) ValidateDelete() error {
+func (r *HTTPTrigger) ValidateDelete() (admission.Warnings, error) {
 	httptriggerlog.Debug("validate delete", zap.String("name", r.Name))
 
-	return nil
+	return nil, nil
 }

pkg/apis/core/v1/kuberneteswatchtrigger_webhook.go

@@ -21,6 +21,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	"github.com/fission/fission/pkg/utils/loggerfactory"
 )
@@ -49,24 +50,24 @@ func (r *KubernetesWatchTrigger) Default() {
 var _ webhook.Validator = &KubernetesWatchTrigger{}
 
 // ValidateCreate implements webhook.Validator so a webhook will be registered for the type
-func (r *KubernetesWatchTrigger) ValidateCreate() error {
+func (r *KubernetesWatchTrigger) ValidateCreate() (admission.Warnings, error) {
 	kuberneteswatchtriggerlog.Debug("validate create", zap.String("name", r.Name))
 	err := r.Validate()
 	if err != nil {
 		err = AggregateValidationErrors("Watch", err)
-		return err
+		return nil, err
 	}
-	return nil
+	return nil, nil
 }
 
 // ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
-func (r *KubernetesWatchTrigger) ValidateUpdate(old runtime.Object) error {
+func (r *KubernetesWatchTrigger) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
 	// WATCH UPDATE NOT IMPLEMENTED
-	return nil
+	return nil, nil
 }
 
 // ValidateDelete implements webhook.Validator so a webhook will be registered for the type
-func (r *KubernetesWatchTrigger) ValidateDelete() error {
+func (r *KubernetesWatchTrigger) ValidateDelete() (admission.Warnings, error) {
 	kuberneteswatchtriggerlog.Debug("validate delete", zap.String("name", r.Name))
-	return nil
+	return nil, nil
 }

pkg/apis/core/v1/messagequeuetrigger_webhook.go

@@ -21,6 +21,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	"github.com/fission/fission/pkg/utils/loggerfactory"
 )
@@ -49,29 +50,29 @@ func (r *MessageQueueTrigger) Default() {
 var _ webhook.Validator = &MessageQueueTrigger{}
 
 // ValidateCreate implements webhook.Validator so a webhook will be registered for the type
-func (r *MessageQueueTrigger) ValidateCreate() error {
+func (r *MessageQueueTrigger) ValidateCreate() (admission.Warnings, error) {
 	messagequeuetriggerlog.Debug("validate create", zap.String("name", r.Name))
 	err := r.Validate()
 	if err != nil {
 		err = AggregateValidationErrors("MessageQueueTrigger", err)
-		return err
+		return nil, err
 	}
-	return nil
+	return nil, nil
 }
 
 // ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
-func (r *MessageQueueTrigger) ValidateUpdate(old runtime.Object) error {
+func (r *MessageQueueTrigger) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
 	messagequeuetriggerlog.Debug("validate update", zap.String("name", r.Name))
 	err := r.Validate()
 	if err != nil {
 		err = AggregateValidationErrors("MessageQueueTrigger", err)
-		return err
+		return nil, err
 	}
-	return nil
+	return nil, nil
 }
 
 // ValidateDelete implements webhook.Validator so a webhook will be registered for the type
-func (r *MessageQueueTrigger) ValidateDelete() error {
+func (r *MessageQueueTrigger) ValidateDelete() (admission.Warnings, error) {
 	messagequeuetriggerlog.Debug("validate delete", zap.String("name", r.Name))
-	return nil
+	return nil, nil
 }

pkg/apis/core/v1/package_webhook.go

@@ -24,6 +24,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	ferror "github.com/fission/fission/pkg/error"
 	"github.com/fission/fission/pkg/utils/loggerfactory"
@@ -56,43 +57,43 @@ func (r *Package) Default() {
 var _ webhook.Validator = &Package{}
 
 // ValidateCreate implements webhook.Validator so a webhook will be registered for the type
-func (r *Package) ValidateCreate() error {
+func (r *Package) ValidateCreate() (admission.Warnings, error) {
 	packagelog.Debug("validate create", zap.String("name", r.Name))
 	err := r.Validate()
 	if err != nil {
 		err = AggregateValidationErrors("Package", err)
-		return err
+		return nil, err
 	}
 
 	// Ensure size limits
 	if len(r.Spec.Source.Literal) > int(ArchiveLiteralSizeLimit) {
 		err := ferror.MakeError(ferror.ErrorInvalidArgument,
 			fmt.Sprintf("Package literal larger than %s", humanize.Bytes(uint64(ArchiveLiteralSizeLimit))))
-		return err
+		return nil, err
 	}
 	if len(r.Spec.Deployment.Literal) > int(ArchiveLiteralSizeLimit) {
 		err := ferror.MakeError(ferror.ErrorInvalidArgument,
 			fmt.Sprintf("Package literal larger than %s", humanize.Bytes(uint64(ArchiveLiteralSizeLimit))))
-		return err
+		return nil, err
 	}
-	return nil
+	return nil, nil
 }
 
 // ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
-func (r *Package) ValidateUpdate(old runtime.Object) error {
+func (r *Package) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
 	packagelog.Debug("validate update", zap.String("name", r.Name))
 	err := r.Validate()
 
 	if err != nil {
 		err = AggregateValidationErrors("Package", err)
-		return err
+		return nil, err
 	}
 
-	return nil
+	return nil, nil
 }
 
 // ValidateDelete implements webhook.Validator so a webhook will be registered for the type
-func (r *Package) ValidateDelete() error {
+func (r *Package) ValidateDelete() (admission.Warnings, error) {
 	packagelog.Debug("validate delete", zap.String("name", r.Name))
-	return nil
+	return nil, nil
 }

pkg/apis/core/v1/timetrigger_webhook.go

@@ -21,6 +21,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 
 	ferror "github.com/fission/fission/pkg/error"
 	"github.com/fission/fission/pkg/utils/loggerfactory"
@@ -50,42 +51,42 @@ func (r *TimeTrigger) Default() {
 var _ webhook.Validator = &TimeTrigger{}
 
 // ValidateCreate implements webhook.Validator so a webhook will be registered for the type
-func (r *TimeTrigger) ValidateCreate() error {
+func (r *TimeTrigger) ValidateCreate() (admission.Warnings, error) {
 	timetriggerlog.Debug("validate create", zap.String("name", r.Name))
 	err := r.Validate()
 	if err != nil {
 		err = AggregateValidationErrors("TimeTrigger", err)
-		return err
+		return nil, err
 	}
 
 	err = IsValidCronSpec(r.Spec.Cron)
 	if err != nil {
 		err = ferror.MakeError(ferror.ErrorInvalidArgument, "TimeTrigger cron spec is not valid")
-		return err
+		return nil, err
 	}
-	return nil
+	return nil, nil
 }
 
 // ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
-func (r *TimeTrigger) ValidateUpdate(old runtime.Object) error {
+func (r *TimeTrigger) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
 	timetriggerlog.Debug("validate update", zap.String("name", r.Name))
 	err := r.Validate()
 	if err != nil {
 		err = AggregateValidationErrors("TimeTrigger", err)
-		return err
+		return nil, err
 	}
 
 	err = IsValidCronSpec(r.Spec.Cron)
 	if err != nil {
 		err = ferror.MakeError(ferror.ErrorInvalidArgument, "TimeTrigger cron spec is not valid")
-		return err
+		return nil, err
 	}
 
-	return nil
+	return nil, nil
 }
 
 // ValidateDelete implements webhook.Validator so a webhook will be registered for the type
-func (r *TimeTrigger) ValidateDelete() error {
+func (r *TimeTrigger) ValidateDelete() (admission.Warnings, error) {
 	timetriggerlog.Debug("validate delete", zap.String("name", r.Name))
-	return nil
+	return nil, nil
 }

pkg/apis/core/v1/zz_generated.deepcopy.go

@@ -1,5 +1,4 @@
 //go:build !ignore_autogenerated
-// +build !ignore_autogenerated
 
 /*
 Copyright The Fission Authors.

pkg/buildermgr/buildermgr.go

@@ -59,13 +59,19 @@ func Start(ctx context.Context, logger *zap.Logger, storageSvcUrl string) error
 		logger.Warn("error reading data for pod spec patch", zap.String("path", fv1.BuilderPodSpecPath), zap.Error(err))
 	}
 
-	envWatcher := makeEnvironmentWatcher(ctx, bmLogger, fissionClient, kubernetesClient, fetcherConfig, podSpecPatch)
+	envWatcher, err := makeEnvironmentWatcher(ctx, bmLogger, fissionClient, kubernetesClient, fetcherConfig, podSpecPatch)
 	envWatcher.Run(ctx)
+	if err != nil {
+		return err
+	}
 
 	pkgWatcher := makePackageWatcher(bmLogger, fissionClient,
 		kubernetesClient, storageSvcUrl,
 		utils.GetK8sInformersForNamespaces(kubernetesClient, time.Minute*30, fv1.Pods),
 		utils.GetInformersForNamespaces(fissionClient, time.Minute*30, fv1.PackagesResource))
-	pkgWatcher.Run(ctx)
+	err = pkgWatcher.Run(ctx)
+	if err != nil {
+		return err
+	}
 	return nil
 }

pkg/buildermgr/envwatcher.go

@@ -23,7 +23,6 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	appsv1 "k8s.io/api/apps/v1"
 	apiv1 "k8s.io/api/core/v1"
@@ -81,7 +80,7 @@ func makeEnvironmentWatcher(
 	fissionClient versioned.Interface,
 	kubernetesClient kubernetes.Interface,
 	fetcherConfig *fetcherConfig.Config,
-	podSpecPatch *apiv1.PodSpec) *environmentWatcher {
+	podSpecPatch *apiv1.PodSpec) (*environmentWatcher, error) {
 
 	useIstio := false
 	enableIstio := os.Getenv("ENABLE_ISTIO")
@@ -108,8 +107,11 @@ func makeEnvironmentWatcher(
 		envWatchInformer:       utils.GetInformersForNamespaces(fissionClient, time.Minute*30, fv1.EnvironmentResource),
 	}
 
-	envWatcher.EnvWatchEventHandlers(ctx)
-	return envWatcher
+	err := envWatcher.EnvWatchEventHandlers(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return envWatcher, nil
 }
 
 func (env *environmentWatcher) getDeploymentLabels(envName string) map[string]string {
@@ -134,9 +136,9 @@ func (envw *environmentWatcher) Run(ctx context.Context) {
 	}
 }
 
-func (envw *environmentWatcher) EnvWatchEventHandlers(ctx context.Context) {
+func (envw *environmentWatcher) EnvWatchEventHandlers(ctx context.Context) error {
 	for _, informer := range envw.envWatchInformer {
-		informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
+		_, err := informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
 				envObj := obj.(*fv1.Environment)
 				envw.AddUpdateBuilder(ctx, envObj)
@@ -153,7 +155,11 @@ func (envw *environmentWatcher) EnvWatchEventHandlers(ctx context.Context) {
 				envw.DeleteBuilder(ctx, envObj)
 			},
 		})
+		if err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
 func (envw *environmentWatcher) AddUpdateBuilder(ctx context.Context, env *fv1.Environment) {
@@ -252,9 +258,7 @@ func (envw *environmentWatcher) createBuilder(ctx context.Context, env *fv1.Envi
 	if len(svcList) == 0 {
 		svc, err = envw.createBuilderService(ctx, env, ns)
 		if err != nil {
-			return nil, errors.Wrap(err,
-				fmt.Sprintf("error creating builder service for environment in namespace %s %s", env.ObjectMeta.Name, ns))
-
+			return nil, fmt.Errorf("error creating builder service for environment in namespace %s %s: %w", env.ObjectMeta.Name, ns, err)
 		}
 	} else if len(svcList) == 1 {
 		svc = &svcList[0]
@@ -270,8 +274,7 @@ func (envw *environmentWatcher) createBuilder(ctx context.Context, env *fv1.Envi
 	if len(deployList) == 0 {
 		deploy, err = envw.createBuilderDeployment(ctx, env, ns)
 		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("error creating builder deployment for environment in namespace %s %s", env.ObjectMeta.Name, ns))
-
+			return nil, fmt.Errorf("error creating builder deployment for environment in namespace %s %s: %w", env.ObjectMeta.Name, ns, err)
 		}
 	} else if len(deployList) == 1 {
 		deploy = &deployList[0]
@@ -291,7 +294,7 @@ func (envw *environmentWatcher) deleteBuilderServiceByName(ctx context.Context,
 		Services(namespace).
 		Delete(ctx, name, delOpt)
 	if err != nil {
-		return errors.Wrapf(err, "error deleting builder service %s.%s", name, namespace)
+		return fmt.Errorf("error deleting builder service %s.%s: %w", name, namespace, err)
 	}
 	return nil
 }
@@ -301,7 +304,7 @@ func (envw *environmentWatcher) deleteBuilderDeploymentByName(ctx context.Contex
 		Deployments(namespace).
 		Delete(ctx, name, delOpt)
 	if err != nil {
-		return errors.Wrapf(err, "error deleting builder deployment %s.%s", name, namespace)
+		return fmt.Errorf("error deleting builder deployment %s.%s: %w", name, namespace, err)
 	}
 	return nil
 }
@@ -313,7 +316,7 @@ func (envw *environmentWatcher) getBuilderServiceList(ctx context.Context, sel m
 			LabelSelector: labels.Set(sel).AsSelector().String(),
 		})
 	if err != nil {
-		return nil, errors.Wrap(err, "error getting builder service list")
+		return nil, fmt.Errorf("error getting builder service list for namespace %s: %w", ns, err)
 	}
 	return svcList.Items, nil
 }
@@ -367,7 +370,7 @@ func (envw *environmentWatcher) getBuilderDeploymentList(ctx context.Context, se
 			LabelSelector: labels.Set(sel).AsSelector().String(),
 		})
 	if err != nil {
-		return nil, errors.Wrap(err, "error getting builder deployment list")
+		return nil, fmt.Errorf("error getting builder deployment list for namespace %s: %w", ns, err)
 	}
 	return deployList.Items, nil
 }

pkg/buildermgr/pkgwatcher.go

@@ -308,15 +308,20 @@ func (pkgw *packageWatcher) packageInformerHandler(ctx context.Context) k8sCache
 	}
 }
 
-func (pkgw *packageWatcher) Run(ctx context.Context) {
+func (pkgw *packageWatcher) Run(ctx context.Context) error {
 	go metrics.ServeMetrics(ctx, pkgw.logger)
 	for _, podInformer := range pkgw.podInformer {
 		go podInformer.Run(ctx.Done())
 	}
 	for _, pkgInformer := range pkgw.pkgInformer {
-		pkgInformer.AddEventHandler(pkgw.packageInformerHandler(ctx))
+		_, err := pkgInformer.AddEventHandler(pkgw.packageInformerHandler(ctx))
+		if err != nil {
+			pkgw.logger.Fatal("error adding package informer handler", zap.Error(err))
+			return err
+		}
 		go pkgInformer.Run(ctx.Done())
 	}
+	return nil
 }
 
 // setInitialBuildStatus sets initial build status to a package if it is empty.

pkg/canaryconfigmgr/canaryConfigMgr.go

@@ -18,13 +18,13 @@ package canaryconfigmgr
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net/url"
 	"os"
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -78,7 +78,7 @@ func MakeCanaryConfigMgr(ctx context.Context, logger *zap.Logger, fissionClient
 
 	_, err := url.Parse(prometheusSvc)
 	if err != nil {
-		return nil, errors.Errorf("prometheus service url not found/invalid, can't create canary config manager: %v", prometheusSvc)
+		return nil, fmt.Errorf("prometheus service url not found/invalid, can't create canary config manager: %s", prometheusSvc)
 	}
 
 	promClient, err := MakePrometheusClient(logger, prometheusSvc)
@@ -94,13 +94,16 @@ func MakeCanaryConfigMgr(ctx context.Context, logger *zap.Logger, fissionClient
 		canaryCfgCancelFuncMap: makecanaryConfigCancelFuncMap(),
 	}
 	configMgr.canaryConfigInformer = utils.GetInformersForNamespaces(fissionClient, time.Minute*30, fv1.CanaryConfigResource)
-	configMgr.CanaryConfigEventHandlers(ctx)
+	err = configMgr.CanaryConfigEventHandlers(ctx)
+	if err != nil {
+		return nil, err
+	}
 	return configMgr, nil
 }
 
-func (canaryCfgMgr *canaryConfigMgr) CanaryConfigEventHandlers(ctx context.Context) {
+func (canaryCfgMgr *canaryConfigMgr) CanaryConfigEventHandlers(ctx context.Context) error {
 	for _, informer := range canaryCfgMgr.canaryConfigInformer {
-		informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
+		_, err := informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
 				canaryConfig := obj.(*fv1.CanaryConfig)
 				if canaryConfig.Status.Status == fv1.CanaryConfigStatusPending {
@@ -126,7 +129,11 @@ func (canaryCfgMgr *canaryConfigMgr) CanaryConfigEventHandlers(ctx context.Conte
 
 			},
 		})
+		if err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
 func (canaryCfgMgr *canaryConfigMgr) Run(ctx context.Context) {
@@ -374,9 +381,8 @@ func (canaryCfgMgr *canaryConfigMgr) updateHttpTriggerWithRetries(ctx context.Co
 	for i := 0; i < maxRetries; i++ {
 		triggerObj, err := canaryCfgMgr.fissionClient.CoreV1().HTTPTriggers(triggerNamespace).Get(ctx, triggerName, metav1.GetOptions{})
 		if err != nil {
-			e := "error getting http trigger object"
-			canaryCfgMgr.logger.Error(e, zap.Error(err), zap.String("trigger_name", triggerName), zap.String("trigger_namespace", triggerNamespace))
-			return errors.Wrap(err, e)
+			canaryCfgMgr.logger.Error("error getting http trigger object", zap.Error(err), zap.String("trigger_name", triggerName), zap.String("trigger_namespace", triggerNamespace))
+			return fmt.Errorf("error getting http trigger object: %w", err)
 		}
 
 		triggerObj.Spec.FunctionReference.FunctionWeights = fnWeights
@@ -394,11 +400,11 @@ func (canaryCfgMgr *canaryConfigMgr) updateHttpTriggerWithRetries(ctx context.Co
 			continue
 		default:
 			e := "error updating http trigger"
-			canaryCfgMgr.logger.Error(e,
+			canaryCfgMgr.logger.Error("error updating http trigger",
 				zap.Error(err),
 				zap.String("trigger_name", triggerName),
 				zap.String("trigger_namespace", triggerNamespace))
-			return errors.Wrapf(err, "%s: %s.%s", e, triggerName, triggerNamespace)
+			return fmt.Errorf("%s: %s.%s %w", e, triggerName, triggerNamespace, err)
 		}
 	}
 
@@ -415,7 +421,7 @@ func (canaryCfgMgr *canaryConfigMgr) updateCanaryConfigStatusWithRetries(ctx con
 				zap.String("name", cfgName),
 				zap.String("namespace", cfgNamespace),
 				zap.String("status", status))
-			return errors.Wrap(err, e)
+			return fmt.Errorf("%s: %s.%s %w", e, cfgName, cfgNamespace, err)
 		}
 
 		canaryCfgMgr.logger.Info("updating status of canary config",
@@ -444,7 +450,7 @@ func (canaryCfgMgr *canaryConfigMgr) updateCanaryConfigStatusWithRetries(ctx con
 				zap.Error(err),
 				zap.String("name", cfgName),
 				zap.String("namespace", cfgNamespace))
-			return errors.Wrapf(err, "%s: %s.%s", e, cfgName, cfgNamespace)
+			return fmt.Errorf("%s: %s.%s %w", e, cfgName, cfgNamespace, err)
 		}
 	}
 
@@ -558,11 +564,11 @@ func StartCanaryServer(ctx context.Context, logger *zap.Logger, unitTestFlag boo
 	clientGen := crd.NewClientGenerator()
 	fissionClient, err := clientGen.GetFissionClient()
 	if err != nil {
-		return errors.Wrap(err, "failed to get fission client")
+		return fmt.Errorf("failed to get fission client: %w", err)
 	}
 	kubernetesClient, err := clientGen.GetKubernetesClient()
 	if err != nil {
-		return errors.Wrap(err, "failed to get kubernetes client")
+		return fmt.Errorf("failed to get kubernetes client: %w", err)
 	}
 
 	err = ConfigureFeatures(ctx, cLogger, unitTestFlag, fissionClient, kubernetesClient)

pkg/executor/cms/cmscontroller.go

@@ -42,20 +42,26 @@ type (
 func MakeConfigSecretController(ctx context.Context, logger *zap.Logger, fissionClient versioned.Interface,
 	kubernetesClient kubernetes.Interface, types map[fv1.ExecutorType]executortype.ExecutorType,
 	configmapInformer,
-	secretInformer map[string]cache.SharedIndexInformer) *ConfigSecretController {
+	secretInformer map[string]cache.SharedIndexInformer) (*ConfigSecretController, error) {
 	logger.Debug("Creating ConfigMap & Secret Controller")
 	cmsController := &ConfigSecretController{
 		logger:        logger,
 		fissionClient: fissionClient,
 	}
 	for _, informer := range configmapInformer {
-		informer.AddEventHandler(ConfigMapEventHandlers(ctx, logger, fissionClient, kubernetesClient, types))
+		_, err := informer.AddEventHandler(ConfigMapEventHandlers(ctx, logger, fissionClient, kubernetesClient, types))
+		if err != nil {
+			return nil, err
+		}
 	}
 	for _, informer := range secretInformer {
-		informer.AddEventHandler(SecretEventHandlers(ctx, logger, fissionClient, kubernetesClient, types))
+		_, err := informer.AddEventHandler(SecretEventHandlers(ctx, logger, fissionClient, kubernetesClient, types))
+		if err != nil {
+			return nil, err
+		}
 	}
 
-	return cmsController
+	return cmsController, nil
 }
 
 func refreshPods(ctx context.Context, logger *zap.Logger, funcs []fv1.Function, types map[fv1.ExecutorType]executortype.ExecutorType) {

pkg/executor/executor.go

@@ -356,7 +356,10 @@ func StartExecutor(ctx context.Context, logger *zap.Logger, port int) error {
 
 	configMapInformer := utils.GetK8sInformersForNamespaces(kubernetesClient, time.Minute*30, fv1.ConfigMaps)
 	secretInformer := utils.GetK8sInformersForNamespaces(kubernetesClient, time.Minute*30, fv1.Secrets)
-	cms := cms.MakeConfigSecretController(ctx, logger, fissionClient, kubernetesClient, executorTypes, configMapInformer, secretInformer)
+	cms, err := cms.MakeConfigSecretController(ctx, logger, fissionClient, kubernetesClient, executorTypes, configMapInformer, secretInformer)
+	if err != nil {
+		return fmt.Errorf("error creating configmap and secret controller: %w", err)
+	}
 
 	fissionInformers := make([]k8sCache.SharedIndexInformer, 0)
 	for _, informer := range configMapInformer {

pkg/executor/executortype/container/containermgr.go

@@ -140,7 +140,10 @@ func MakeContainer(
 		caaf.svcListerSynced[ns] = informerFactory.Core().V1().Services().Informer().HasSynced
 	}
 	for _, factory := range finformerFactory {
-		factory.Core().V1().Functions().Informer().AddEventHandler(caaf.FuncInformerHandler(ctx))
+		_, err := factory.Core().V1().Functions().Informer().AddEventHandler(caaf.FuncInformerHandler(ctx))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to add event handler for function informer")
+		}
 	}
 	return caaf, nil
 }

pkg/executor/executortype/newdeploy/newdeploymgr.go

@@ -148,10 +148,16 @@ func MakeNewDeploy(
 		nd.svcListerSynced[ns] = informerFactory.Core().V1().Services().Informer().HasSynced
 	}
 	for _, factory := range finformerFactory {
-		factory.Core().V1().Functions().Informer().AddEventHandler(nd.FunctionEventHandlers(ctx))
+		_, err := factory.Core().V1().Functions().Informer().AddEventHandler(nd.FunctionEventHandlers(ctx))
+		if err != nil {
+			return nil, err
+		}
 	}
 	for _, factory := range finformerFactory {
-		factory.Core().V1().Environments().Informer().AddEventHandler(nd.EnvEventHandlers(ctx))
+		_, err := factory.Core().V1().Environments().Informer().AddEventHandler(nd.EnvEventHandlers(ctx))
+		if err != nil {
+			return nil, err
+		}
 	}
 	return nd, nil
 }

pkg/executor/executortype/poolmgr/gpm.go

@@ -134,9 +134,11 @@ func MakeGenericPoolManager(ctx context.Context,
 		enableIstio = istio
 	}
 
-	poolPodC := NewPoolPodController(ctx, gpmLogger, kubernetesClient,
+	poolPodC, err := NewPoolPodController(ctx, gpmLogger, kubernetesClient,
 		enableIstio, finformerFactory, gpmInformerFactory)
-
+	if err != nil {
+		return nil, err
+	}
 	gpm := &GenericPoolManager{
 		logger:                     gpmLogger,
 		pools:                      make(map[string]*GenericPool),
@@ -177,8 +179,8 @@ func (gpm *GenericPoolManager) Run(ctx context.Context) {
 	}
 	go gpm.service()
 	gpm.poolPodC.InjectGpm(gpm)
-	go gpm.WebsocketStartEventChecker(ctx, gpm.kubernetesClient)
-	go gpm.NoActiveConnectionEventChecker(ctx, gpm.kubernetesClient)
+	go gpm.WebsocketStartEventChecker(ctx, gpm.kubernetesClient)     //nolint:errcheck
+	go gpm.NoActiveConnectionEventChecker(ctx, gpm.kubernetesClient) //nolint:errcheck
 	go gpm.idleObjectReaper(ctx)
 	go gpm.poolPodC.Run(ctx, ctx.Done())
 }
@@ -205,13 +207,13 @@ func (gpm *GenericPoolManager) GetFuncSvc(ctx context.Context, fn *fv1.Function)
 	env, err := gpm.getFunctionEnv(ctx, fn)
 	if err != nil {
 		fErr = err
-		return
+		return nil, fErr
 	}
 
 	pool, created, err := gpm.getPool(ctx, env)
 	if err != nil {
 		fErr = err
-		return
+		return nil, fErr
 	}
 
 	if created {
@@ -695,13 +697,13 @@ func (gpm *GenericPoolManager) doIdleObjectReaper(ctx context.Context) {
 }
 
 // WebsocketStartEventChecker checks if the pod has emitted a websocket connection start event
-func (gpm *GenericPoolManager) WebsocketStartEventChecker(ctx context.Context, kubeClient kubernetes.Interface) {
+func (gpm *GenericPoolManager) WebsocketStartEventChecker(ctx context.Context, kubeClient kubernetes.Interface) error {
 	stopper := make(chan struct{})
 	defer close(stopper)
 
 	var wg wait.Group
 	for _, informer := range utils.GetInformerEventChecker(ctx, kubeClient, "WsConnectionStarted") {
-		informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
+		_, err := informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
 				mObj := obj.(metav1.Object)
 				gpm.logger.Info("Websocket event detected for pod",
@@ -718,19 +720,23 @@ func (gpm *GenericPoolManager) WebsocketStartEventChecker(ctx context.Context, k
 				}
 			},
 		})
+		if err != nil {
+			return err
+		}
 		wg.StartWithChannel(stopper, informer.Run)
 	}
 	wg.Wait()
+	return nil
 }
 
 // NoActiveConnectionEventChecker checks if the pod has emitted an inactive event
-func (gpm *GenericPoolManager) NoActiveConnectionEventChecker(ctx context.Context, kubeClient kubernetes.Interface) {
+func (gpm *GenericPoolManager) NoActiveConnectionEventChecker(ctx context.Context, kubeClient kubernetes.Interface) error {
 	stopper := make(chan struct{})
 	defer close(stopper)
 
 	var wg wait.Group
 	for _, informer := range utils.GetInformerEventChecker(ctx, kubeClient, "NoActiveConnections") {
-		informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
+		_, err := informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
 				mObj := obj.(metav1.Object)
 				gpm.logger.Info("Inactive event detected for pod",
@@ -758,9 +764,13 @@ func (gpm *GenericPoolManager) NoActiveConnectionEventChecker(ctx context.Contex
 
 			},
 		})
+		if err != nil {
+			return err
+		}
 		wg.StartWithChannel(stopper, informer.Run)
 	}
 	wg.Wait()
+	return nil
 }
 
 func (gpm *GenericPoolManager) DumpDebugInfo(ctx context.Context) error {

pkg/executor/executortype/poolmgr/poolpodcontroller.go

@@ -71,7 +71,7 @@ func NewPoolPodController(ctx context.Context, logger *zap.Logger,
 	kubernetesClient kubernetes.Interface,
 	enableIstio bool,
 	finformerFactory map[string]genInformer.SharedInformerFactory,
-	gpmInformerFactory map[string]k8sInformers.SharedInformerFactory) *PoolPodController {
+	gpmInformerFactory map[string]k8sInformers.SharedInformerFactory) (*PoolPodController, error) {
 	logger = logger.Named("pool_pod_controller")
 	p := &PoolPodController{
 		logger:               logger,
@@ -88,30 +88,39 @@ func NewPoolPodController(ctx context.Context, logger *zap.Logger,
 	}
 	if p.enableIstio {
 		for _, factory := range finformerFactory {
-			factory.Core().V1().Functions().Informer().AddEventHandler(FunctionEventHandlers(ctx, p.logger, p.kubernetesClient, p.nsResolver.ResolveNamespace(p.nsResolver.FunctionNamespace), p.enableIstio))
+			_, err := factory.Core().V1().Functions().Informer().AddEventHandler(FunctionEventHandlers(ctx, p.logger, p.kubernetesClient, p.nsResolver.ResolveNamespace(p.nsResolver.FunctionNamespace), p.enableIstio))
+			if err != nil {
+				return nil, err
+			}
 		}
 	}
 	for ns, informer := range finformerFactory {
-		informer.Core().V1().Environments().Informer().AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
+		_, err := informer.Core().V1().Environments().Informer().AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
 			AddFunc:    p.enqueueEnvAdd,
 			UpdateFunc: p.enqueueEnvUpdate,
 			DeleteFunc: p.enqueueEnvDelete,
 		})
+		if err != nil {
+			return nil, err
+		}
 		p.envLister[ns] = informer.Core().V1().Environments().Lister()
 		p.envListerSynced[ns] = informer.Core().V1().Environments().Informer().HasSynced
 	}
 	for ns, informerFactory := range gpmInformerFactory {
-		informerFactory.Apps().V1().ReplicaSets().Informer().AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
+		_, err := informerFactory.Apps().V1().ReplicaSets().Informer().AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
 			AddFunc:    p.handleRSAdd,
 			UpdateFunc: p.handleRSUpdate,
 			DeleteFunc: p.handleRSDelete,
 		})
+		if err != nil {
+			return nil, err
+		}
 		p.podListerSynced[ns] = informerFactory.Core().V1().Pods().Informer().HasSynced
 		p.podLister[ns] = informerFactory.Core().V1().Pods().Lister()
 	}
 
 	p.logger.Info("pool pod controller handlers registered")
-	return p
+	return p, nil
 }
 
 func (p *PoolPodController) InjectGpm(gpm *GenericPoolManager) {

pkg/executor/executortype/poolmgr/poolpodcontroller_test.go

@@ -51,8 +51,11 @@ func TestPoolPodControllerPodCleanup(t *testing.T) {
 	}
 	gpmInformerFactory := utils.GetInformerFactoryByExecutor(kubernetesClient, executorLabel, time.Minute*30)
 
-	ppc := NewPoolPodController(ctx, logger, kubernetesClient, false,
+	ppc, err := NewPoolPodController(ctx, logger, kubernetesClient, false,
 		factory, gpmInformerFactory)
+	if err != nil {
+		t.Fatalf("Error creating pool pod controller: %v", err)
+	}
 
 	executorInstanceID := strings.ToLower(uniuri.NewLen(8))
 	metricsClient := metricsclient.NewSimpleClientset()

pkg/executor/executortype/poolmgr/readyPodController.go

@@ -38,7 +38,10 @@ func (gp *GenericPool) setupReadyPodController() error {
 	podInformer := informerFactory.Core().V1().Pods()
 	gp.readyPodLister = podInformer.Lister()
 	gp.readyPodListerSynced = podInformer.Informer().HasSynced
-	podInformer.Informer().AddEventHandler(gp.readyPodEventHandlers())
+	_, err = podInformer.Informer().AddEventHandler(gp.readyPodEventHandlers())
+	if err != nil {
+		return err
+	}
 	go podInformer.Informer().Run(gp.stopReadyPodControllerCh)
 	gp.logger.Info("readyPod controller started", zap.String("env", gp.env.ObjectMeta.Name), zap.String("envID", string(gp.env.ObjectMeta.UID)))
 	return nil

pkg/kubewatcher/main.go

@@ -44,7 +44,10 @@ func Start(ctx context.Context, logger *zap.Logger, routerUrl string) error {
 
 	poster := publisher.MakeWebhookPublisher(logger, routerUrl)
 	kubeWatch := MakeKubeWatcher(ctx, logger, kubeClient, poster)
-	ws := MakeWatchSync(ctx, logger, fissionClient, kubeWatch)
+	ws, err := MakeWatchSync(ctx, logger, fissionClient, kubeWatch)
+	if err != nil {
+		return errors.Wrap(err, "error making watch sync")
+	}
 	ws.Run(ctx)
 
 	return nil

pkg/kubewatcher/watchSync.go

@@ -37,15 +37,18 @@ type (
 	}
 )
 
-func MakeWatchSync(ctx context.Context, logger *zap.Logger, client versioned.Interface, kubeWatcher *KubeWatcher) *WatchSync {
+func MakeWatchSync(ctx context.Context, logger *zap.Logger, client versioned.Interface, kubeWatcher *KubeWatcher) (*WatchSync, error) {
 	ws := &WatchSync{
 		logger:      logger.Named("watch_sync"),
 		client:      client,
 		kubeWatcher: kubeWatcher,
 	}
 	ws.kubeWatcherInformer = utils.GetInformersForNamespaces(client, time.Minute*30, fv1.KubernetesWatchResource)
-	ws.KubeWatcherEventHandlers(ctx)
-	return ws
+	err := ws.KubeWatcherEventHandlers(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return ws, nil
 }
 
 func (ws *WatchSync) Run(ctx context.Context) {
@@ -54,9 +57,9 @@ func (ws *WatchSync) Run(ctx context.Context) {
 	}
 }
 
-func (ws *WatchSync) KubeWatcherEventHandlers(ctx context.Context) {
+func (ws *WatchSync) KubeWatcherEventHandlers(ctx context.Context) error {
 	for _, informer := range ws.kubeWatcherInformer {
-		informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
+		_, err := informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
 				objKubeWatcher := obj.(*fv1.KubernetesWatchTrigger)
 				ws.kubeWatcher.addWatch(ctx, objKubeWatcher) //nolint: errCheck
@@ -66,5 +69,9 @@ func (ws *WatchSync) KubeWatcherEventHandlers(ctx context.Context) {
 				ws.kubeWatcher.removeWatch(objKubeWatcher) //nolint: errCheck
 			},
 		})
+		if err != nil {
+			return err
+		}
 	}
+	return nil
 }

pkg/logger/logger.go

@@ -19,7 +19,6 @@ package logger
 import (
 	"context"
 	"fmt"
-	"log"
 	"os"
 	"path/filepath"
 	"strings"
@@ -157,7 +156,7 @@ func symlinkReaper(zapLogger *zap.Logger) {
 	}
 }
 
-func Start(ctx context.Context, logger *zap.Logger) {
+func Start(ctx context.Context, logger *zap.Logger) error {
 	if _, err := os.Stat(fissionSymlinkPath); os.IsNotExist(err) {
 		logger.Info("symlink path not exist, create it",
 			zap.String("fissionSymlinkPath", fissionSymlinkPath))
@@ -171,15 +170,19 @@ func Start(ctx context.Context, logger *zap.Logger) {
 	clientGen := crd.NewClientGenerator()
 	kubernetesClient, err := clientGen.GetKubernetesClient()
 	if err != nil {
-		log.Fatalf("Error starting pod watcher: %v", err)
+		return err
 	}
 
 	var wg wait.Group
 	for _, podInformer := range utils.GetK8sInformersForNamespaces(kubernetesClient, time.Minute*30, fv1.Pods) {
-		podInformer.AddEventHandler(podInformerHandlers(logger))
+		_, err := podInformer.AddEventHandler(podInformerHandlers(logger))
+		if err != nil {
+			return err
+		}
 		wg.StartWithChannel(ctx.Done(), podInformer.Run)
 	}
 	wg.Wait()
 
 	logger.Error("Stop watching pod changes")
+	return nil
 }

pkg/mqtrigger/mqtmanager.go

@@ -78,16 +78,20 @@ func MakeMessageQueueTriggerManager(logger *zap.Logger,
 	return &mqTriggerMgr
 }
 
-func (mqt *MessageQueueTriggerManager) Run(ctx context.Context) {
+func (mqt *MessageQueueTriggerManager) Run(ctx context.Context) error {
 	go mqt.service()
 	for _, informer := range utils.GetInformersForNamespaces(mqt.fissionClient, time.Minute*30, fv1.MessageQueueResource) {
-		informer.AddEventHandler(mqt.mqtInformerHandlers())
+		_, err := informer.AddEventHandler(mqt.mqtInformerHandlers())
+		if err != nil {
+			return err
+		}
 		go informer.Run(ctx.Done())
 		if ok := k8sCache.WaitForCacheSync(ctx.Done(), informer.HasSynced); !ok {
 			mqt.logger.Fatal("failed to wait for caches to sync")
 		}
 	}
 	go metrics.ServeMetrics(ctx, mqt.logger)
+	return nil
 }
 
 func (mqt *MessageQueueTriggerManager) service() {

pkg/mqtrigger/scalermanager.go

@@ -167,7 +167,10 @@ func StartScalerManager(ctx context.Context, logger *zap.Logger, routerURL strin
 	}
 
 	for _, informer := range utils.GetInformersForNamespaces(fissionClient, time.Minute*30, fv1.MessageQueueResource) {
-		informer.AddEventHandler(mqTriggerEventHandlers(ctx, logger, kubeClient, routerURL))
+		_, err := informer.AddEventHandler(mqTriggerEventHandlers(ctx, logger, kubeClient, routerURL))
+		if err != nil {
+			return err
+		}
 		go informer.Run(ctx.Done())
 		if ok := k8sCache.WaitForCacheSync(ctx.Done(), informer.HasSynced); !ok {
 			logger.Fatal("failed to wait for caches to sync")

pkg/router/httpTriggers.go

@@ -64,7 +64,7 @@ type HTTPTriggerSet struct {
 }
 
 func makeHTTPTriggerSet(logger *zap.Logger, fmap *functionServiceMap, fissionClient versioned.Interface,
-	kubeClient kubernetes.Interface, executor *executorClient.Client, params *tsRoundTripperParams, isDebugEnv bool, unTapServiceTimeout time.Duration, actionThrottler *throttler.Throttler) *HTTPTriggerSet {
+	kubeClient kubernetes.Interface, executor *executorClient.Client, params *tsRoundTripperParams, isDebugEnv bool, unTapServiceTimeout time.Duration, actionThrottler *throttler.Throttler) (*HTTPTriggerSet, error) {
 
 	httpTriggerSet := &HTTPTriggerSet{
 		logger:                     logger.Named("http_trigger_set"),
@@ -82,9 +82,15 @@ func makeHTTPTriggerSet(logger *zap.Logger, fmap *functionServiceMap, fissionCli
 	}
 	httpTriggerSet.triggerInformer = utils.GetInformersForNamespaces(fissionClient, time.Minute*30, fv1.HttpTriggerResource)
 	httpTriggerSet.funcInformer = utils.GetInformersForNamespaces(fissionClient, time.Minute*30, fv1.FunctionResource)
-	httpTriggerSet.addTriggerHandlers()
-	httpTriggerSet.addFunctionHandlers()
-	return httpTriggerSet
+	err := httpTriggerSet.addTriggerHandlers()
+	if err != nil {
+		return nil, err
+	}
+	err = httpTriggerSet.addFunctionHandlers()
+	if err != nil {
+		return nil, err
+	}
+	return httpTriggerSet, nil
 }
 
 func (ts *HTTPTriggerSet) subscribeRouter(ctx context.Context, mr *mutableRouter) {
@@ -290,9 +296,9 @@ func (ts *HTTPTriggerSet) updateTriggerStatusFailed(ht *fv1.HTTPTrigger, err err
 	// TODO
 }
 
-func (ts *HTTPTriggerSet) addTriggerHandlers() {
+func (ts *HTTPTriggerSet) addTriggerHandlers() error {
 	for _, triggerInformer := range ts.triggerInformer {
-		triggerInformer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
+		_, err := triggerInformer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
 				trigger := obj.(*fv1.HTTPTrigger)
 				go createIngress(context.Background(), ts.logger, trigger, ts.kubeClient)
@@ -315,13 +321,17 @@ func (ts *HTTPTriggerSet) addTriggerHandlers() {
 				ts.syncTriggers()
 			},
 		})
+		if err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
-func (ts *HTTPTriggerSet) addFunctionHandlers() {
+func (ts *HTTPTriggerSet) addFunctionHandlers() error {
 	for _, funcInformer := range ts.funcInformer {
 
-		funcInformer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
+		_, err := funcInformer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
 				ts.syncTriggers()
 			},
@@ -353,7 +363,11 @@ func (ts *HTTPTriggerSet) addFunctionHandlers() {
 				ts.syncTriggers()
 			},
 		})
+		if err != nil {
+			return err
+		}
 	}
+	return nil
 }
 
 func (ts *HTTPTriggerSet) runInformer(ctx context.Context, informer map[string]k8sCache.SharedIndexInformer) {

pkg/router/router.go

@@ -200,7 +200,7 @@ func Start(ctx context.Context, logger *zap.Logger, port int, executorURL string
 			zap.Bool("default", displayAccessLog))
 	}
 
-	triggers := makeHTTPTriggerSet(logger.Named("triggerset"), fmap, fissionClient, kubeClient, executor, &tsRoundTripperParams{
+	triggers, err := makeHTTPTriggerSet(logger.Named("triggerset"), fmap, fissionClient, kubeClient, executor, &tsRoundTripperParams{
 		timeout:           timeout,
 		timeoutExponent:   timeoutExponent,
 		disableKeepAlive:  disableKeepAlive,
@@ -208,7 +208,9 @@ func Start(ctx context.Context, logger *zap.Logger, port int, executorURL string
 		maxRetries:        maxRetries,
 		svcAddrRetryCount: svcAddrRetryCount,
 	}, isDebugEnv, unTapServiceTimeout, throttler.MakeThrottler(svcAddrUpdateTimeout))
-
+	if err != nil {
+		logger.Fatal("error making HTTP trigger set", zap.Error(err))
+	}
 	go metrics.ServeMetrics(ctx, logger)
 
 	logger.Info("starting router", zap.Int("port", port))

pkg/timer/main.go

@@ -39,8 +39,10 @@ func Start(ctx context.Context, logger *zap.Logger, routerUrl string) error {
 	}
 
 	poster := publisher.MakeWebhookPublisher(logger, routerUrl)
-	timerSync := MakeTimerSync(ctx, logger, fissionClient, MakeTimer(logger, poster))
+	timerSync, err := MakeTimerSync(ctx, logger, fissionClient, MakeTimer(logger, poster))
+	if err != nil {
+		return errors.Wrap(err, "error making timer sync")
+	}
 	timerSync.Run(ctx)
-
 	return nil
 }

pkg/timer/timerSync.go

@@ -38,15 +38,18 @@ type (
 	}
 )
 
-func MakeTimerSync(ctx context.Context, logger *zap.Logger, fissionClient versioned.Interface, timer *Timer) *TimerSync {
+func MakeTimerSync(ctx context.Context, logger *zap.Logger, fissionClient versioned.Interface, timer *Timer) (*TimerSync, error) {
 	ws := &TimerSync{
 		logger:        logger.Named("timer_sync"),
 		fissionClient: fissionClient,
 		timer:         timer,
 	}
 	ws.timeTriggerInformer = utils.GetInformersForNamespaces(fissionClient, time.Minute*30, fv1.TimeTriggerResource)
-	ws.TimeTriggerEventHandlers(ctx)
-	return ws
+	err := ws.TimeTriggerEventHandlers(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return ws, nil
 }
 
 func (ws *TimerSync) Run(ctx context.Context) {
@@ -89,9 +92,9 @@ func (ws *TimerSync) DeleteTimeTrigger(timeTrigger *fv1.TimeTrigger) {
 	}
 }
 
-func (ws *TimerSync) TimeTriggerEventHandlers(ctx context.Context) {
+func (ws *TimerSync) TimeTriggerEventHandlers(ctx context.Context) error {
 	for _, informer := range ws.timeTriggerInformer {
-		informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
+		_, err := informer.AddEventHandler(k8sCache.ResourceEventHandlerFuncs{
 			AddFunc: func(obj interface{}) {
 				timeTrigger := obj.(*fv1.TimeTrigger)
 				ws.AddUpdateTimeTrigger(timeTrigger)
@@ -108,5 +111,9 @@ func (ws *TimerSync) TimeTriggerEventHandlers(ctx context.Context) {
 				ws.DeleteTimeTrigger(timeTrigger)
 			},
 		})
+		if err != nil {
+			return err
+		}
 	}
+	return nil
 }

pkg/webhook/admission-webhook.go

@@ -27,6 +27,8 @@ import (
 	_ "k8s.io/client-go/plugin/pkg/client/auth"
 	"sigs.k8s.io/controller-runtime/pkg/client/config"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
+	metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server"
+	"sigs.k8s.io/controller-runtime/pkg/webhook"
 
 	v1 "github.com/fission/fission/pkg/apis/core/v1"
 	"github.com/fission/fission/pkg/generated/clientset/versioned/scheme"
@@ -45,12 +47,18 @@ func Start(ctx context.Context, logger *zap.Logger, port int) (err error) {
 	if metricsAddr == "" {
 		metricsAddr = ":8080"
 	}
+
+	mgrOpt := manager.Options{
+		Scheme: scheme.Scheme,
+		Metrics: metricsserver.Options{
+			BindAddress: metricsAddr,
+		},
+		WebhookServer: webhook.NewServer(webhook.Options{
+			Port: port,
+		}),
+	}
 	// Setup a Manager
-	mgr, err := manager.New(config.GetConfigOrDie(), manager.Options{
-		Scheme:             scheme.Scheme,
-		Port:               port,
-		MetricsBindAddress: metricsAddr,
-	})
+	mgr, err := manager.New(config.GetConfigOrDie(), mgrOpt)
 	if err != nil {
 		wLogger.Error("unable to set up overall controller manager", zap.Error(err))
 		return err