Skip to content

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

Python

feat: sort env to avoid unneccesary hash generation (#1522)

ming56f4f444767a
diff --git a/kubernetes/operator/internal/controller/env.go b/kubernetes/operator/internal/controller/env.go
index 89f8d730f..faacb89cf 100644
--- a/kubernetes/operator/internal/controller/env.go
+++ b/kubernetes/operator/internal/controller/env.go
@@ -5,6 +5,7 @@ import (
"encoding/base64"
"fmt"
"os"
+ "sort"
"strings"
corev1 "k8s.io/api/core/v1"
@@ -186,11 +187,18 @@ func (m *EnvVarManager) mergeEnvVars(defaults map[string]string, prefix string,
// BuildEnvFileContent converts a map of env vars to .env file format
func (m *EnvVarManager) BuildEnvFileContent(envVars map[string]string) string {
+ // Sort keys to ensure deterministic output
+ keys := make([]string, 0, len(envVars))
+ for k := range envVars {
+ keys = append(keys, k)
+ }
+ sort.Strings(keys)
+
var b strings.Builder
- for k, v := range envVars {
+ for _, k := range keys {
b.WriteString(k)
b.WriteString("=")
- b.WriteString(v)
+ b.WriteString(envVars[k])
b.WriteString("\n")
}
return b.String()
diff --git a/kubernetes/operator/internal/controller/env_test.go b/kubernetes/operator/internal/controller/env_test.go
index 75f1a43aa..9d033397b 100644
--- a/kubernetes/operator/internal/controller/env_test.go
+++ b/kubernetes/operator/internal/controller/env_test.go
@@ -158,6 +158,16 @@ func TestEnvVarManager_BuildEnvFileContent(t *testing.T) {
// Should have newlines
assert.Contains(t, content, "\n")
+
+ // Should be deterministic (alphabetically sorted)
+ expected := "VAR1=value1\nVAR2=value2\nVAR3=value3\n"
+ assert.Equal(t, expected, content, "Output should be deterministic and sorted")
+
+ // Verify determinism by calling multiple times
+ for i := 0; i < 10; i++ {
+ result := manager.BuildEnvFileContent(envVars)
+ assert.Equal(t, expected, result, "Output should be identical on iteration %d", i)
+ }
}
func TestEnvVarManager_RealWorldScenario(t *testing.T) {
diff --git a/kubernetes/operator/internal/controller/openrag_controller.go b/kubernetes/operator/internal/controller/openrag_controller.go
index ebec3927d..8feaeb474 100644
--- a/kubernetes/operator/internal/controller/openrag_controller.go
+++ b/kubernetes/operator/internal/controller/openrag_controller.go
@@ -2,9 +2,7 @@ package controller
import (
"context"
- "crypto/rand"
"crypto/sha256"
- "encoding/base64"
"encoding/hex"
"encoding/json"
"fmt"
@@ -77,6 +75,10 @@ func (r *OpenRAGReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
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
}
}
@@ -88,9 +90,6 @@ func (r *OpenRAGReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
if err := r.reconcileServiceAccounts(ctx, instance, targetNS); err != nil {
return ctrl.Result{}, fmt.Errorf("service accounts: %w", err)
}
- if err := r.reconcileGeneratedCreds(ctx, instance, targetNS); err != nil {
- return ctrl.Result{}, fmt.Errorf("generated creds: %w", err)
- }
if err := r.reconcileEnvSecrets(ctx, instance, targetNS); err != nil {
return ctrl.Result{}, fmt.Errorf("env secrets: %w", err)
}
@@ -176,46 +175,6 @@ func (r *OpenRAGReconciler) reconcileServiceAccounts(ctx context.Context, o *ope
return nil
}
-// reconcileGeneratedCreds creates a stable Secret holding auto-generated
-// LANGFLOW_SECRET_KEY and OPENRAG_ENCRYPTION_KEY. It is only created once —
-// subsequent reconcile loops skip it to preserve the generated values.
-func (r *OpenRAGReconciler) reconcileGeneratedCreds(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {
- secretName := resourceName(o.Name, "gen-creds")
- existing := &corev1.Secret{}
- err := r.Get(ctx, client.ObjectKey{Name: secretName, Namespace: targetNS}, existing)
- if err == nil {
- return nil // already exists, don't overwrite stable keys
- }
- if !errors.IsNotFound(err) {
- return err
- }
-
- langflowKey, err := generateKey(32)
- if err != nil {
- return err
- }
- encryptionKey, err := generateKey(32)
- if err != nil {
- return err
- }
-
- secret := &corev1.Secret{
- ObjectMeta: metav1.ObjectMeta{
- Name: secretName,
- Namespace: targetNS,
- Labels: map[string]string{"app.kubernetes.io/managed-by": "openrag-operator"},
- },
- StringData: map[string]string{
- "LANGFLOW_SECRET_KEY": langflowKey,
- "OPENRAG_ENCRYPTION_KEY": encryptionKey,
- },
- }
- if err := r.setOwnerOrLabel(o, secret, targetNS); err != nil {
- return err
- }
- return r.Create(ctx, secret)
-}
-
// parseEnvValue extracts a value from .env file content for the given key
func parseEnvValue(envContent, key string) string {
lines := strings.Split(envContent, "\n")
@@ -1027,24 +986,35 @@ func (r *OpenRAGReconciler) setOwnerOrLabel(o *openragv1alpha1.OpenRAG, obj clie
}
func (r *OpenRAGReconciler) createOrUpdate(ctx context.Context, obj client.Object) error {
- hash, err := desiredHash(obj)
+ existing := obj.DeepCopyObject().(client.Object)
+ err := r.Get(ctx, client.ObjectKeyFromObject(obj), existing)
+ if errors.IsNotFound(err) {
+ // Object doesn't exist, create it with hash annotation
+ hash, err := desiredHash(obj)
+ if err != nil {
+ return err
+ }
+ setAnnotation(obj, specHashAnnotation, hash)
+ return r.Create(ctx, obj)
+ }
if err != nil {
return err
}
- setAnnotation(obj, specHashAnnotation, hash)
- existing := obj.DeepCopyObject().(client.Object)
- if err := r.Get(ctx, client.ObjectKeyFromObject(obj), existing); err != nil {
- if errors.IsNotFound(err) {
- return r.Create(ctx, obj)
- }
+ // Object exists, check if update is needed
+ hash, err := desiredHash(obj)
+ if err != nil {
return err
}
- if existing.GetAnnotations()[specHashAnnotation] == hash {
+ existingHash := existing.GetAnnotations()[specHashAnnotation]
+ if existingHash == hash {
+ // No changes needed
return nil
}
+ // Update needed - set the new hash and resource version
+ setAnnotation(obj, specHashAnnotation, hash)
obj.SetResourceVersion(existing.GetResourceVersion())
return r.Update(ctx, obj)
}
@@ -1186,11 +1156,3 @@ func secretEnvVar(name string, sel *corev1.SecretKeySelector) corev1.EnvVar {
ValueFrom: &corev1.EnvVarSource{SecretKeyRef: sel},
}
}
-
-func generateKey(n int) (string, error) {
- b := make([]byte, n)
- if _, err := rand.Read(b); err != nil {
- return "", err
- }
- return base64.URLEncoding.EncodeToString(b), nil
-}
diff --git a/kubernetes/operator/internal/controller/openrag_controller_test.go b/kubernetes/operator/internal/controller/openrag_controller_test.go
index 130c11de6..e7ee3db79 100644
--- a/kubernetes/operator/internal/controller/openrag_controller_test.go
+++ b/kubernetes/operator/internal/controller/openrag_controller_test.go
@@ -202,21 +202,6 @@ func TestReconcile_BackendMountsOperatorManagedEnvSecret(t *testing.T) {
assert.True(t, found, "backend-env volume should exist with operator-managed secret")
}
-func TestReconcile_CreatesEnvSecrets(t *testing.T) {
- s := newScheme(t)
- cr := minimalCR("my-openrag", "my-ns")
- r, c := reconciler(s, cr)
-
- reconcileOnce(t, r, cr)
-
- for _, role := range []string{"be-env", "lf-env", "gen-creds"} {
- sec := &corev1.Secret{}
- require.NoError(t, c.Get(context.Background(),
- types.NamespacedName{Name: resourceName(cr.Name, role), Namespace: "my-ns"}, sec),
- "secret for role %s should exist", role)
- }
-}
-
func TestReconcile_BackendEnvContainsLangflowURL(t *testing.T) {
s := newScheme(t)
cr := minimalCR("my-openrag", "my-ns")
@@ -270,6 +255,9 @@ func TestReconcile_CreatesTargetNamespace(t *testing.T) {
cr.Spec.TargetNamespace = "tenant-ns"
r, c := reconciler(s, cr)
+ // First reconcile adds finalizer and returns early
+ reconcileOnce(t, r, cr)
+ // Second reconcile creates namespace and resources
reconcileOnce(t, r, cr)
ns := &corev1.Namespace{}
@@ -310,6 +298,9 @@ func TestReconcile_ResourcesInTargetNamespace(t *testing.T) {
cr.Spec.TargetNamespace = "tenant-ns"
r, c := reconciler(s, cr)
+ // First reconcile adds finalizer and returns early
+ reconcileOnce(t, r, cr)
+ // Second reconcile creates resources
reconcileOnce(t, r, cr)
d := &appsv1.Deployment{}