From 23c8926a0f174a9c8a511cdc8ede319271971c6e Mon Sep 17 00:00:00 2001
From: Raman Tehlan <ramantehlan@gmail.com>
Date: Tue, 2 Jul 2024 15:25:18 +0530
Subject: [PATCH] feat: rollout tested

---
 Makefile                                      |   9 +-
 README.md                                     |   6 +
 demo-elastiService.yaml                       |   2 +-
 go.work.sum                                   |   1 +
 operator/install.yaml => install.yaml         |  86 ++++++++++++-
 kustomization.yaml                            |   3 +
 .../config/rbac/role_additional_binding.yaml  |  16 ---
 operator/config/rbac/service_account.yaml     |   2 +-
 .../controller/elastiservice_controller.go    |  89 +++-----------
 operator/internal/controller/opsCRD.go        | 115 +++++++++++++++++-
 operator/internal/controller/opsInformer.go   |  14 +++
 operator/internal/controller/opsModes.go      |   7 +-
 .../internal/elastiServer/elastiServer.go     |  10 +-
 operator/internal/informer/informer.go        |  17 ++-
 pkg/k8sHelper/errors.go                       |   2 +
 pkg/k8sHelper/ops.go                          |  34 +++++-
 pkg/values/values.go                          |  16 +++
 resolver/Dockerfile.cross                     |  35 ++++++
 resolver/cmd/main.go                          |  18 ++-
 resolver/config/clusterRole.yaml              |  11 ++
 resolver/config/clusterRoleBinding.yaml       |  15 +++
 resolver/config/kustomization.yaml            |   5 +
 resolver/config/serviceAccount.yaml           |   8 ++
 resolver/install.yaml                         |  45 -------
 24 files changed, 388 insertions(+), 178 deletions(-)
 rename operator/install.yaml => install.yaml (88%)
 create mode 100644 kustomization.yaml
 create mode 100644 resolver/Dockerfile.cross
 create mode 100644 resolver/config/clusterRole.yaml
 create mode 100644 resolver/config/clusterRoleBinding.yaml
 create mode 100644 resolver/config/serviceAccount.yaml
 delete mode 100644 resolver/install.yaml

diff --git a/Makefile b/Makefile
index b672078d..155c9a69 100644
--- a/Makefile
+++ b/Makefile
@@ -16,16 +16,13 @@ helm-chart: ## Create Helm chart for the operator
 
 .PHONY: generate-manifest
 generate-manifest: ## Generate deploy manifest
-	kustomize build operator/config/default > ./operator/install.yaml
-	kustomize build resolver/config/ > ./resolver/install.yaml
+	kustomize build . > ./install.yaml
 
 .PHONY: deploy
 deploy: ## Deploy the operator and resolver
-	kubectl apply -f ./resolver/install.yaml
-	kubectl apply -f ./operator/install.yaml	
+	kubectl apply -f ./install.yaml
 
 .PHONY: undeploy
 undeploy: ## Undeploy the operator and resolver
-	kubectl delete -f ./resolver/install.yaml
-	kubectl delete -f ./operator/install.yaml	
+	kubectl delete -f ./install.yaml
 
diff --git a/README.md b/README.md
index b84100f4..1b638bf3 100644
--- a/README.md
+++ b/README.md
@@ -105,7 +105,13 @@ The icon is <a href="https://www.flaticon.com/free-icons/full-screen" title="ful
 
 
 
+---
 
+```
+Get argo rollout type locally
+kubectl apply -f https://github.com/argoproj/argo-rollouts/releases/latest/download/install.yaml
+
+```
 
 
 
diff --git a/demo-elastiService.yaml b/demo-elastiService.yaml
index faa272f6..fc9fe6d7 100644
--- a/demo-elastiService.yaml
+++ b/demo-elastiService.yaml
@@ -9,7 +9,7 @@ metadata:
 spec:
   queueTimeout: 4
   idlePeriod: 20
-  minTargetReplicas: 1
+  minTargetReplicas: 2
   service: emotion-class-svc
   scaleTargetRef:
     apiVersion: argoproj.io/v1alpha1
diff --git a/go.work.sum b/go.work.sum
index a4999eeb..9e593080 100644
--- a/go.work.sum
+++ b/go.work.sum
@@ -110,6 +110,7 @@ github.com/fxamacker/cbor/v2 v2.6.0 h1:sU6J2usfADwWlYDAFhZBQ6TnLFBHxgesMrQfQgk1t
 github.com/fxamacker/cbor/v2 v2.6.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ=
 github.com/ghodss/yaml v1.0.1-0.20190212211648-25d852aebe32/go.mod h1:GIjDIg/heH5DOkXY3YJ/wNhfHsQHoXGjl8G8amsYQ1I=
 github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
+github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
 github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
 github.com/go-gorp/gorp/v3 v3.0.5/go.mod h1:dLEjIyyRNiXvNZ8PSmzpt1GsWAUK8kjVhEpjH8TixEw=
 github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
diff --git a/operator/install.yaml b/install.yaml
similarity index 88%
rename from operator/install.yaml
rename to install.yaml
index 452b325e..cdab2950 100644
--- a/operator/install.yaml
+++ b/install.yaml
@@ -1,5 +1,10 @@
 apiVersion: v1
 kind: Namespace
