OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
fix: cr deletion (#1656)
ming3132a1cfc955
diff --git a/kubernetes/operator/internal/controller/deletion_handler.go b/kubernetes/operator/internal/controller/deletion_handler.gonew file mode 100644index 000000000..cecf88327--- /dev/null+++ b/kubernetes/operator/internal/controller/deletion_handler.go@@ -0,0 +1,445 @@+package controller++import (+ "context"+ "fmt"++ appsv1 "k8s.io/api/apps/v1"+ autoscalingv2 "k8s.io/api/autoscaling/v2"+ corev1 "k8s.io/api/core/v1"+ networkingv1 "k8s.io/api/networking/v1"+ "k8s.io/apimachinery/pkg/api/errors"+ "sigs.k8s.io/controller-runtime/pkg/client"+ "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"+ "sigs.k8s.io/controller-runtime/pkg/log"++ openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+)++func (r *OpenRAGReconciler) handleDeletion(ctx context.Context, o *openragv1alpha1.OpenRAG) error {+ logger := log.FromContext(ctx)+ logger.Info("handleDeletion called", "name", o.Name, "namespace", o.Namespace)++ hasFinalizer := controllerutil.ContainsFinalizer(o, finalizer)+ logger.Info("checking for finalizer", "finalizer", finalizer, "hasFinalizer", hasFinalizer, "allFinalizers", o.Finalizers)++ if !hasFinalizer {+ logger.Info("CR has no finalizer - nothing to clean up, returning")+ return nil+ }++ logger.Info("CR has finalizer - proceeding with cleanup")++ targetNS := targetNamespace(o)+ logger.Info("starting secret cleanup", "targetNamespace", targetNS)++ // Remove finalizers from .env secrets and delete them+ for _, envSecretName := range []string{resourceName("be-env"), resourceName("lf-env")} {+ logger.Info("processing .env secret", "name", envSecretName, "namespace", targetNS)+ envSecret := &corev1.Secret{}+ err := r.Get(ctx, client.ObjectKey{Name: envSecretName, Namespace: targetNS}, envSecret)+ if err == nil {+ logger.Info("found .env secret", "name", envSecretName, "finalizers", envSecret.Finalizers)+ // Remove finalizer first+ if controllerutil.ContainsFinalizer(envSecret, envSecretFinalizer) {+ logger.Info("removing finalizer from .env secret", "name", envSecretName, "finalizer", envSecretFinalizer)+ controllerutil.RemoveFinalizer(envSecret, envSecretFinalizer)+ if err := r.Update(ctx, envSecret); err != nil {+ logger.Error(err, "failed to remove finalizer from env secret", "name", envSecretName)+ return fmt.Errorf("failed to remove finalizer from env secret %s: %w", envSecretName, err)+ }+ logger.Info("successfully removed finalizer from .env secret", "name", envSecretName)+ } else {+ logger.Info(".env secret has no finalizer to remove", "name", envSecretName)+ }++ // Only explicitly delete secrets in cross-namespace case (owner refs don't work across namespaces)+ // In same namespace, owner references will automatically delete the secret when CR is deleted+ if targetNS != o.Namespace {+ logger.Info("deleting .env secret (cross-namespace deployment)", "name", envSecretName)+ if err := r.Delete(ctx, envSecret); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete env secret", "name", envSecretName)+ return fmt.Errorf("failed to delete env secret %s: %w", envSecretName, err)+ }+ logger.Info("successfully deleted .env secret", "name", envSecretName)+ } else {+ logger.Info(".env secret will be automatically deleted by Kubernetes garbage collection via owner reference", "name", envSecretName)+ }+ } else if !errors.IsNotFound(err) {+ logger.Error(err, "failed to get env secret", "name", envSecretName)+ return fmt.Errorf("failed to get env secret %s: %w", envSecretName, err)+ } else {+ logger.Info(".env secret not found - already deleted or never created", "name", envSecretName)+ }+ }++ // Remove finalizers from user-provided secrets so they can be deleted+ userSecretRefs := collectProtectedSecrets(o)+ for _, secretRef := range userSecretRefs {+ userSecret := &corev1.Secret{}+ err := r.Get(ctx, client.ObjectKey{Name: secretRef.Name, Namespace: targetNS}, userSecret)+ if err == nil {+ if controllerutil.ContainsFinalizer(userSecret, userSecretFinalizer) {+ controllerutil.RemoveFinalizer(userSecret, userSecretFinalizer)+ if err := r.Update(ctx, userSecret); err != nil {+ return fmt.Errorf("failed to remove finalizer from user secret %s: %w", secretRef.Name, err)+ }+ logger.Info("removed finalizer from user-supplied secret", "secret", secretRef.Name, "namespace", targetNS, "finalizer", userSecretFinalizer)+ }+ } else if !errors.IsNotFound(err) {+ return fmt.Errorf("failed to get user secret %s: %w", secretRef.Name, err)+ }+ }++ // Remove finalizers from auto-generated default secrets and delete them+ // Use DNS-compliant names (lowercase, hyphens instead of underscores)+ // These names must match getOrGenerateSecret() logic: o.Name + "-" + strings.ToLower(strings.ReplaceAll(envKeyName, "_", "-")) + "-default"+ defaultSecretNames := []string{+ o.Name + "-openrag-encryption-key-default", // OPENRAG_ENCRYPTION_KEY+ o.Name + "-jwt-signing-key-default", // JWT_SIGNING_KEY (not jwt-private-key!)+ o.Name + "-langflow-secret-key-default", // LANGFLOW_SECRET_KEY+ }+ logger.Info("processing default secrets", "count", len(defaultSecretNames))+ for _, secretName := range defaultSecretNames {+ logger.Info("processing default secret", "name", secretName, "namespace", targetNS)+ defaultSecret := &corev1.Secret{}+ err := r.Get(ctx, client.ObjectKey{Name: secretName, Namespace: targetNS}, defaultSecret)+ if err == nil {+ logger.Info("found default secret", "name", secretName, "finalizers", defaultSecret.Finalizers)+ // Remove finalizer first+ if controllerutil.ContainsFinalizer(defaultSecret, userSecretFinalizer) {+ logger.Info("removing finalizer from default secret", "name", secretName, "finalizer", userSecretFinalizer)+ controllerutil.RemoveFinalizer(defaultSecret, userSecretFinalizer)+ if err := r.Update(ctx, defaultSecret); err != nil {+ logger.Error(err, "failed to remove finalizer from default secret", "name", secretName)+ return fmt.Errorf("failed to remove finalizer from default secret %s: %w", secretName, err)+ }+ logger.Info("successfully removed finalizer from default secret", "name", secretName)+ } else {+ logger.Info("default secret has no finalizer to remove", "name", secretName)+ }++ // Only explicitly delete secrets in cross-namespace case (owner refs don't work across namespaces)+ // In same namespace, owner references will automatically delete the secret when CR is deleted+ if targetNS != o.Namespace {+ logger.Info("deleting default secret (cross-namespace deployment)", "name", secretName)+ if err := r.Delete(ctx, defaultSecret); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete default secret", "name", secretName)+ return fmt.Errorf("failed to delete default secret %s: %w", secretName, err)+ }+ logger.Info("successfully deleted default secret", "name", secretName)+ } else {+ logger.Info("default secret will be automatically deleted by Kubernetes garbage collection via owner reference", "name", secretName)+ }+ } else if !errors.IsNotFound(err) {+ logger.Error(err, "failed to get default secret", "name", secretName)+ return fmt.Errorf("failed to get default secret %s: %w", secretName, err)+ } else {+ logger.Info("default secret not found - already deleted or never created", "name", secretName)+ }+ }++ // If targetNamespace is different from CR namespace, we need to clean up resources+ // We can only delete the namespace if WE created it (has managedByLabel)+ // Otherwise, we must delete resources individually+ if targetNS != o.Namespace {+ ns := &corev1.Namespace{}+ err := r.Get(ctx, client.ObjectKey{Name: targetNS}, ns)+ if err != nil && !errors.IsNotFound(err) {+ return err+ }++ // Check if we created this namespace+ if err == nil && ns.Labels[managedByLabel] == o.Name {+ // We created it, safe to delete the entire namespace+ if err := r.Delete(ctx, ns); err != nil && !errors.IsNotFound(err) {+ return err+ }+ } else {+ // Namespace exists but we didn't create it (user-provided)+ // Must delete resources individually to avoid orphans+ if err := r.deleteResources(ctx, o, targetNS); err != nil {+ return fmt.Errorf("failed to delete resources in namespace %s: %w", targetNS, err)+ }+ }+ }+ // If same namespace, owner references handle cleanup automatically++ // remove the CR finalizer+ controllerutil.RemoveFinalizer(o, finalizer)+ return r.Update(ctx, o)+}++// deleteResources explicitly deletes all resources created by the operator in the target namespace+// This is necessary when deploying to an existing namespace that we don't manage+func (r *OpenRAGReconciler) deleteResources(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {+ logger := log.FromContext(ctx)++ // Delete .env secrets with finalizers first+ for _, envSecretName := range []string{resourceName("be-env"), resourceName("lf-env")} {+ envSecret := &corev1.Secret{}+ err := r.Get(ctx, client.ObjectKey{Name: envSecretName, Namespace: targetNS}, envSecret)+ if err == nil {+ // Remove finalizer first+ if controllerutil.ContainsFinalizer(envSecret, envSecretFinalizer) {+ controllerutil.RemoveFinalizer(envSecret, envSecretFinalizer)+ if err := r.Update(ctx, envSecret); err != nil {+ logger.Error(err, "failed to remove finalizer from env secret", "name", envSecretName)+ } else {+ logger.Info("Removed finalizer from .env secret", "name", envSecretName, "finalizer", envSecretFinalizer)+ }+ }+ // Then delete the secret+ if err := r.Delete(ctx, envSecret); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete env secret", "name", envSecretName)+ } else {+ logger.Info("Deleted .env secret", "name", envSecretName)+ }+ }+ }++ // Delete auto-generated default secrets with finalizers+ // These names must match getOrGenerateSecret() logic: o.Name + "-" + strings.ToLower(strings.ReplaceAll(envKeyName, "_", "-")) + "-default"+ defaultSecretNames := []string{+ o.Name + "-openrag-encryption-key-default", // OPENRAG_ENCRYPTION_KEY+ o.Name + "-jwt-signing-key-default", // JWT_SIGNING_KEY (not jwt-private-key!)+ o.Name + "-langflow-secret-key-default", // LANGFLOW_SECRET_KEY+ }+ for _, secretName := range defaultSecretNames {+ defaultSecret := &corev1.Secret{}+ err := r.Get(ctx, client.ObjectKey{Name: secretName, Namespace: targetNS}, defaultSecret)+ if err == nil {+ // Remove finalizer first+ if controllerutil.ContainsFinalizer(defaultSecret, userSecretFinalizer) {+ controllerutil.RemoveFinalizer(defaultSecret, userSecretFinalizer)+ if err := r.Update(ctx, defaultSecret); err != nil {+ logger.Error(err, "failed to remove finalizer from default secret", "name", secretName)+ } else {+ logger.Info("Removed finalizer from default secret", "name", secretName, "finalizer", userSecretFinalizer)+ }+ }+ // Then delete the secret+ if err := r.Delete(ctx, defaultSecret); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete default secret", "name", secretName)+ } else {+ logger.Info("Deleted default secret", "name", secretName)+ }+ }+ }++ // Remove finalizers from user-supplied secrets (but don't delete them)+ userSecretRefs := collectProtectedSecrets(o)+ for _, secretRef := range userSecretRefs {+ userSecret := &corev1.Secret{}+ err := r.Get(ctx, client.ObjectKey{Name: secretRef.Name, Namespace: targetNS}, userSecret)+ if err == nil {+ if controllerutil.ContainsFinalizer(userSecret, userSecretFinalizer) {+ controllerutil.RemoveFinalizer(userSecret, userSecretFinalizer)+ if err := r.Update(ctx, userSecret); err != nil {+ logger.Error(err, "failed to remove finalizer from user secret", "name", secretRef.Name)+ } else {+ logger.Info("Removed finalizer from user-supplied secret", "secret", secretRef.Name, "finalizer", userSecretFinalizer)+ }+ }+ }+ }++ // Delete deployments+ for _, name := range []string{resourceName("fe"), resourceName("be"), resourceName("lf")} {+ deployment := &appsv1.Deployment{}+ err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, deployment)+ if err == nil {+ if err := r.Delete(ctx, deployment); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete deployment", "name", name)+ }+ }+ }++ // Delete services+ for _, name := range []string{getServiceName(o, "fe"), getServiceName(o, "be"), getServiceName(o, "lf")} {+ service := &corev1.Service{}+ err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, service)+ if err == nil {+ if err := r.Delete(ctx, service); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete service", "name", name)+ }+ }+ }++ // Delete service accounts (only if we created them)+ for _, role := range []string{"fe", "be", "lf"} {+ if shouldCreateServiceAccount(o, role) {+ name := getServiceAccountName(o, role)+ sa := &corev1.ServiceAccount{}+ err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, sa)+ if err == nil {+ if err := r.Delete(ctx, sa); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete service account", "name", name)+ }+ }+ }+ }++ // Delete PVCs based on pvcReclaimPolicy+ // Default is "Retain" to preserve user data+ policy := o.Spec.Langflow.PVCReclaimPolicy+ if policy == "" {+ policy = openragv1alpha1.PVCReclaimRetain // default if not specified+ }++ if policy == openragv1alpha1.PVCReclaimDelete {+ pvc := &corev1.PersistentVolumeClaim{}+ err := r.Get(ctx, client.ObjectKey{Name: resourceName("lf-data"), Namespace: targetNS}, pvc)+ if err == nil {+ logger.Info("Deleting Langflow PVC per pvcReclaimPolicy", "pvc", resourceName("lf-data"), "policy", policy)+ if err := r.Delete(ctx, pvc); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete PVC", "name", resourceName("lf-data"))+ }+ }+ } else {+ logger.Info("Retaining Langflow PVC to preserve user data", "pvc", resourceName("lf-data"), "policy", policy)+ }++ // Delete network policy if enabled+ if o.Spec.NetworkPolicy.Enabled {+ np := &networkingv1.NetworkPolicy{}+ err := r.Get(ctx, client.ObjectKey{Name: resourceName("lf-netpol"), Namespace: targetNS}, np)+ if err == nil {+ logger.Info("Deleting NetworkPolicy", "name", resourceName("lf-netpol"), "namespace", targetNS)+ if err := r.Delete(ctx, np); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete network policy", "name", resourceName("lf-netpol"))+ }+ } else if !errors.IsNotFound(err) {+ logger.Error(err, "failed to get network policy for deletion", "name", resourceName("lf-netpol"))+ }+ }++ // Delete Docling components if enabled+ if o.Spec.DoclingComponents != nil && o.Spec.DoclingComponents.Enabled {+ // Delete Docling deployments (ds and dw)+ for _, name := range []string{resourceName("ds"), resourceName("dw")} {+ deployment := &appsv1.Deployment{}+ err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, deployment)+ if err == nil {+ logger.Info("Deleting Docling deployment", "name", name)+ if err := r.Delete(ctx, deployment); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete Docling deployment", "name", name)+ }+ }+ }++ // Delete Docling services+ for _, name := range []string{getServiceName(o, "ds"), getServiceName(o, "dw")} {+ service := &corev1.Service{}+ err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, service)+ if err == nil {+ logger.Info("Deleting Docling service", "name", name)+ if err := r.Delete(ctx, service); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete Docling service", "name", name)+ }+ }+ }++ // Delete Docling service accounts (only if we created them)+ for _, role := range []string{"ds", "dw"} {+ if shouldCreateServiceAccount(o, role) {+ name := getServiceAccountName(o, role)+ sa := &corev1.ServiceAccount{}+ err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, sa)+ if err == nil {+ logger.Info("Deleting Docling service account", "name", name)+ if err := r.Delete(ctx, sa); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete Docling service account", "name", name)+ }+ }+ }+ }++ // Delete Docling HPAs if enabled+ for _, name := range []string{resourceName("ds-hpa"), resourceName("dw-hpa")} {+ hpa := &autoscalingv2.HorizontalPodAutoscaler{}+ err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, hpa)+ if err == nil {+ logger.Info("Deleting Docling HPA", "name", name)+ if err := r.Delete(ctx, hpa); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete Docling HPA", "name", name)+ }+ }+ }++ // Delete Docling PVCs if storage is enabled+ // Note: Could add reclaim policy for Docling PVCs in future+ for _, name := range []string{resourceName("ds-data"), resourceName("dw-data")} {+ pvc := &corev1.PersistentVolumeClaim{}+ err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, pvc)+ if err == nil {+ logger.Info("Deleting Docling PVC", "name", name)+ if err := r.Delete(ctx, pvc); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete Docling PVC", "name", name)+ }+ }+ }++ // Delete Valkey resources if enabled+ if o.Spec.DoclingComponents.Valkey != nil {+ // Delete Valkey StatefulSet+ sts := &appsv1.StatefulSet{}+ err := r.Get(ctx, client.ObjectKey{Name: resourceName("valkey"), Namespace: targetNS}, sts)+ if err == nil {+ logger.Info("Deleting Valkey StatefulSet", "name", resourceName("valkey"))+ if err := r.Delete(ctx, sts); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete Valkey StatefulSet")+ }+ }++ // Delete Valkey services+ for _, name := range []string{resourceName("valkey"), resourceName("valkey-headless")} {+ service := &corev1.Service{}+ err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, service)+ if err == nil {+ logger.Info("Deleting Valkey service", "name", name)+ if err := r.Delete(ctx, service); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete Valkey service", "name", name)+ }+ }+ }++ // Delete Valkey ConfigMap+ cm := &corev1.ConfigMap{}+ err = r.Get(ctx, client.ObjectKey{Name: resourceName("valkey-config"), Namespace: targetNS}, cm)+ if err == nil {+ logger.Info("Deleting Valkey ConfigMap", "name", resourceName("valkey-config"))+ if err := r.Delete(ctx, cm); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete Valkey ConfigMap")+ }+ }++ // Delete Valkey Secret+ secret := &corev1.Secret{}+ err = r.Get(ctx, client.ObjectKey{Name: resourceName("valkey-auth"), Namespace: targetNS}, secret)+ if err == nil {+ logger.Info("Deleting Valkey Secret", "name", resourceName("valkey-auth"))+ if err := r.Delete(ctx, secret); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete Valkey Secret")+ }+ }++ // Delete Valkey PVCs (from StatefulSet)+ // Note: StatefulSet PVCs have format: data-<statefulset-name>-<ordinal>+ // We should delete these to avoid orphaned PVCs+ for i := 0; i < 1; i++ { // Default replicas is 1+ pvcName := fmt.Sprintf("data-%s-%d", resourceName("valkey"), i)+ pvc := &corev1.PersistentVolumeClaim{}+ err := r.Get(ctx, client.ObjectKey{Name: pvcName, Namespace: targetNS}, pvc)+ if err == nil {+ logger.Info("Deleting Valkey PVC", "name", pvcName)+ if err := r.Delete(ctx, pvc); err != nil && !errors.IsNotFound(err) {+ logger.Error(err, "failed to delete Valkey PVC", "name", pvcName)+ }+ }+ }+ }+ }++ return nil+}diff --git a/kubernetes/operator/internal/controller/openrag_controller.go b/kubernetes/operator/internal/controller/openrag_controller.goindex 391c7b1af..be6381029 100644--- a/kubernetes/operator/internal/controller/openrag_controller.go+++ b/kubernetes/operator/internal/controller/openrag_controller.go@@ -75,30 +75,41 @@ func NewOpenRAGReconciler(c client.Client, s *runtime.Scheme) *OpenRAGReconcilerfunc (r *OpenRAGReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {logger := log.FromContext(ctx)+ logger.Info("reconcile triggered", "name", req.Name, "namespace", req.Namespace)+instance := &openragv1alpha1.OpenRAG{}if err := r.Get(ctx, req.NamespacedName, instance); err != nil {if errors.IsNotFound(err) {+ logger.Info("CR not found - already deleted or never existed", "name", req.Name)return ctrl.Result{}, nil}return ctrl.Result{}, err}+ logger.Info("CR retrieved", "name", instance.Name, "deletionTimestamp", instance.DeletionTimestamp)+if !instance.DeletionTimestamp.IsZero() {+ logger.Info("CR has deletionTimestamp - calling handleDeletion", "name", instance.Name)return ctrl.Result{}, r.handleDeletion(ctx, instance)}targetNS := targetNamespace(instance)- if targetNS != instance.Namespace {- if !controllerutil.ContainsFinalizer(instance, finalizer) {- controllerutil.AddFinalizer(instance, finalizer)- if err := r.Update(ctx, instance); err != nil {- return ctrl.Result{}, err- }- // Return immediately after adding finalizer to avoid duplicate reconciliation.- // The update will trigger a new reconcile that will do the actual work.- logger.Info("added finalizer, will reconcile again")- return ctrl.Result{}, nil- }+ logger.Info("target namespace determined", "targetNS", targetNS, "crNamespace", instance.Namespace)++ // Always add finalizer to CR so handleDeletion() can clean up .env secret finalizers+ // .env secrets have envSecretFinalizer that must be removed before secrets can be deleted+ if !controllerutil.ContainsFinalizer(instance, finalizer) {+ logger.Info("adding finalizer to CR", "finalizer", finalizer, "reason", "needed to cleanup secret finalizers")+ controllerutil.AddFinalizer(instance, finalizer)+ if err := r.Update(ctx, instance); err != nil {+ return ctrl.Result{}, err+ }+ // Return immediately after adding finalizer to avoid duplicate reconciliation.+ // The update will trigger a new reconcile that will do the actual work.+ logger.Info("added finalizer, will reconcile again")+ return ctrl.Result{}, nil+ } else {+ logger.Info("CR already has finalizer", "finalizer", finalizer)}// Reconcile all resources@@ -134,316 +145,6 @@ func (r *OpenRAGReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctreturn r.updateStatusSuccess(ctx, instance, targetNS)}-func (r *OpenRAGReconciler) handleDeletion(ctx context.Context, o *openragv1alpha1.OpenRAG) error {- logger := log.FromContext(ctx)-- if !controllerutil.ContainsFinalizer(o, finalizer) {- return nil- }-- targetNS := targetNamespace(o)-- // Remove finalizers from .env secrets and delete them- for _, envSecretName := range []string{resourceName("be-env"), resourceName("lf-env")} {- envSecret := &corev1.Secret{}- err := r.Get(ctx, client.ObjectKey{Name: envSecretName, Namespace: targetNS}, envSecret)- if err == nil {- // Remove finalizer first- if controllerutil.ContainsFinalizer(envSecret, envSecretFinalizer) {- controllerutil.RemoveFinalizer(envSecret, envSecretFinalizer)- if err := r.Update(ctx, envSecret); err != nil {- return fmt.Errorf("failed to remove finalizer from env secret %s: %w", envSecretName, err)- }- }- // Then delete the secret (necessary for cross-namespace or if owner ref not set)- if err := r.Delete(ctx, envSecret); err != nil && !errors.IsNotFound(err) {- return fmt.Errorf("failed to delete env secret %s: %w", envSecretName, err)- }- } else if !errors.IsNotFound(err) {- return fmt.Errorf("failed to get env secret %s: %w", envSecretName, err)- }- }-- // Remove finalizers from user-provided secrets so they can be deleted- userSecretRefs := collectProtectedSecrets(o)- for _, secretRef := range userSecretRefs {- userSecret := &corev1.Secret{}- err := r.Get(ctx, client.ObjectKey{Name: secretRef.Name, Namespace: targetNS}, userSecret)- if err == nil {- if controllerutil.ContainsFinalizer(userSecret, userSecretFinalizer) {- controllerutil.RemoveFinalizer(userSecret, userSecretFinalizer)- if err := r.Update(ctx, userSecret); err != nil {- return fmt.Errorf("failed to remove finalizer from user secret %s: %w", secretRef.Name, err)- }- logger.Info("removed finalizer from user-supplied secret", "secret", secretRef.Name, "namespace", targetNS, "finalizer", userSecretFinalizer)- }- } else if !errors.IsNotFound(err) {- return fmt.Errorf("failed to get user secret %s: %w", secretRef.Name, err)- }- }-- // Remove finalizers from auto-generated default secrets and delete them- // Use DNS-compliant names (lowercase, hyphens instead of underscores)- defaultSecretNames := []string{- o.Name + "-openrag-encryption-key-default",- o.Name + "-jwt-private-key-default",- o.Name + "-langflow-secret-key-default",- }- for _, secretName := range defaultSecretNames {- defaultSecret := &corev1.Secret{}- err := r.Get(ctx, client.ObjectKey{Name: secretName, Namespace: targetNS}, defaultSecret)- if err == nil {- // Remove finalizer first- if controllerutil.ContainsFinalizer(defaultSecret, userSecretFinalizer) {- controllerutil.RemoveFinalizer(defaultSecret, userSecretFinalizer)- if err := r.Update(ctx, defaultSecret); err != nil {- return fmt.Errorf("failed to remove finalizer from default secret %s: %w", secretName, err)- }- }- // Then delete the secret (necessary for cross-namespace or if owner ref not set)- if err := r.Delete(ctx, defaultSecret); err != nil && !errors.IsNotFound(err) {- return fmt.Errorf("failed to delete default secret %s: %w", secretName, err)- }- } else if !errors.IsNotFound(err) {- return fmt.Errorf("failed to get default secret %s: %w", secretName, err)- }- }-- // If targetNamespace is different from CR namespace, we need to clean up resources- // We can only delete the namespace if WE created it (has managedByLabel)- // Otherwise, we must delete resources individually- if targetNS != o.Namespace {- ns := &corev1.Namespace{}- err := r.Get(ctx, client.ObjectKey{Name: targetNS}, ns)- if err != nil && !errors.IsNotFound(err) {- return err- }-- // Check if we created this namespace- if err == nil && ns.Labels[managedByLabel] == o.Name {- // We created it, safe to delete the entire namespace- if err := r.Delete(ctx, ns); err != nil && !errors.IsNotFound(err) {- return err- }- } else {- // Namespace exists but we didn't create it (user-provided)- // Must delete resources individually to avoid orphans- if err := r.deleteResources(ctx, o, targetNS); err != nil {- return fmt.Errorf("failed to delete resources in namespace %s: %w", targetNS, err)- }- }- }- // If same namespace, owner references handle cleanup automatically-- controllerutil.RemoveFinalizer(o, finalizer)- return r.Update(ctx, o)-}--// deleteResources explicitly deletes all resources created by the operator in the target namespace-// This is necessary when deploying to an existing namespace that we don't manage-func (r *OpenRAGReconciler) deleteResources(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {- logger := log.FromContext(ctx)-- // Delete deployments- for _, name := range []string{resourceName("fe"), resourceName("be"), resourceName("lf")} {- deployment := &appsv1.Deployment{}- err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, deployment)- if err == nil {- if err := r.Delete(ctx, deployment); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete deployment", "name", name)- }- }- }-- // Delete services- for _, name := range []string{getServiceName(o, "fe"), getServiceName(o, "be"), getServiceName(o, "lf")} {- service := &corev1.Service{}- err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, service)- if err == nil {- if err := r.Delete(ctx, service); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete service", "name", name)- }- }- }-- // Delete service accounts (only if we created them)- for _, role := range []string{"fe", "be", "lf"} {- if shouldCreateServiceAccount(o, role) {- name := getServiceAccountName(o, role)- sa := &corev1.ServiceAccount{}- err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, sa)- if err == nil {- if err := r.Delete(ctx, sa); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete service account", "name", name)- }- }- }- }-- // Delete PVCs based on pvcReclaimPolicy- // Default is "Retain" to preserve user data- policy := o.Spec.Langflow.PVCReclaimPolicy- if policy == "" {- policy = openragv1alpha1.PVCReclaimRetain // default if not specified- }-- if policy == openragv1alpha1.PVCReclaimDelete {- pvc := &corev1.PersistentVolumeClaim{}- err := r.Get(ctx, client.ObjectKey{Name: resourceName("lf-data"), Namespace: targetNS}, pvc)- if err == nil {- logger.Info("Deleting Langflow PVC per pvcReclaimPolicy", "pvc", resourceName("lf-data"), "policy", policy)- if err := r.Delete(ctx, pvc); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete PVC", "name", resourceName("lf-data"))- }- }- } else {- logger.Info("Retaining Langflow PVC to preserve user data", "pvc", resourceName("lf-data"), "policy", policy)- }-- // Delete network policy if enabled- if o.Spec.NetworkPolicy.Enabled {- np := &networkingv1.NetworkPolicy{}- err := r.Get(ctx, client.ObjectKey{Name: resourceName("lf-netpol"), Namespace: targetNS}, np)- if err == nil {- logger.Info("Deleting NetworkPolicy", "name", resourceName("lf-netpol"), "namespace", targetNS)- if err := r.Delete(ctx, np); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete network policy", "name", resourceName("lf-netpol"))- }- } else if !errors.IsNotFound(err) {- logger.Error(err, "failed to get network policy for deletion", "name", resourceName("lf-netpol"))- }- }-- // Delete Docling components if enabled- if o.Spec.DoclingComponents != nil && o.Spec.DoclingComponents.Enabled {- // Delete Docling deployments (ds and dw)- for _, name := range []string{resourceName("ds"), resourceName("dw")} {- deployment := &appsv1.Deployment{}- err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, deployment)- if err == nil {- logger.Info("Deleting Docling deployment", "name", name)- if err := r.Delete(ctx, deployment); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete Docling deployment", "name", name)- }- }- }-- // Delete Docling services- for _, name := range []string{getServiceName(o, "ds"), getServiceName(o, "dw")} {- service := &corev1.Service{}- err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, service)- if err == nil {- logger.Info("Deleting Docling service", "name", name)- if err := r.Delete(ctx, service); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete Docling service", "name", name)- }- }- }-- // Delete Docling service accounts (only if we created them)- for _, role := range []string{"ds", "dw"} {- if shouldCreateServiceAccount(o, role) {- name := getServiceAccountName(o, role)- sa := &corev1.ServiceAccount{}- err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, sa)- if err == nil {- logger.Info("Deleting Docling service account", "name", name)- if err := r.Delete(ctx, sa); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete Docling service account", "name", name)- }- }- }- }-- // Delete Docling HPAs if enabled- for _, name := range []string{resourceName("ds-hpa"), resourceName("dw-hpa")} {- hpa := &autoscalingv2.HorizontalPodAutoscaler{}- err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, hpa)- if err == nil {- logger.Info("Deleting Docling HPA", "name", name)- if err := r.Delete(ctx, hpa); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete Docling HPA", "name", name)- }- }- }-- // Delete Docling PVCs if storage is enabled- // Note: Could add reclaim policy for Docling PVCs in future- for _, name := range []string{resourceName("ds-data"), resourceName("dw-data")} {- pvc := &corev1.PersistentVolumeClaim{}- err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, pvc)- if err == nil {- logger.Info("Deleting Docling PVC", "name", name)- if err := r.Delete(ctx, pvc); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete Docling PVC", "name", name)- }- }- }-- // Delete Valkey resources if enabled- if o.Spec.DoclingComponents.Valkey != nil {- // Delete Valkey StatefulSet- sts := &appsv1.StatefulSet{}- err := r.Get(ctx, client.ObjectKey{Name: resourceName("valkey"), Namespace: targetNS}, sts)- if err == nil {- logger.Info("Deleting Valkey StatefulSet", "name", resourceName("valkey"))- if err := r.Delete(ctx, sts); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete Valkey StatefulSet")- }- }-- // Delete Valkey services- for _, name := range []string{resourceName("valkey"), resourceName("valkey-headless")} {- service := &corev1.Service{}- err := r.Get(ctx, client.ObjectKey{Name: name, Namespace: targetNS}, service)- if err == nil {- logger.Info("Deleting Valkey service", "name", name)- if err := r.Delete(ctx, service); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete Valkey service", "name", name)- }- }- }-- // Delete Valkey ConfigMap- cm := &corev1.ConfigMap{}- err = r.Get(ctx, client.ObjectKey{Name: resourceName("valkey-config"), Namespace: targetNS}, cm)- if err == nil {- logger.Info("Deleting Valkey ConfigMap", "name", resourceName("valkey-config"))- if err := r.Delete(ctx, cm); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete Valkey ConfigMap")- }- }-- // Delete Valkey Secret- secret := &corev1.Secret{}- err = r.Get(ctx, client.ObjectKey{Name: resourceName("valkey-auth"), Namespace: targetNS}, secret)- if err == nil {- logger.Info("Deleting Valkey Secret", "name", resourceName("valkey-auth"))- if err := r.Delete(ctx, secret); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete Valkey Secret")- }- }-- // Delete Valkey PVCs (from StatefulSet)- // Note: StatefulSet PVCs have format: data-<statefulset-name>-<ordinal>- // We should delete these to avoid orphaned PVCs- for i := 0; i < 1; i++ { // Default replicas is 1- pvcName := fmt.Sprintf("data-%s-%d", resourceName("valkey"), i)- pvc := &corev1.PersistentVolumeClaim{}- err := r.Get(ctx, client.ObjectKey{Name: pvcName, Namespace: targetNS}, pvc)- if err == nil {- logger.Info("Deleting Valkey PVC", "name", pvcName)- if err := r.Delete(ctx, pvc); err != nil && !errors.IsNotFound(err) {- logger.Error(err, "failed to delete Valkey PVC", "name", pvcName)- }- }- }- }- }-- return nil-}-func (r *OpenRAGReconciler) reconcileNamespace(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {if targetNS == o.Namespace {return nildiff --git a/kubernetes/operator/internal/controller/openrag_controller_test.go b/kubernetes/operator/internal/controller/openrag_controller_test.goindex 59644afa7..54ccc25c3 100644--- a/kubernetes/operator/internal/controller/openrag_controller_test.go+++ b/kubernetes/operator/internal/controller/openrag_controller_test.go@@ -61,6 +61,14 @@ func reconciler(s *runtime.Scheme, objs ...client.Object) (*OpenRAGReconciler, cfunc reconcileOnce(t *testing.T, r *OpenRAGReconciler, cr *openragv1alpha1.OpenRAG) ctrl.Result {t.Helper()+ // First reconcile: adds finalizer and returns early+ _, err := r.Reconcile(context.Background(), ctrl.Request{+ NamespacedName: types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace},+ })+ require.NoError(t, err)++ // Second reconcile: actually creates resources+ // This is needed because adding finalizer triggers an Update() which returns earlyres, err := r.Reconcile(context.Background(), ctrl.Request{NamespacedName: types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace},})@@ -287,7 +295,7 @@ func TestReconcile_AddsFinalizer_WhenTargetNamespaceDiffers(t *testing.T) {assert.True(t, controllerutil.ContainsFinalizer(updated, finalizer))}-func TestReconcile_NoFinalizer_WhenSameNamespace(t *testing.T) {+func TestReconcile_AlwaysAddsFinalizer_SameNamespace(t *testing.T) {s := newScheme(t)cr := minimalCR("my-openrag", "my-ns")r, c := reconciler(s, cr)@@ -297,7 +305,8 @@ func TestReconcile_NoFinalizer_WhenSameNamespace(t *testing.T) {updated := &openragv1alpha1.OpenRAG{}require.NoError(t, c.Get(context.Background(),types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace}, updated))- assert.False(t, controllerutil.ContainsFinalizer(updated, finalizer))+ // Finalizer is always added (even for same namespace) to ensure .env secret finalizers are cleaned up on deletion+ assert.True(t, controllerutil.ContainsFinalizer(updated, finalizer))}func TestReconcile_ResourcesInTargetNamespace(t *testing.T) {