From 6ab17d72a6c3b1425d1d91609d9ac3d8a5778fa0 Mon Sep 17 00:00:00 2001 From: "itamar.marom" Date: Wed, 27 Dec 2023 17:56:31 +0200 Subject: [PATCH 1/3] (finalizers): refactor --- controllers/druid/druid_controller.go | 2 +- controllers/druid/finalizers.go | 112 ++++++++++++++++++++++++++ controllers/druid/handler.go | 90 ++------------------- controllers/druid/types.go | 1 - 4 files changed, 119 insertions(+), 86 deletions(-) create mode 100644 controllers/druid/finalizers.go diff --git a/controllers/druid/druid_controller.go b/controllers/druid/druid_controller.go index 6998090b..60e59d49 100644 --- a/controllers/druid/druid_controller.go +++ b/controllers/druid/druid_controller.go @@ -69,7 +69,7 @@ func (r *DruidReconciler) Reconcile(ctx context.Context, request reconcile.Reque return ctrl.Result{}, err } - // Intialize Emit Events + // Initialize Emit Events var emitEvent EventEmitter = EmitEventFuncs{r.Recorder} if err := deployDruidCluster(ctx, r.Client, instance, emitEvent); err != nil { diff --git a/controllers/druid/finalizers.go b/controllers/druid/finalizers.go new file mode 100644 index 00000000..f0d87764 --- /dev/null +++ b/controllers/druid/finalizers.go @@ -0,0 +1,112 @@ +package druid + +import ( + "context" + "fmt" + + "github.com/datainfrahq/druid-operator/apis/druid/v1alpha1" + appsv1 "k8s.io/api/apps/v1" + v1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" + "sigs.k8s.io/controller-runtime/pkg/client" +) + +const ( + deletePVCFinalizerName = "deletepvc.finalizers.druid.apache.org" +) + +var ( + defaultFinalizers []string +) + +func addFinalizers(ctx context.Context, sdk client.Client, m *v1alpha1.Druid, emitEvents EventEmitter) error { + desiredFinalizers := m.GetFinalizers() + additionFinalizers := defaultFinalizers + + if m.Spec.DisablePVCDeletionFinalizer == false { + additionFinalizers = append(additionFinalizers, deletePVCFinalizerName) + } + + for _, finalizer := range additionFinalizers { + if !ContainsString(desiredFinalizers, finalizer) { + desiredFinalizers = append(desiredFinalizers, finalizer) + } + } + + m.SetFinalizers(desiredFinalizers) + if _, err := writers.Update(ctx, sdk, m, m, emitEvents); err != nil { + return err + } + + return nil +} + +func executeFinalizers(ctx context.Context, sdk client.Client, m *v1alpha1.Druid, emitEvents EventEmitter) error { + if m.Spec.DisablePVCDeletionFinalizer == false { + if err := executePVCFinalizer(ctx, sdk, m, emitEvents); err != nil { + return err + } + } + return nil +} + +/* +executePVCFinalizer will execute a PVC deletion of all Druid's PVCs. +Flow: + 1. Get sts List and PVC List + 2. Range and Delete sts first and then delete pvc. PVC must be deleted after sts termination has been executed + else pvc finalizer shall block deletion since a pod/sts is referencing it. + 3. Once delete is executed we block program and return. +*/ +func executePVCFinalizer(ctx context.Context, sdk client.Client, m *v1alpha1.Druid, emitEvents EventEmitter) error { + if ContainsString(m.ObjectMeta.Finalizers, deletePVCFinalizerName) { + pvcLabels := map[string]string{ + "druid_cr": m.Name, + } + + pvcList, err := readers.List(ctx, sdk, m, pvcLabels, emitEvents, func() objectList { return &v1.PersistentVolumeClaimList{} }, func(listObj runtime.Object) []object { + items := listObj.(*v1.PersistentVolumeClaimList).Items + result := make([]object, len(items)) + for i := 0; i < len(items); i++ { + result[i] = &items[i] + } + return result + }) + if err != nil { + return err + } + + stsList, err := readers.List(ctx, sdk, m, makeLabelsForDruid(m.Name), emitEvents, func() objectList { return &appsv1.StatefulSetList{} }, func(listObj runtime.Object) []object { + items := listObj.(*appsv1.StatefulSetList).Items + result := make([]object, len(items)) + for i := 0; i < len(items); i++ { + result[i] = &items[i] + } + return result + }) + if err != nil { + return err + } + + msg := fmt.Sprintf("Trigerring finalizer for CR [%s] in namespace [%s]", m.Name, m.Namespace) + // sendEvent(sdk, m, v1.EventTypeNormal, DruidFinalizer, msg) + logger.Info(msg) + if err := deleteSTSAndPVC(ctx, sdk, m, stsList, pvcList, emitEvents); err != nil { + return err + } else { + msg := fmt.Sprintf("Finalizer success for CR [%s] in namespace [%s]", m.Name, m.Namespace) + // sendEvent(sdk, m, v1.EventTypeNormal, DruidFinalizerSuccess, msg) + logger.Info(msg) + } + + // remove our finalizer from the list and update it. + m.ObjectMeta.Finalizers = RemoveString(m.ObjectMeta.Finalizers, deletePVCFinalizerName) + + _, err = writers.Update(ctx, sdk, m, m, emitEvents) + if err != nil { + return err + } + + } + return nil +} diff --git a/controllers/druid/handler.go b/controllers/druid/handler.go index c19099f3..7fe9b535 100644 --- a/controllers/druid/handler.go +++ b/controllers/druid/handler.go @@ -80,35 +80,12 @@ func deployDruidCluster(ctx context.Context, sdk client.Client, m *v1alpha1.Drui return err } - /* - Default Behavior: Finalizer shall be always executed resulting in deletion of pvc post deletion of Druid CR - When the object (druid CR) has for deletion time stamp set, execute the finalizer. - Finalizer shall execute the following flow : - 1. Get sts List and PVC List - 2. Range and Delete sts first and then delete pvc. PVC must be deleted after sts termination has been executed - else pvc finalizer shall block deletion since a pod/sts is referencing it. - 3. Once delete is executed we block program and return. - */ - - if m.Spec.DisablePVCDeletionFinalizer == false { - md := m.GetDeletionTimestamp() != nil - if md { - return executeFinalizers(ctx, sdk, m, emitEvents) - } - /* - If finalizer isn't present add it to object meta. - In case cr is already deleted do not call this function - */ - cr := checkIfCRExists(ctx, sdk, m, emitEvents) - if cr { - if !ContainsString(m.ObjectMeta.Finalizers, finalizerName) { - m.SetFinalizers(append(m.GetFinalizers(), finalizerName)) - _, err := writers.Update(context.Background(), sdk, m, m, emitEvents) - if err != nil { - return err - } - } - } + if m.GetDeletionTimestamp() != nil { + return executeFinalizers(ctx, sdk, m, emitEvents) + } + + if err := addFinalizers(ctx, sdk, m, emitEvents); err != nil { + return err } for _, elem := range allNodeSpecs { @@ -574,61 +551,6 @@ func setPVCLabels(ctx context.Context, sdk client.Client, drd *v1alpha1.Druid, e return nil } -func executeFinalizers(ctx context.Context, sdk client.Client, m *v1alpha1.Druid, emitEvents EventEmitter) error { - - if ContainsString(m.ObjectMeta.Finalizers, finalizerName) { - pvcLabels := map[string]string{ - "druid_cr": m.Name, - } - - pvcList, err := readers.List(ctx, sdk, m, pvcLabels, emitEvents, func() objectList { return &v1.PersistentVolumeClaimList{} }, func(listObj runtime.Object) []object { - items := listObj.(*v1.PersistentVolumeClaimList).Items - result := make([]object, len(items)) - for i := 0; i < len(items); i++ { - result[i] = &items[i] - } - return result - }) - if err != nil { - return err - } - - stsList, err := readers.List(ctx, sdk, m, makeLabelsForDruid(m.Name), emitEvents, func() objectList { return &appsv1.StatefulSetList{} }, func(listObj runtime.Object) []object { - items := listObj.(*appsv1.StatefulSetList).Items - result := make([]object, len(items)) - for i := 0; i < len(items); i++ { - result[i] = &items[i] - } - return result - }) - if err != nil { - return err - } - - msg := fmt.Sprintf("Trigerring finalizer for CR [%s] in namespace [%s]", m.Name, m.Namespace) - // sendEvent(sdk, m, v1.EventTypeNormal, DruidFinalizer, msg) - logger.Info(msg) - if err := deleteSTSAndPVC(ctx, sdk, m, stsList, pvcList, emitEvents); err != nil { - return err - } else { - msg := fmt.Sprintf("Finalizer success for CR [%s] in namespace [%s]", m.Name, m.Namespace) - // sendEvent(sdk, m, v1.EventTypeNormal, DruidFinalizerSuccess, msg) - logger.Info(msg) - } - - // remove our finalizer from the list and update it. - m.ObjectMeta.Finalizers = RemoveString(m.ObjectMeta.Finalizers, finalizerName) - - _, err = writers.Update(ctx, sdk, m, m, emitEvents) - if err != nil { - return err - } - - } - return nil - -} - func execCheckCrashStatus(ctx context.Context, sdk client.Client, nodeSpec *v1alpha1.DruidNodeSpec, m *v1alpha1.Druid, event EventEmitter) { if m.Spec.ForceDeleteStsPodOnError == false { return diff --git a/controllers/druid/types.go b/controllers/druid/types.go index 58acec6b..a19fe3a0 100644 --- a/controllers/druid/types.go +++ b/controllers/druid/types.go @@ -1,7 +1,6 @@ package druid const ( - finalizerName = "deletepvc.finalizers.druid.apache.org" ignoredAnnotation = "druid.apache.org/ignored" broker = "broker" From a98a90a398f14e7d23af48fcd00aa558e5d9e887 Mon Sep 17 00:00:00 2001 From: "itamar.marom" Date: Wed, 27 Dec 2023 18:54:21 +0200 Subject: [PATCH 2/3] (finalizers): added tests --- controllers/druid/finalizers.go | 8 +- controllers/druid/finalizers_test.go | 141 +++++++++++++++++++++ controllers/druid/handler.go | 2 +- controllers/druid/suite_test.go | 3 + controllers/druid/testdata/finalizers.yaml | 70 ++++++++++ 5 files changed, 220 insertions(+), 4 deletions(-) create mode 100644 controllers/druid/finalizers_test.go create mode 100644 controllers/druid/testdata/finalizers.yaml diff --git a/controllers/druid/finalizers.go b/controllers/druid/finalizers.go index f0d87764..350d98b7 100644 --- a/controllers/druid/finalizers.go +++ b/controllers/druid/finalizers.go @@ -19,11 +19,12 @@ var ( defaultFinalizers []string ) -func addFinalizers(ctx context.Context, sdk client.Client, m *v1alpha1.Druid, emitEvents EventEmitter) error { +func updateFinalizers(ctx context.Context, sdk client.Client, m *v1alpha1.Druid, emitEvents EventEmitter) error { desiredFinalizers := m.GetFinalizers() additionFinalizers := defaultFinalizers - if m.Spec.DisablePVCDeletionFinalizer == false { + desiredFinalizers = RemoveString(desiredFinalizers, deletePVCFinalizerName) + if !m.Spec.DisablePVCDeletionFinalizer { additionFinalizers = append(additionFinalizers, deletePVCFinalizerName) } @@ -34,7 +35,8 @@ func addFinalizers(ctx context.Context, sdk client.Client, m *v1alpha1.Druid, em } m.SetFinalizers(desiredFinalizers) - if _, err := writers.Update(ctx, sdk, m, m, emitEvents); err != nil { + _, err := writers.Update(ctx, sdk, m, m, emitEvents) + if err != nil { return err } diff --git a/controllers/druid/finalizers_test.go b/controllers/druid/finalizers_test.go new file mode 100644 index 00000000..b63323ec --- /dev/null +++ b/controllers/druid/finalizers_test.go @@ -0,0 +1,141 @@ +package druid + +import ( + "time" + + druidv1alpha1 "github.com/datainfrahq/druid-operator/apis/druid/v1alpha1" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + "k8s.io/apimachinery/pkg/types" +) + +// +kubebuilder:docs-gen:collapse=Imports + +/* +finalizers_test +*/ +var _ = Describe("Test finalizers logic", func() { + const ( + filePath = "testdata/finalizers.yaml" + timeout = time.Second * 45 + interval = time.Millisecond * 250 + ) + + var ( + druid = &druidv1alpha1.Druid{} + ) + + Context("When creating a druid cluster", func() { + It("Should create the druid object", func() { + By("Creating a new druid") + druidCR, err := readDruidClusterSpecFromFile(filePath) + Expect(err).Should(BeNil()) + Expect(k8sClient.Create(ctx, druidCR)).To(Succeed()) + + By("Getting a newly created druid") + Eventually(func() bool { + err := k8sClient.Get(ctx, types.NamespacedName{Name: druidCR.Name, Namespace: druidCR.Namespace}, druid) + return err == nil + }, timeout, interval).Should(BeTrue()) + }) + It("Should add the delete PVC finalizer", func() { + By("Waiting for the finalizer to be created") + Eventually(func() bool { + err := k8sClient.Get(ctx, types.NamespacedName{Name: druid.Name, Namespace: druid.Namespace}, druid) + if err == nil && ContainsString(druid.GetFinalizers(), deletePVCFinalizerName) { + return true + } + return false + }, timeout, interval).Should(BeTrue()) + }) + It("Should delete druid successfully", func() { + By("Waiting for the druid cluster to be deleted") + Expect(k8sClient.Delete(ctx, druid)).To(Succeed()) + Eventually(func() bool { + err := k8sClient.Get(ctx, types.NamespacedName{Name: druid.Name, Namespace: druid.Namespace}, druid) + return err != nil + }, timeout, interval).Should(BeTrue()) + }) + }) + + Context("When creating a druid cluster with disablePVCDeletion", func() { + It("Should create the druid object", func() { + By("Creating a new druid") + druidCR, err := readDruidClusterSpecFromFile(filePath) + druidCR.Spec.DisablePVCDeletionFinalizer = true + Expect(err).Should(BeNil()) + Expect(k8sClient.Create(ctx, druidCR)).To(Succeed()) + + By("Getting a newly created druid") + Eventually(func() bool { + err := k8sClient.Get(ctx, types.NamespacedName{Name: druidCR.Name, Namespace: druidCR.Namespace}, druid) + return err == nil + }, timeout, interval).Should(BeTrue()) + }) + It("Should not add the delete PVC finalizer", func() { + By("Call for the update finalizer function") + Expect(updateFinalizers(ctx, k8sClient, druid, emitEvent)).Should(BeNil()) + + By("Getting a updated druid") + Eventually(func() bool { + err := k8sClient.Get(ctx, types.NamespacedName{Name: druid.Name, Namespace: druid.Namespace}, druid) + return err == nil + }, timeout, interval).Should(BeTrue()) + + By("Checking the absence of the finalizer") + Expect(ContainsString(druid.GetFinalizers(), deletePVCFinalizerName)).Should(BeFalse()) + }) + It("Should delete druid successfully", func() { + Expect(k8sClient.Delete(ctx, druid)).To(Succeed()) + Eventually(func() bool { + err := k8sClient.Get(ctx, types.NamespacedName{Name: druid.Name, Namespace: druid.Namespace}, druid) + return err != nil + }, timeout, interval).Should(BeTrue()) + }) + }) + + Context("When creating a druid cluster", func() { + It("Should create the druid object", func() { + By("Creating a new druid") + druidCR, err := readDruidClusterSpecFromFile(filePath) + Expect(err).Should(BeNil()) + Expect(k8sClient.Create(ctx, druidCR)).To(Succeed()) + + By("Getting the CR") + Eventually(func() bool { + err := k8sClient.Get(ctx, types.NamespacedName{Name: druidCR.Name, Namespace: druidCR.Namespace}, druid) + return err == nil + }, timeout, interval).Should(BeTrue()) + }) + It("Should add the delete PVC finalizer", func() { + By("Waiting for the finalizer to be created") + Eventually(func() bool { + err := k8sClient.Get(ctx, types.NamespacedName{Name: druid.Name, Namespace: druid.Namespace}, druid) + if err == nil && ContainsString(druid.GetFinalizers(), deletePVCFinalizerName) { + return true + } + return false + }, timeout, interval).Should(BeTrue()) + }) + It("Should remove the delete PVC finalizer", func() { + By("Disabling the deletePVC finalizer") + druid.Spec.DisablePVCDeletionFinalizer = true + Expect(k8sClient.Update(ctx, druid)).To(BeNil()) + By("Waiting for the finalizer to be deleted") + Eventually(func() bool { + err := k8sClient.Get(ctx, types.NamespacedName{Name: druid.Name, Namespace: druid.Namespace}, druid) + if err == nil && !ContainsString(druid.GetFinalizers(), deletePVCFinalizerName) { + return true + } + return false + }, timeout, interval).Should(BeTrue()) + }) + It("Should delete druid successfully", func() { + Expect(k8sClient.Delete(ctx, druid)).To(Succeed()) + Eventually(func() bool { + err := k8sClient.Get(ctx, types.NamespacedName{Name: druid.Name, Namespace: druid.Namespace}, druid) + return err != nil + }, timeout, interval).Should(BeTrue()) + }) + }) +}) diff --git a/controllers/druid/handler.go b/controllers/druid/handler.go index 7fe9b535..1eaae375 100644 --- a/controllers/druid/handler.go +++ b/controllers/druid/handler.go @@ -84,7 +84,7 @@ func deployDruidCluster(ctx context.Context, sdk client.Client, m *v1alpha1.Drui return executeFinalizers(ctx, sdk, m, emitEvents) } - if err := addFinalizers(ctx, sdk, m, emitEvents); err != nil { + if err := updateFinalizers(ctx, sdk, m, emitEvents); err != nil { return err } diff --git a/controllers/druid/suite_test.go b/controllers/druid/suite_test.go index 0dbb726a..360d3acd 100644 --- a/controllers/druid/suite_test.go +++ b/controllers/druid/suite_test.go @@ -34,6 +34,7 @@ var ( testEnv *envtest.Environment ctx context.Context cancel context.CancelFunc + emitEvent EventEmitter ) func TestAPIs(t *testing.T) { @@ -93,6 +94,8 @@ var _ = BeforeSuite(func() { }).SetupWithManager(k8sManager) Expect(err).ToNot(HaveOccurred()) + emitEvent = EmitEventFuncs{k8sManager.GetEventRecorderFor("druid-operator")} + go func() { defer GinkgoRecover() err = k8sManager.Start(ctx) diff --git a/controllers/druid/testdata/finalizers.yaml b/controllers/druid/testdata/finalizers.yaml new file mode 100644 index 00000000..f8d614fa --- /dev/null +++ b/controllers/druid/testdata/finalizers.yaml @@ -0,0 +1,70 @@ +apiVersion: druid.apache.org/v1alpha1 +kind: Druid +metadata: + name: finalizers + namespace: default +spec: + image: apache/druid:25.0.0 + startScript: /druid.sh + rollingDeploy: false + securityContext: + fsGroup: 1000 + runAsUser: 1000 + runAsGroup: 1000 + services: + - spec: + type: ClusterIP + commonConfigMountPath: "/opt/druid/conf/druid/cluster/_common" + jvm.options: |- + -server + -XX:MaxDirectMemorySize=10240g + -Duser.timezone=UTC + -Dfile.encoding=UTF-8 + -Djava.io.tmpdir=/druid/data + common.runtime.properties: |- + # Metadata Store + druid.metadata.storage.type=derby + druid.metadata.storage.connector.connectURI=jdbc:derby://localhost:1527/druid/data/derbydb/metadata.db;create=true + druid.metadata.storage.connector.host=localhost + druid.metadata.storage.connector.port=1527 + druid.metadata.storage.connector.createTables=true + + # Deep Storage + druid.storage.type=local + druid.storage.storageDirectory=/druid/deepstorage + + # Service discovery + druid.selectors.indexing.serviceName=druid/overlord + druid.selectors.coordinator.serviceName=druid/coordinator + nodes: + brokers: + nodeType: "broker" + kind: "Deployment" + druid.port: 8088 + nodeConfigMountPath: "/opt/druid/conf/druid/cluster/query/broker" + replicas: 1 + runtime.properties: |- + druid.service=druid/broker + additionalContainer: + - command: + - /bin/sh echo hello + containerName: node-level + image: hello-world + coordinators: + nodeType: "coordinator" + druid.port: 8080 + nodeConfigMountPath: "/opt/druid/conf/druid/cluster/master/coordinator-overlord" + replicas: 1 + runtime.properties: |- + druid.service=druid/coordinator + druid.coordinator.asOverlord.enabled=true + druid.coordinator.asOverlord.overlordService=druid/overlord + historicals: + nodeType: "historical" + druid.port: 8080 + nodeConfigMountPath: "/opt/druid/conf/druid/cluster/data/historical" + replicas: 1 + runtime.properties: |- + druid.service=druid/historical + druid.segmentCache.locations=[{\"path\":\"/druid/data/segments\",\"maxSize\":10737418240}] + druid.server.maxSize=10737418240 From b51247e9b60953030aab104162d7949ad3787d1c Mon Sep 17 00:00:00 2001 From: "itamar.marom" Date: Tue, 2 Jan 2024 14:30:27 +0200 Subject: [PATCH 3/3] (finalizers): convert finalizer logs to events --- controllers/druid/finalizers.go | 32 +++++++++++++++++--------------- controllers/druid/interface.go | 4 ++++ 2 files changed, 21 insertions(+), 15 deletions(-) diff --git a/controllers/druid/finalizers.go b/controllers/druid/finalizers.go index 350d98b7..b963fb23 100644 --- a/controllers/druid/finalizers.go +++ b/controllers/druid/finalizers.go @@ -60,13 +60,13 @@ Flow: else pvc finalizer shall block deletion since a pod/sts is referencing it. 3. Once delete is executed we block program and return. */ -func executePVCFinalizer(ctx context.Context, sdk client.Client, m *v1alpha1.Druid, emitEvents EventEmitter) error { - if ContainsString(m.ObjectMeta.Finalizers, deletePVCFinalizerName) { +func executePVCFinalizer(ctx context.Context, sdk client.Client, druid *v1alpha1.Druid, eventEmitter EventEmitter) error { + if ContainsString(druid.ObjectMeta.Finalizers, deletePVCFinalizerName) { pvcLabels := map[string]string{ - "druid_cr": m.Name, + "druid_cr": druid.Name, } - pvcList, err := readers.List(ctx, sdk, m, pvcLabels, emitEvents, func() objectList { return &v1.PersistentVolumeClaimList{} }, func(listObj runtime.Object) []object { + pvcList, err := readers.List(ctx, sdk, druid, pvcLabels, eventEmitter, func() objectList { return &v1.PersistentVolumeClaimList{} }, func(listObj runtime.Object) []object { items := listObj.(*v1.PersistentVolumeClaimList).Items result := make([]object, len(items)) for i := 0; i < len(items); i++ { @@ -78,7 +78,7 @@ func executePVCFinalizer(ctx context.Context, sdk client.Client, m *v1alpha1.Dru return err } - stsList, err := readers.List(ctx, sdk, m, makeLabelsForDruid(m.Name), emitEvents, func() objectList { return &appsv1.StatefulSetList{} }, func(listObj runtime.Object) []object { + stsList, err := readers.List(ctx, sdk, druid, makeLabelsForDruid(druid.Name), eventEmitter, func() objectList { return &appsv1.StatefulSetList{} }, func(listObj runtime.Object) []object { items := listObj.(*appsv1.StatefulSetList).Items result := make([]object, len(items)) for i := 0; i < len(items); i++ { @@ -90,21 +90,23 @@ func executePVCFinalizer(ctx context.Context, sdk client.Client, m *v1alpha1.Dru return err } - msg := fmt.Sprintf("Trigerring finalizer for CR [%s] in namespace [%s]", m.Name, m.Namespace) - // sendEvent(sdk, m, v1.EventTypeNormal, DruidFinalizer, msg) - logger.Info(msg) - if err := deleteSTSAndPVC(ctx, sdk, m, stsList, pvcList, emitEvents); err != nil { + eventEmitter.EmitEventGeneric(druid, string(druidFinalizerTriggered), + fmt.Sprintf("Trigerring finalizer [%s] for CR [%s] in namespace [%s]", deletePVCFinalizerName, druid.Name, druid.Namespace), nil) + + if err = deleteSTSAndPVC(ctx, sdk, druid, stsList, pvcList, eventEmitter); err != nil { + eventEmitter.EmitEventGeneric(druid, string(druidFinalizerFailed), + fmt.Sprintf("Finalizer [%s] failed for CR [%s] in namespace [%s]", deletePVCFinalizerName, druid.Name, druid.Namespace), err) + return err - } else { - msg := fmt.Sprintf("Finalizer success for CR [%s] in namespace [%s]", m.Name, m.Namespace) - // sendEvent(sdk, m, v1.EventTypeNormal, DruidFinalizerSuccess, msg) - logger.Info(msg) } + eventEmitter.EmitEventGeneric(druid, string(druidFinalizerSuccess), + fmt.Sprintf("Finalizer [%s] success for CR [%s] in namespace [%s]", deletePVCFinalizerName, druid.Name, druid.Namespace), nil) + // remove our finalizer from the list and update it. - m.ObjectMeta.Finalizers = RemoveString(m.ObjectMeta.Finalizers, deletePVCFinalizerName) + druid.ObjectMeta.Finalizers = RemoveString(druid.ObjectMeta.Finalizers, deletePVCFinalizerName) - _, err = writers.Update(ctx, sdk, m, m, emitEvents) + _, err = writers.Update(ctx, sdk, druid, druid, eventEmitter) if err != nil { return err } diff --git a/controllers/druid/interface.go b/controllers/druid/interface.go index 3d9025e3..bf349ada 100644 --- a/controllers/druid/interface.go +++ b/controllers/druid/interface.go @@ -38,6 +38,10 @@ const ( druidNodePatchFail druidEventReason = "DruidOperatorPatchFail" druidNodePatchSucess druidEventReason = "DruidOperatorPatchSuccess" druidObjectListFail druidEventReason = "DruidOperatorListFail" + + druidFinalizerTriggered druidEventReason = "DruidOperatorFinalizerTriggered" + druidFinalizerFailed druidEventReason = "DruidFinalizerFailed" + druidFinalizerSuccess druidEventReason = "DruidFinalizerSuccess" ) // Reader Interface