+metadata:
+  name: elasti
+---
+apiVersion: v1
+kind: Namespace
 metadata:
   labels:
     app.kubernetes.io/managed-by: kustomize
@@ -292,6 +297,35 @@ rules:
   - update
 ---
 apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: elasti-resolver-additional-access
+rules:
+- apiGroups:
+  - apps
+  resources:
+  - deployments
+  verbs:
+  - get
+  - list
+  - watch
+  - update
+  - patch
+- apiGroups:
+  - ""
+  resources:
+  - services
+  - pods
+  verbs:
+  - get
+  - list
+  - watch
+  - update
+  - patch
+  - delete
+  - create
+---
+apiVersion: rbac.authorization.k8s.io/v1
 kind: RoleBinding
 metadata:
   labels:
@@ -363,15 +397,15 @@ metadata:
   labels:
     app.kubernetes.io/managed-by: kustomize
     app.kubernetes.io/name: elasti-operator
-  name: elasti-operator-resolver-additional-access-binding
+  name: elasti-resolver-additional-access-binding
 roleRef:
   apiGroup: rbac.authorization.k8s.io
   kind: ClusterRole
-  name: elasti-operator-additional-access
+  name: elasti-resolver-additional-access
 subjects:
 - kind: ServiceAccount
   name: default
-  namespace: elasti-operator-system
+  namespace: elasti
 ---
 apiVersion: v1
 kind: Service
@@ -409,6 +443,20 @@ spec:
   selector:
     control-plane: controller-manager
 ---
+apiVersion: v1
+kind: Service
+metadata:
+  name: resolver-service
+  namespace: elasti
+spec:
+  ports:
+  - name: http-playground
+    port: 8012
+    protocol: TCP
+  selector:
+    app: elasti-resolver
+  type: LoadBalancer
+---
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -472,3 +520,35 @@ spec:
         runAsNonRoot: true
       serviceAccountName: elasti-operator-controller-manager
       terminationGracePeriodSeconds: 10
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: elasti-resolver
+  namespace: elasti
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: elasti-resolver
+  template:
+    metadata:
+      labels:
+        app: elasti-resolver
+    spec:
+      containers:
+      - env:
+        - name: SYSTEM_NAMESPACE
+          value: elasti
+        image: ramantehlan/elasti-resolver:v1alpha1
+        imagePullPolicy: Always
+        name: playground
+        ports:
+        - containerPort: 8012
+        resources:
+          limits:
+            cpu: 750m
+            memory: 1Gi
+          requests:
+            cpu: 250m
+            memory: 500Mi
diff --git a/kustomization.yaml b/kustomization.yaml
new file mode 100644
index 00000000..1b35c66f
--- /dev/null
+++ b/kustomization.yaml
@@ -0,0 +1,3 @@
+resources:
+- operator/config/default
+- resolver/config
\ No newline at end of file
diff --git a/operator/config/rbac/role_additional_binding.yaml b/operator/config/rbac/role_additional_binding.yaml
index 0833dcb8..4eac4edc 100644
--- a/operator/config/rbac/role_additional_binding.yaml
+++ b/operator/config/rbac/role_additional_binding.yaml
@@ -13,19 +13,3 @@ subjects:
 - kind: ServiceAccount
   name: elasti-operator-controller-manager
   namespace: elasti-operator-system
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: ClusterRoleBinding
-metadata:
-  labels:
-    app.kubernetes.io/name: elasti-operator
-    app.kubernetes.io/managed-by: kustomize
-  name: resolver-additional-access-binding
-roleRef:
-  apiGroup: rbac.authorization.k8s.io
-  kind: ClusterRole
-  name: additional-access
-subjects:
-- kind: ServiceAccount
-  name: default
-  namespace: elasti
diff --git a/operator/config/rbac/service_account.yaml b/operator/config/rbac/service_account.yaml
index cce97c6d..a333a1db 100644
--- a/operator/config/rbac/service_account.yaml
+++ b/operator/config/rbac/service_account.yaml
@@ -5,4 +5,4 @@ metadata:
     app.kubernetes.io/name: elasti-operator
     app.kubernetes.io/managed-by: kustomize
   name: controller-manager
-  namespace: system
+  namespace: system
\ No newline at end of file
diff --git a/operator/internal/controller/elastiservice_controller.go b/operator/internal/controller/elastiservice_controller.go
index 5c2331c2..412d8ed2 100644
--- a/operator/internal/controller/elastiservice_controller.go
+++ b/operator/internal/controller/elastiservice_controller.go
@@ -2,24 +2,18 @@ package controller
 
 import (
 	"context"
-	"strings"
 	"sync"
 
-	"github.com/truefoundry/elasti/pkg/utils"
 	"truefoundry.io/elasti/internal/crdDirectory"
 	"truefoundry.io/elasti/internal/informer"
 
 	"k8s.io/apimachinery/pkg/api/errors"
 	kRuntime "k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 
 	"truefoundry.io/elasti/api/v1alpha1"
 
-	"runtime"
-
 	"go.uber.org/zap"
 )
 
