Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python

feat: add more finalizer removal logic (#1601)

mingbd4e7fc35f9c
diff --git a/kubernetes/operator/api/v1alpha1/openrag_types.go b/kubernetes/operator/api/v1alpha1/openrag_types.go
index d0e835b64..d64e6adb9 100644
--- a/kubernetes/operator/api/v1alpha1/openrag_types.go
+++ b/kubernetes/operator/api/v1alpha1/openrag_types.go
@@ -9,6 +9,17 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
+// PVCReclaimPolicy describes what happens to PVCs when the OpenRAG CR is deleted.
+// +kubebuilder:validation:Enum=Retain;Delete
+type PVCReclaimPolicy string
+
+const (
+ // PVCReclaimRetain means the PVC will be retained when the CR is deleted (preserves user data).
+ PVCReclaimRetain PVCReclaimPolicy = "Retain"
+ // PVCReclaimDelete means the PVC will be deleted when the CR is deleted (data loss).
+ PVCReclaimDelete PVCReclaimPolicy = "Delete"
+)
+
// ComponentSpec defines common configuration shared by all three components.
type ComponentSpec struct {
// Image is the container image (repository:tag).
@@ -226,6 +237,15 @@ type LangflowSpec struct {
// Storage configures a PVC mounted at /app/data (Langflow SQLite + flows).
// +optional
Storage *PersistenceSpec `json:"storage,omitempty"`
+
+ // PVCReclaimPolicy determines what happens to the Langflow PVC when the OpenRAG CR is deleted.
+ // - "Retain" (default): PVC is retained to preserve user data (flows, SQLite database)
+ // - "Delete": PVC is deleted along with other resources (WARNING: permanent data loss)
+ // Similar to Kubernetes PersistentVolume reclaimPolicy.
+ // +optional
+ // +kubebuilder:default=Retain
+ // +kubebuilder:validation:Enum=Retain;Delete
+ PVCReclaimPolicy PVCReclaimPolicy `json:"pvcReclaimPolicy,omitempty"`
}
// LLMSpec configures the LLM provider used by backend and Langflow.
diff --git a/kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml b/kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml
index 167b409d5..9f8ad5f19 100644
--- a/kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml
+++ b/kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml
@@ -12676,6 +12676,21 @@ spec:
type: string
type: object
type: object
+ pvcReclaimPolicy:
+ allOf:
+ - enum:
+ - Retain
+ - Delete
+ - enum:
+ - Retain
+ - Delete
+ default: Retain
+ description: |-
+ PVCReclaimPolicy determines what happens to the Langflow PVC when the OpenRAG CR is deleted.
+ - "Retain" (default): PVC is retained to preserve user data (flows, SQLite database)
+ - "Delete": PVC is deleted along with other resources (WARNING: permanent data loss)
+ Similar to Kubernetes PersistentVolume reclaimPolicy.
+ type: string
replicas:
default: 1
format: int32
diff --git a/kubernetes/operator/internal/controller/openrag_controller.go b/kubernetes/operator/internal/controller/openrag_controller.go
index 547fc7771..0dbedaad2 100644
--- a/kubernetes/operator/internal/controller/openrag_controller.go
+++ b/kubernetes/operator/internal/controller/openrag_controller.go
@@ -166,23 +166,30 @@ func (r *OpenRAGReconciler) updateStatusError(ctx context.Context, instance *ope
}
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 so they can be deleted
+ // 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)
}
@@ -199,13 +206,14 @@ func (r *OpenRAGReconciler) handleDeletion(ctx context.Context, o *openragv1alph
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 so they can be deleted
+ // 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",
@@ -216,35 +224,257 @@ func (r *OpenRAGReconciler) handleDeletion(ctx context.Context, o *openragv1alph
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)
}
}
- // Delete managed namespace if it exists
- ns := &corev1.Namespace{}
- err := r.Get(ctx, client.ObjectKey{Name: targetNS}, ns)
- if err != nil && !errors.IsNotFound(err) {
- return err
- }
- if err == nil {
- if ns.Labels[managedByLabel] == o.Name {
+ // 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 nil