@@ -59,23 +53,12 @@ const (
 // For more details, check Reconcile and its Result here:
 // - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.17.3/pkg/reconcile
 func (r *ElastiServiceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (res ctrl.Result, err error) {
-	defer func() {
-		if rErr := recover(); rErr != nil {
-			r.Logger.Error("Recovered from panic", zap.Any("recovered", rErr))
-			buf := make([]byte, 4096)
-			n := runtime.Stack(buf, false)
-			r.Logger.Error("Panic stack trace", zap.ByteString("stacktrace", buf[:n]))
-		}
-	}()
-
 	r.Logger.Debug("- In Reconcile", zap.String("es", req.NamespacedName.String()))
 	mutex := r.getMutexForReconcile(req.NamespacedName.String())
 	mutex.Lock()
 	defer r.Logger.Debug("- Out of Reconcile", zap.String("es", req.NamespacedName.String()))
 	defer mutex.Unlock()
 
-	// First we get the ElastiService object
-	// No mutex is taken for this, as we are not modifying the object, but if we face issues in future, we can add a mutex
 	es, esErr := r.getCRD(ctx, req.NamespacedName)
 	if esErr != nil {
 		if errors.IsNotFound(esErr) {
@@ -87,75 +70,35 @@ func (r *ElastiServiceReconciler) Reconcile(ctx context.Context, req ctrl.Reques
 	}
 
 	// If the ElastiService is being deleted, we need to clean up the resources
-	if !es.ObjectMeta.DeletionTimestamp.IsZero() {
-		if controllerutil.ContainsFinalizer(es, v1alpha1.ElastiServiceFinalizer) {
-			// If CRD contains finalizer, we call the finaizer function and remove the finalizer post that
-			if err := r.finalizeCRD(ctx, es, req); err != nil {
-				r.Logger.Error("Failed to enable serve mode", zap.String("es", req.String()), zap.Error(err))
-				return res, err
-			}
-			controllerutil.RemoveFinalizer(es, v1alpha1.ElastiServiceFinalizer)
-			if err := r.Update(ctx, es); err != nil {
-				return res, err
-			}
-		}
-		return res, nil
+	if err := r.checkIfCRDIsDeleted(ctx, es, req); err != nil {
+		r.Logger.Error("Failed to check if CRD is deleted", zap.String("es", req.String()), zap.Error(err))
+		return res, err
 	}
 
 	// We also check if the CRD has finalizer, and if not, we add the finalizer
-	if err := r.checkFinalizerCRD(ctx, es, req); err != nil {
+	if err := r.checkAndAddCRDFinalizer(ctx, es, req); err != nil {
 		r.Logger.Error("Failed to finalize CRD", zap.String("es", req.String()), zap.Error(err))
 		return res, err
 	}
 
+	// Check if ScaleTargetRef is present, and has not changed from the values in CRDDirectory
+	if err := r.checkChangesInScaleTargetRef(ctx, es, req); err != nil {
+		r.Logger.Error("Failed to check changes in ScaleTargetRef", zap.String("es", req.String()), zap.Error(err))
+		return res, err
+	}
+
+	// Check if Public Service is present, and has not changed from the values in CRDDirectory
+	if err := r.checkChangesInPublicService(ctx, es, req); err != nil {
+		r.Logger.Error("Failed to check changes in public service", zap.String("es", req.String()), zap.Error(err))
+		return res, err
+	}
+
 	// We add the CRD details to service directory, so when elasti server received a request,
 	// we can find the right resource to scale up
 	crdDirectory.CRDDirectory.AddCRD(es.Spec.Service, &crdDirectory.CRDDetails{
 		CRDName: es.Name,
 		Spec:    es.Spec,
 	})
-
-	// We need to start the informer only once per CRD. This is to avoid multiple informers for the same CRD
-	// We reset mutex if crd is deleted, so it can be used again if the same CRD is reapplied
-	r.getMutexForInformerStart(req.NamespacedName.String()).Do(func() {
-		targetGroup, targetVersion, err := utils.ParseAPIVersion(es.Spec.ScaleTargetRef.APIVersion)
-		if err != nil {
-			r.Logger.Error("Failed to parse API version", zap.String("APIVersion", es.Spec.ScaleTargetRef.APIVersion), zap.Error(err))
-			return
-		}
-
-		// Watch for changes in ScaleTargetRef
-		r.Informer.Add(&informer.RequestWatch{
-			Req:               req,
-			ResourceName:      es.Spec.ScaleTargetRef.Name,
-			ResourceNamespace: req.Namespace,
-			GroupVersionResource: &schema.GroupVersionResource{
-				Group:    targetGroup,
-				Version:  targetVersion,
-				Resource: strings.ToLower(es.Spec.ScaleTargetRef.Kind),
-			},
-			Handlers: r.getScaleTargetRefChangeHandler(ctx, es, req),
-		})
-
-		// Watch for changes in public service
-		r.Informer.Add(&informer.RequestWatch{
-			Req:               req,
-			ResourceName:      es.Spec.Service,
-			ResourceNamespace: es.Namespace,
-			GroupVersionResource: &schema.GroupVersionResource{
-				Group:    "",
-				Version:  "v1",
-				Resource: "services",
-			},
-			Handlers: r.getPublicServiceChangeHandler(ctx, es, req),
-		})
-
-		r.Logger.Info("ScaleTargetRef and Public Service added to informer", zap.String("es", req.String()),
-			zap.String("scaleTargetRef", es.Spec.ScaleTargetRef.Name),
-			zap.String("public service", es.Spec.Service),
-		)
-	})
-
 	return res, nil
 }
 
diff --git a/operator/internal/controller/opsCRD.go b/operator/internal/controller/opsCRD.go
index 110d1d1a..79ed4059 100644
--- a/operator/internal/controller/opsCRD.go
+++ b/operator/internal/controller/opsCRD.go
@@ -2,14 +2,20 @@ package controller
 
 import (
 	"context"
+	"strings"
 
+	"github.com/truefoundry/elasti/pkg/k8sHelper"
+	"github.com/truefoundry/elasti/pkg/utils"
+	"github.com/truefoundry/elasti/pkg/values"
 	"go.uber.org/zap"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
 	"truefoundry.io/elasti/api/v1alpha1"
 	"truefoundry.io/elasti/internal/crdDirectory"
+	"truefoundry.io/elasti/internal/informer"
 )
 
 func (r *ElastiServiceReconciler) getCRD(ctx context.Context, crdNamespacedName types.NamespacedName) (*v1alpha1.ElastiService, error) {
@@ -36,7 +42,7 @@ func (r *ElastiServiceReconciler) updateCRDStatus(ctx context.Context, crdNamesp
 	r.Logger.Info("CRD Status updated successfully")
 }
 
-func (r *ElastiServiceReconciler) checkFinalizerCRD(ctx context.Context, es *v1alpha1.ElastiService, req ctrl.Request) error {
+func (r *ElastiServiceReconciler) checkAndAddCRDFinalizer(ctx context.Context, es *v1alpha1.ElastiService, req ctrl.Request) error {
 	// If the CRD does not contain the finalizer, we add the finalizer
 	if !controllerutil.ContainsFinalizer(es, v1alpha1.ElastiServiceFinalizer) {
 		controllerutil.AddFinalizer(es, v1alpha1.ElastiServiceFinalizer)
@@ -53,7 +59,8 @@ func (r *ElastiServiceReconciler) checkFinalizerCRD(ctx context.Context, es *v1a
 func (r *ElastiServiceReconciler) finalizeCRD(ctx context.Context, es *v1alpha1.ElastiService, req ctrl.Request) error {
 	r.Logger.Info("ElastiService is being deleted", zap.String("name", es.Name), zap.Any("deletionTimestamp", es.ObjectMeta.DeletionTimestamp))
 	// Reset the informer start mutex, so if the ElastiService is recreated, we will need to reset the informer
-	r.resetMutexForInformer(req.NamespacedName.String())
+	r.resetMutexForInformer(r.getMutexKeyForTargetRef(req))
+	r.resetMutexForInformer(r.getMutexKeyForPublicSVC(req))
 	// Stop all active informers
 	// NOTE: If the informerManager is shared across multiple controllers, this will stop all informers
 	// In that case, we must call the
@@ -76,3 +83,107 @@ func (r *ElastiServiceReconciler) finalizeCRD(ctx context.Context, es *v1alpha1.
 	r.Logger.Info("Serve mode enabled")
 	return nil
 }
+
+// checkChangesInScaleTargetRef checks if the ScaleTargetRef has changed, and if it has, stops the informer for the old ScaleTargetRef
+// Start the new informer for the new ScaleTargetRef
+func (r *ElastiServiceReconciler) checkChangesInScaleTargetRef(ctx context.Context, es *v1alpha1.ElastiService, req ctrl.Request) error {
+	if es.Spec.ScaleTargetRef.Name == "" ||
+		es.Spec.ScaleTargetRef.Kind == "" ||
+		es.Spec.ScaleTargetRef.APIVersion == "" {
+		r.Logger.Error("ScaleTargetRef is not present", zap.String("es", req.String()), zap.Any("scaleTargetRef", es.Spec.ScaleTargetRef))
+		return k8sHelper.ErrNoScaleTargetFound
+	}
+
+	crd, found := crdDirectory.CRDDirectory.GetCRD(es.Spec.Service)
+	if found {
+		if es.Spec.ScaleTargetRef.Name != crd.Spec.ScaleTargetRef.Name ||
+			es.Spec.ScaleTargetRef.Kind != crd.Spec.ScaleTargetRef.Kind ||
+			es.Spec.ScaleTargetRef.APIVersion != crd.Spec.ScaleTargetRef.APIVersion {
+			r.Logger.Info("ScaleTargetRef has changed", zap.String("es", req.String()))
+			r.Logger.Debug("Stopping informer for scaleTargetRef", zap.Any("scaleTargetRef", es.Spec.ScaleTargetRef))
+			key := r.Informer.GetKey(req.Namespace, req.Name, crd.Spec.ScaleTargetRef.Name, strings.ToLower(crd.Spec.ScaleTargetRef.Kind))
+			r.Informer.StopInformer(key)
+			r.Logger.Debug("Resetting mutex for scaleTargetRef", zap.Any("scaleTargetRef", es.Spec.ScaleTargetRef))
+			r.resetMutexForInformer(r.getMutexKeyForTargetRef(req))
+		}
+	}
+
+	r.getMutexForInformerStart(r.getMutexKeyForTargetRef(req)).Do(func() {
+		targetGroup, targetVersion, err := utils.ParseAPIVersion(es.Spec.ScaleTargetRef.APIVersion)
+		if err != nil {
+			r.Logger.Error("Failed to parse API version", zap.String("APIVersion", es.Spec.ScaleTargetRef.APIVersion), zap.Error(err))
+			return
+		}
+		r.Informer.Add(&informer.RequestWatch{
+			Req:               req,
+			ResourceName:      es.Spec.ScaleTargetRef.Name,
+			ResourceNamespace: req.Namespace,
+			GroupVersionResource: &schema.GroupVersionResource{
+				Group:    targetGroup,
+				Version:  targetVersion,
+				Resource: strings.ToLower(es.Spec.ScaleTargetRef.Kind),
+			},
+			Handlers: r.getScaleTargetRefChangeHandler(ctx, es, req),
+		})
+
+		r.Logger.Info("ScaleTargetRef added to informer", zap.String("es", req.String()),
+			zap.String("scaleTargetRef", es.Spec.ScaleTargetRef.Name),
+		)
+	})
+	return nil
+}
+
+// checkChangesInPublicService checks if the Public Service has changed, and makes sure it's not null
+
+func (r *ElastiServiceReconciler) checkChangesInPublicService(ctx context.Context, es *v1alpha1.ElastiService, req ctrl.Request) error {
+	if es.Spec.Service == "" {
+		r.Logger.Error("Public Service is not present", zap.String("es", req.String()))
+		return k8sHelper.ErrNoPublicServiceFound
+	}
+
+	// crd, found := crdDirectory.CRDDirectory.GetCRD(es.Spec.Service)
+	// if found {
+	// 	if crd.Spec.Service != es.Spec.Service {
+	// 		r.Logger.Info("Public Service has changed", zap.String("es", req.String()))
+	// 		r.Logger.Debug("Stopping informer for public service", zap.String("public service", crd.Spec.Service))
+	// 		key := r.Informer.GetKey(req.Namespace, req.Name, crd.Spec.Service, values.KindService)
+	// 		r.Informer.StopInformer(key)
+	// 		r.Logger.Debug("Resetting mutex for public service", zap.String("public service", crd.Spec.Service))
+	// 		r.resetMutexForInformer(r.getMutexKeyForPublicSVC(req))
+	// 	}
+	// }
+
+	r.getMutexForInformerStart(r.getMutexKeyForPublicSVC(req)).Do(func() {
+		r.Informer.Add(&informer.RequestWatch{
+			Req:                  req,
+			ResourceName:         es.Spec.Service,
+			ResourceNamespace:    es.Namespace,
+			GroupVersionResource: &values.ServiceGVR,
+			Handlers:             r.getPublicServiceChangeHandler(ctx, es, req),
+		})
+
+		r.Logger.Info("Public Service added to informer", zap.String("es", req.String()),
+			zap.String("public service", es.Spec.Service),
+		)
+	})
+
+	return nil
+}
+
+func (r *ElastiServiceReconciler) checkIfCRDIsDeleted(ctx context.Context, es *v1alpha1.ElastiService, req ctrl.Request) error {
+	// If the ElastiService is being deleted, we need to clean up the resources
+	if !es.ObjectMeta.DeletionTimestamp.IsZero() {
+		if controllerutil.ContainsFinalizer(es, v1alpha1.ElastiServiceFinalizer) {
+			// If CRD contains finalizer, we call the finaizer function and remove the finalizer post that
+			if err := r.finalizeCRD(ctx, es, req); err != nil {
+				r.Logger.Error("Failed to enable serve mode", zap.String("es", req.String()), zap.Error(err))
+				return err
+			}
+			controllerutil.RemoveFinalizer(es, v1alpha1.ElastiServiceFinalizer)
+			if err := r.Update(ctx, es); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
diff --git a/operator/internal/controller/opsInformer.go b/operator/internal/controller/opsInformer.go
index 3f2beb60..f994006e 100644
--- a/operator/internal/controller/opsInformer.go
+++ b/operator/internal/controller/opsInformer.go
@@ -13,6 +13,12 @@ import (
 	"truefoundry.io/elasti/api/v1alpha1"
 )
 
+const (
+	// Prefix is the name of the NamespacedName string for CRD
+	lockKeyPostfixForPublicSVC = "public-service"
+	lockKeyPostfixForTargetRef = "scale-target-ref"
+)
+
 func (r *ElastiServiceReconciler) getMutexForInformerStart(key string) *sync.Once {
 	l, _ := r.InformerStartLocks.LoadOrStore(key, &sync.Once{})
 	return l.(*sync.Once)
@@ -22,6 +28,14 @@ func (r *ElastiServiceReconciler) resetMutexForInformer(key string) {
 	r.InformerStartLocks.Delete(key)
 }
 
+func (r *ElastiServiceReconciler) getMutexKeyForPublicSVC(req ctrl.Request) string {
+	return req.String() + lockKeyPostfixForPublicSVC
+}
+
+func (r *ElastiServiceReconciler) getMutexKeyForTargetRef(req ctrl.Request) string {
+	return req.String() + lockKeyPostfixForTargetRef
+}
+
 func (r *ElastiServiceReconciler) getResolverChangeHandler(ctx context.Context, es *v1alpha1.ElastiService, req ctrl.Request) cache.ResourceEventHandlerFuncs {
 	return cache.ResourceEventHandlerFuncs{
 		AddFunc: func(obj interface{}) {
diff --git a/operator/internal/controller/opsModes.go b/operator/internal/controller/opsModes.go
index d49d180e..3b03f22e 100644
--- a/operator/internal/controller/opsModes.go
+++ b/operator/internal/controller/opsModes.go
@@ -2,7 +2,6 @@ package controller
 
 import (
 	"context"
-	"fmt"
 	"sync"
 
 	"github.com/truefoundry/elasti/pkg/values"
@@ -64,7 +63,7 @@ func (r *ElastiServiceReconciler) enableProxyMode(ctx context.Context, req ctrl.
 		return err
 	}
 
-	// Watch for changes in activator deployment, and update the endpointslice since we are in proxy mode
+	// Watch for changes in resolver deployment, and update the endpointslice since we are in proxy mode
 	r.Informer.AddDeploymentWatch(req, resolverDeploymentName, resolverNamespace, r.getResolverChangeHandler(ctx, es, req))
 
 	return nil
@@ -72,8 +71,8 @@ func (r *ElastiServiceReconciler) enableProxyMode(ctx context.Context, req ctrl.
 
 func (r *ElastiServiceReconciler) enableServeMode(ctx context.Context, req ctrl.Request, es *v1alpha1.ElastiService) error {
 	// Stop the watch on resolver deployment, since we are in serve mode
-	resolverInformerKey := fmt.Sprintf("%s/%s/%s", req.Name, resolverDeploymentName, resolverNamespace)
-	r.Informer.StopInformer(resolverInformerKey)
+	key := r.Informer.GetKey(resolverNamespace, req.Name, resolverDeploymentName, values.KindDeployments)
+	r.Informer.StopInformer(key)
 
 	targetNamespacedName := types.NamespacedName{
 		Name:      es.Spec.Service,
diff --git a/operator/internal/elastiServer/elastiServer.go b/operator/internal/elastiServer/elastiServer.go
index d819eeff..80ff89e5 100644
--- a/operator/internal/elastiServer/elastiServer.go
+++ b/operator/internal/elastiServer/elastiServer.go
@@ -6,9 +6,9 @@ import (
 	"io"
 	"net/http"
 
-	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 
+	"github.com/go-errors/errors"
 	"github.com/truefoundry/elasti/pkg/k8sHelper"
 	"github.com/truefoundry/elasti/pkg/messages"
 	"go.uber.org/zap"
@@ -30,13 +30,8 @@ type (
 )
 
 func NewServer(logger *zap.Logger, config *rest.Config) *Server {
-	// Get kubernetes client
-	kClient, err := kubernetes.NewForConfig(config)
-	if err != nil {
-		logger.Fatal("Error connecting with kubernetes", zap.Error(err))
-	}
 	// Get Ops client
-	k8sUtil := k8sHelper.NewOps(logger, kClient)
+	k8sUtil := k8sHelper.NewOps(logger, config)
 	return &Server{
 		logger:    logger.Named("elastiServer"),
 		k8sHelper: k8sUtil,
@@ -108,6 +103,7 @@ func (s *Server) scaleTargetForService(_ context.Context, serviceName, namespace
 	crd, found := crdDirectory.CRDDirectory.GetCRD(serviceName)
 	if !found {
 		s.logger.Error("Failed to get CRD details from directory")
+		return errors.New("Failed to get CRD details from directory")
 	}
 	if err := s.k8sHelper.ScaleTargetWhenAtZero(namespace, crd.Spec.ScaleTargetRef.Name, crd.Spec.ScaleTargetRef.Kind, crd.Spec.MinTargetReplicas); err != nil {
 		s.logger.Error("Failed to scale TargetRef", zap.Any("TargetRef", crd.Spec.ScaleTargetRef), zap.Error(err))
diff --git a/operator/internal/informer/informer.go b/operator/internal/informer/informer.go
index 66cd67a0..8aaaa49a 100644
--- a/operator/internal/informer/informer.go
+++ b/operator/internal/informer/informer.go
@@ -248,8 +248,17 @@ func (m *Manager) enableInformer(req *RequestWatch) {
 // CRDname.resourcerName.Namespace
 func (m *Manager) getKeyFromRequestWatch(req *RequestWatch) string {
 	return fmt.Sprintf("%s/%s/%s/%s",
-		strings.ToLower(req.ResourceNamespace),
-		strings.ToLower(req.Req.Name),
-		strings.ToLower(req.GroupVersionResource.Resource),
-		strings.ToLower(req.ResourceName))
+		strings.ToLower(req.ResourceNamespace),             // Namespace
+		strings.ToLower(req.Req.Name),                      // CRD Name
+		strings.ToLower(req.GroupVersionResource.Resource), // Resource Type
+		strings.ToLower(req.ResourceName))                  // Resource Name
+}
+
+// GetKey is to get the key for the informer map using namespace and resource name
+func (m *Manager) GetKey(namespace, crdName, resource, resourceName string) string {
+	return fmt.Sprintf("%s/%s/%s/%s",
+		strings.ToLower(namespace),    // Namespace
+		strings.ToLower(crdName),      // CRD Name
+		strings.ToLower(resource),     // Resource Type
+		strings.ToLower(resourceName)) // Resource Name
 }
diff --git a/pkg/k8sHelper/errors.go b/pkg/k8sHelper/errors.go
index 684f4e94..19e9e5d4 100644
--- a/pkg/k8sHelper/errors.go
+++ b/pkg/k8sHelper/errors.go
@@ -4,3 +4,5 @@ import "errors"
 
 var ErrNoPodFound = errors.New("no pod found")
 var ErrNoActivePodFound = errors.New("no active pod found")
+var ErrNoScaleTargetFound = errors.New("no scale target found")
+var ErrNoPublicServiceFound = errors.New("no public service found")
diff --git a/pkg/k8sHelper/ops.go b/pkg/k8sHelper/ops.go
index d30fd4df..d760b353 100644
--- a/pkg/k8sHelper/ops.go
+++ b/pkg/k8sHelper/ops.go
@@ -9,20 +9,32 @@ import (
 	"go.uber.org/zap"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/dynamic"
 	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
 )
 
 // Ops help you do various operations in your kubernetes cluster
 type Ops struct {
-	kClient *kubernetes.Clientset
-	logger  *zap.Logger
+	kClient        *kubernetes.Clientset
+	kDynamicClient *dynamic.DynamicClient
+	logger         *zap.Logger
 }
 
 // NewOps create a new instance for the K9s Operations
-func NewOps(logger *zap.Logger, kClient *kubernetes.Clientset) *Ops {
+func NewOps(logger *zap.Logger, config *rest.Config) *Ops {
+	kClient, err := kubernetes.NewForConfig(config)
+	if err != nil {
+		logger.Fatal("Error connecting with kubernetes", zap.Error(err))
+	}
+	kDynamicClient, err := dynamic.NewForConfig(config)
+	if err != nil {
+		logger.Fatal("Error connecting with kubernetes", zap.Error(err))
+	}
 	return &Ops{
-		logger:  logger.Named("k8sOps"),
-		kClient: kClient,
+		logger:         logger.Named("k8sOps"),
+		kClient:        kClient,
+		kDynamicClient: kDynamicClient,
 	}
 }
 
@@ -112,5 +124,17 @@ func (k *Ops) ScaleDeployment(ns, targetName string, replicas int32) error {
 
 func (k *Ops) ScaleArgoRollout(ns, targetName string, replicas int32) error {
 	k.logger.Debug("Scaling Rollout yet to be implimented", zap.String("rollout", targetName), zap.Int32("replicas", replicas))
+
+	rollout, err := k.kDynamicClient.Resource(values.RolloutGVR).Namespace(ns).Get(context.TODO(), targetName, metav1.GetOptions{})
+	if err != nil {
+		return err
+	}
+
+	currentReplicas := rollout.Object["spec"].(map[string]interface{})["replicas"]
+	if currentReplicas == 0 {
+		rollout.Object["spec"].(map[string]interface{})["replicas"] = replicas
+		_, err = k.kDynamicClient.Resource(values.RolloutGVR).Namespace(ns).Update(context.TODO(), rollout, metav1.UpdateOptions{})
+		return err
+	}
 	return nil
 }
diff --git a/pkg/values/values.go b/pkg/values/values.go
index 4d56c98c..ae3791af 100644
--- a/pkg/values/values.go
+++ b/pkg/values/values.go
@@ -1,5 +1,7 @@
 package values
 
+import "k8s.io/apimachinery/pkg/runtime/schema"
+
 const (
 	ArgoPhaseHealthy              = "Healthy"
 	DeploymentConditionStatusTrue = "True"
@@ -12,3 +14,17 @@ const (
 	ProxyMode = "proxy"
 	NullMode  = ""
 )
+
+var (
+	RolloutGVR = schema.GroupVersionResource{
+		Group:    "argoproj.io",
+		Version:  "v1alpha1",
+		Resource: "rollouts",
+	}
+
+	ServiceGVR = schema.GroupVersionResource{
+		Group:    "",
+		Version:  "v1",
+		Resource: "services",
+	}
+)
diff --git a/resolver/Dockerfile.cross b/resolver/Dockerfile.cross
new file mode 100644
index 00000000..ec40a78f
--- /dev/null
+++ b/resolver/Dockerfile.cross
@@ -0,0 +1,35 @@
+# Build the resolver bianry
+FROM --platform=${BUILDPLATFORM} golang:1.22  AS builder
+ARG TARGETOS
+ARG TARGETARCH
+
+COPY ../pkg ../pkg
+
+WORKDIR /workspace
+# Copy the Go Modules manifests
+COPY ./resolver/go.mod go.mod
+COPY ./resolver/go.sum go.sum
+
+# cache deps before building and copying source so that we don't need to re-download as much
+# and so that source changes don't invalidate our downloaded layer
+RUN go mod download
+
+# Copy the go source
+COPY ./resolver/ .
+
+# Build
+# the GOARCH has not a default value to allow the binary be built according to the host where the command
+# was called. For example, if we call make docker-build in a local env which has the Apple Silicon M1 SO
+# the docker BUILDPLATFORM arg will be linux/arm64 when for Apple x86 it will be linux/amd64. Therefore,
+# by leaving it empty we can ensure that the container and binary shipped on it will have the same platform.
+RUN CGO_ENABLED=0 GOOS=${TARGETOS:-linux} GOARCH=${TARGETARCH} go build -a -o resolver cmd/main.go
+
+
+FROM alpine:latest
+COPY --from=builder /workspace/resolver .
+EXPOSE 8080
+EXPOSE 8012
+EXPOSE 8013
+CMD ["./resolver"]
+
+ 
\ No newline at end of file
diff --git a/resolver/cmd/main.go b/resolver/cmd/main.go
index 7eefa864..caf2c58f 100644
--- a/resolver/cmd/main.go
+++ b/resolver/cmd/main.go
@@ -2,18 +2,18 @@ package main
 
 import (
 	"context"
-	"github.com/kelseyhightower/envconfig"
-	"github.com/truefoundry/elasti/pkg/k8sHelper"
-	"github.com/truefoundry/elasti/pkg/logger"
-	"go.uber.org/zap"
-	"k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/rest"
 	"log"
 	"net/http"
 	"time"
 	"truefoundry/resolver/internal/handler"
 	"truefoundry/resolver/internal/hostManager"
 	"truefoundry/resolver/internal/operator"
+
+	"github.com/kelseyhightower/envconfig"
+	"github.com/truefoundry/elasti/pkg/k8sHelper"
+	"github.com/truefoundry/elasti/pkg/logger"
+	"go.uber.org/zap"
+	"k8s.io/client-go/rest"
 )
 
 type config struct {
@@ -46,12 +46,8 @@ func main() {
 	if err != nil {
 		logger.Fatal("Error fetching cluster config", zap.Error(err))
 	}
-	kClient, err := kubernetes.NewForConfig(config)
-	if err != nil {
-		logger.Fatal("Error connecting with kubernetes", zap.Error(err))
-	}
 
-	k8sUtil := k8sHelper.NewOps(logger, kClient)
+	k8sUtil := k8sHelper.NewOps(logger, config)
 	operatorRPC := operator.NewOperatorClient(logger, operatorRetryDuration)
 	reqHostManager := hostManager.NewHostManager(logger, trafficReEnableDuration)
 	requestHandler := handler.NewHandler(ctx, logger, &handler.HandlerConfig{
diff --git a/resolver/config/clusterRole.yaml b/resolver/config/clusterRole.yaml
new file mode 100644
index 00000000..ed474b5c
--- /dev/null
+++ b/resolver/config/clusterRole.yaml
@@ -0,0 +1,11 @@
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: elasti-resolver-additional-access
+rules:
+- apiGroups: ["apps"]
+  resources: ["deployments"]
+  verbs: ["get", "list", "watch", "update", "patch"]
+- apiGroups: [""]
+  resources: ["services", "pods"]
+  verbs: ["get", "list", "watch", "update", "patch", "delete", "create"]
\ No newline at end of file
diff --git a/resolver/config/clusterRoleBinding.yaml b/resolver/config/clusterRoleBinding.yaml
new file mode 100644
index 00000000..9c4c0daf
--- /dev/null
+++ b/resolver/config/clusterRoleBinding.yaml
@@ -0,0 +1,15 @@
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  labels:
+    app.kubernetes.io/name: elasti-operator
+    app.kubernetes.io/managed-by: kustomize
+  name: elasti-resolver-additional-access-binding
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: elasti-resolver-additional-access
+subjects:
+- kind: ServiceAccount
+  name: default
+  namespace: elasti
\ No newline at end of file
diff --git a/resolver/config/kustomization.yaml b/resolver/config/kustomization.yaml
index a66f69d6..b1a3a661 100644
--- a/resolver/config/kustomization.yaml
+++ b/resolver/config/kustomization.yaml
@@ -15,8 +15,13 @@ namespace: elasti
 #    someName: someValue
 
 resources:
+- namespace.yaml
+# - serviceAccount.yaml
+- clusterRole.yaml
+- clusterRoleBinding.yaml
 - deployment.yaml
 - service.yaml
+
 # [WEBHOOK] To enable webhook, uncomment all the sections with [WEBHOOK] prefix including the one in
 # crd/kustomization.yaml
 #- ../webhook
diff --git a/resolver/config/serviceAccount.yaml b/resolver/config/serviceAccount.yaml
new file mode 100644
index 00000000..948a8e52
--- /dev/null
+++ b/resolver/config/serviceAccount.yaml
@@ -0,0 +1,8 @@
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  labels:
+    app.kubernetes.io/name: elasti-operator
+    app.kubernetes.io/managed-by: kustomize
+  name: elasti-resolver
+  namespace: elasti 
diff --git a/resolver/install.yaml b/resolver/install.yaml
deleted file mode 100644
index 47bc5ebc..00000000
--- a/resolver/install.yaml
+++ /dev/null
@@ -1,45 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  name: resolver-service
-  namespace: elasti
-spec:
-  ports:
-  - name: http-playground
-    port: 8012
-    protocol: TCP
-  selector:
-    app: elasti-resolver
-  type: LoadBalancer
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: elasti-resolver
-  namespace: elasti
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: elasti-resolver
-  template:
-    metadata:
-      labels:
-        app: elasti-resolver
-    spec:
-      containers:
-      - env:
-        - name: SYSTEM_NAMESPACE
-          value: elasti
-        image: ramantehlan/elasti-resolver:v1alpha1
-        imagePullPolicy: Always
-        name: playground
-        ports:
-        - containerPort: 8012
-        resources:
-          limits:
-            cpu: 750m
-            memory: 1Gi
-          requests:
-            cpu: 250m
-            memory: 500Mi