OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
feat: operator env source order (#1515)
ming82ba9b45c9cf
diff --git a/kubernetes/operator/api/v1alpha1/openrag_types.go b/kubernetes/operator/api/v1alpha1/openrag_types.goindex dd59f1a8a..7bc167b67 100644--- a/kubernetes/operator/api/v1alpha1/openrag_types.go+++ b/kubernetes/operator/api/v1alpha1/openrag_types.go@@ -45,18 +45,6 @@ type FrontendSpec struct {ComponentSpec `json:",inline"`}-// FlowIDsSpec holds the Langflow flow UUIDs consumed by the backend.-type FlowIDsSpec struct {- // +optional- Chat string `json:"chat,omitempty"`- // +optional- Ingest string `json:"ingest,omitempty"`- // +optional- URLIngest string `json:"urlIngest,omitempty"`- // +optional- Nudges string `json:"nudges,omitempty"`-}-// GoogleOAuthSpec holds Google OAuth2 client credentials.type GoogleOAuthSpec struct {// +optional@@ -100,10 +88,6 @@ type BackendSpec struct {// +optionalStorage *PersistenceSpec `json:"storage,omitempty"`- // FlowIDs are the Langflow flow UUIDs the backend calls for chat, ingest, etc.- // +optional- FlowIDs *FlowIDsSpec `json:"flowIds,omitempty"`-// OAuthBrokerURL is the OAuth callback URL (OAUTH_BROKER_URL).// +optionalOAuthBrokerURL string `json:"oauthBrokerUrl,omitempty"`@@ -127,11 +111,6 @@ type LangflowSpec struct {// +optionalSecretKeySecret *corev1.SecretKeySelector `json:"secretKeySecret,omitempty"`- // DatabaseURL overrides LANGFLOW_DATABASE_URL.- // Defaults to sqlite:////app/data/langflow.db when storage is enabled.- // +optional- DatabaseURL string `json:"databaseUrl,omitempty"`-// FlowsRef is the git branch name or commit SHA from which flow JSON files// are downloaded at pod startup via an init container. When set, all *.json// files under flows/ in langflow-ai/openrag at that ref are fetched intodiff --git a/kubernetes/operator/api/v1alpha1/zz_generated.deepcopy.go b/kubernetes/operator/api/v1alpha1/zz_generated.deepcopy.goindex ca691fe38..09143d7d5 100644--- a/kubernetes/operator/api/v1alpha1/zz_generated.deepcopy.go+++ b/kubernetes/operator/api/v1alpha1/zz_generated.deepcopy.go@@ -1,7 +1,7 @@//go:build !ignore_autogenerated/*-Copyright 2025 The OpenRAG Authors.+Copyright 2026 The OpenRAG Authors.Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.@@ -45,11 +45,6 @@ func (in *BackendSpec) DeepCopyInto(out *BackendSpec) {*out = new(PersistenceSpec)(*in).DeepCopyInto(*out)}- if in.FlowIDs != nil {- in, out := &in.FlowIDs, &out.FlowIDs- *out = new(FlowIDsSpec)- **out = **in- }if in.OAuth != nil {in, out := &in.OAuth, &out.OAuth*out = new(OAuthSpec)@@ -144,21 +139,6 @@ func (in *EmbeddingSpec) DeepCopy() *EmbeddingSpec {return out}-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.-func (in *FlowIDsSpec) DeepCopyInto(out *FlowIDsSpec) {- *out = *in-}--// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FlowIDsSpec.-func (in *FlowIDsSpec) DeepCopy() *FlowIDsSpec {- if in == nil {- return nil- }- out := new(FlowIDsSpec)- in.DeepCopyInto(out)- return out-}-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.func (in *FrontendSpec) DeepCopyInto(out *FrontendSpec) {*out = *indiff --git a/kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml b/kubernetes/operator/config/crd/bases/openr.ag_openrags.yamlindex 8984bc5a4..dcedd261e 100644--- a/kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml+++ b/kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml@@ -1126,19 +1126,6 @@ spec:- nametype: objecttype: array- flowIds:- description: FlowIDs are the Langflow flow UUIDs the backend calls- for chat, ingest, etc.- properties:- chat:- type: string- ingest:- type: string- nudges:- type: string- urlIngest:- type: string- type: objectibmAuthEnabled:description: IBMAuthEnabled enables IBM IAM authentication (IBM_AUTH_ENABLED).type: boolean@@ -3507,11 +3494,6 @@ spec:x-kubernetes-list-type: atomictype: objecttype: object- databaseUrl:- description: |-- DatabaseURL overrides LANGFLOW_DATABASE_URL.- Defaults to sqlite:////app/data/langflow.db when storage is enabled.- type: stringenv:description: Additional environment variables injected into thecontainer.diff --git a/kubernetes/operator/hack/boilerplate.go.txt b/kubernetes/operator/hack/boilerplate.go.txtindex 22fa92f34..ea7a364cf 100644--- a/kubernetes/operator/hack/boilerplate.go.txt+++ b/kubernetes/operator/hack/boilerplate.go.txt@@ -1,5 +1,5 @@/*-Copyright 2025 The OpenRAG Authors.+Copyright 2026 The OpenRAG Authors.Licensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with the License.diff --git a/kubernetes/operator/internal/controller/ENV_OVERRIDE.md b/kubernetes/operator/internal/controller/ENV_OVERRIDE.mdnew file mode 100644index 000000000..d98db513d--- /dev/null+++ b/kubernetes/operator/internal/controller/ENV_OVERRIDE.md@@ -0,0 +1,244 @@+# Environment Variable Override System++The OpenRAG operator implements a three-level environment variable override system that allows fine-grained control over environment variables for Langflow, Backend, and Frontend components.++## Three-Level Priority System++Environment variables are merged using the following priority (highest to lowest):++1. **CR Spec Env Vars** (Highest Priority) - Defined in the `OpenRAG` custom resource+2. **Operator Environment** (Medium Priority) - Set in the operator's deployment with component-specific prefixes+3. **Hardcoded Defaults** (Lowest Priority) - Built into the operator code++### Visual Representation++```+┌─────────────────────────────────────────────────────────────┐+│ Priority Level 3 (Highest): CR Spec │+│ ┌─────────────────────────────────────────────────────────┐ │+│ │ spec: │ │+│ │ langflow: │ │+│ │ env: │ │+│ │ - name: LANGFLOW_LOG_LEVEL │ │+│ │ value: "ERROR" │ │+│ └─────────────────────────────────────────────────────────┘ │+└─────────────────────────────────────────────────────────────┘+ ↓ overrides+┌─────────────────────────────────────────────────────────────┐+│ Priority Level 2 (Medium): Operator Environment │+│ ┌─────────────────────────────────────────────────────────┐ │+│ │ Operator Deployment: │ │+│ │ env: │ │+│ │ - name: OPTLF_LANGFLOW_LOG_LEVEL │ │+│ │ value: "INFO" │ │+│ │ - name: OPTLF_LANGFLOW_WORKERS │ │+│ │ value: "8" │ │+│ └─────────────────────────────────────────────────────────┘ │+└─────────────────────────────────────────────────────────────┘+ ↓ overrides+┌─────────────────────────────────────────────────────────────┐+│ Priority Level 1 (Lowest): Hardcoded Defaults │+│ ┌─────────────────────────────────────────────────────────┐ │+│ │ env.go DefaultLangflowEnvVars: │ │+│ │ "LANGFLOW_LOG_LEVEL": "DEBUG" │ │+│ │ "LANGFLOW_WORKERS": "4" │ │+│ │ "LANGFLOW_AUTO_LOGIN": "true" │ │+│ └─────────────────────────────────────────────────────────┘ │+└─────────────────────────────────────────────────────────────┘+```++### Result++In the example above, the final merged environment would be:+- `LANGFLOW_LOG_LEVEL=ERROR` (from CR spec - highest priority)+- `LANGFLOW_WORKERS=8` (from operator env - medium priority)+- `LANGFLOW_AUTO_LOGIN=true` (from defaults - lowest priority)++## Component-Specific Prefixes++Each component has its own prefix for operator-level environment variables:++| Component | Prefix | Example |+|-----------|--------|---------|+| Langflow | `OPTLF_` | `OPTLF_LANGFLOW_WORKERS=8` |+| Backend | `OPTORBE_` | `OPTORBE_LOG_LEVEL=INFO` |+| Frontend | `OPTORFE_` | `OPTORFE_PORT=3000` |++This allows you to set different values for the same environment variable across components:++```yaml+apiVersion: apps/v1+kind: Deployment+metadata:+ name: openrag-operator+spec:+ template:+ spec:+ containers:+ - name: manager+ env:+ - name: OPTLF_WORKERS+ value: "8"+ - name: OPTORBE_WORKERS+ value: "4"+ - name: OPTORFE_WORKERS+ value: "2"+```++## Usage Examples++### Example 1: Override with CR Spec++```yaml+apiVersion: openr.ag/v1alpha1+kind: OpenRAG+metadata:+ name: my-openrag+spec:+ langflow:+ env:+ - name: LANGFLOW_LOG_LEVEL+ value: "ERROR"+ - name: LANGFLOW_WORKERS+ value: "16"+```++### Example 2: Override with Operator Environment++Deploy the operator with custom defaults:++```yaml+apiVersion: apps/v1+kind: Deployment+metadata:+ name: openrag-operator+spec:+ template:+ spec:+ containers:+ - name: manager+ env:+ # Langflow overrides+ - name: OPTLF_LANGFLOW_WORKERS+ value: "8"+ - name: OPTLF_LANGFLOW_LOG_LEVEL+ value: "INFO"++ # Backend overrides+ - name: OPTORBE_LOG_LEVEL+ value: "DEBUG"+ - name: OPTORBE_MAX_WORKERS+ value: "6"+```++### Example 3: Use All Three Levels++```yaml+# Operator deployment with medium-priority defaults+env:+- name: OPTLF_LANGFLOW_WORKERS+ value: "8"++---+# OpenRAG CR with high-priority overrides+apiVersion: openr.ag/v1alpha1+kind: OpenRAG+metadata:+ name: my-openrag+spec:+ langflow:+ env:+ - name: LANGFLOW_LOG_LEVEL+ value: "ERROR"+```++**Result:**+- `LANGFLOW_WORKERS=8` (from operator env, overrides default "4")+- `LANGFLOW_LOG_LEVEL=ERROR` (from CR, overrides operator env if set)+- `LANGFLOW_AUTO_LOGIN=true` (from hardcoded defaults)++## API Reference++### EnvVarManager++```go+type EnvVarManager struct {+ Config config.OperatorConfig+ DefaultLangflowEnvVars map[string]string+ DefaultOpenRagBEEnvVars map[string]string+ DefaultOpenRagFEEnvVars map[string]string+}+```++### Methods++#### GetLangflowEnvVars++```go+func (m *EnvVarManager) GetLangflowEnvVars(crEnvVars []corev1.EnvVar) map[string]string+```++Returns merged Langflow environment variables with three-level priority applied.++#### GetBackendEnvVars++```go+func (m *EnvVarManager) GetBackendEnvVars(crEnvVars []corev1.EnvVar) map[string]string+```++Returns merged Backend environment variables with three-level priority applied.++#### GetFrontendEnvVars++```go+func (m *EnvVarManager) GetFrontendEnvVars(crEnvVars []corev1.EnvVar) map[string]string+```++Returns merged Frontend environment variables with three-level priority applied.++#### BuildEnvFileContent++```go+func (m *EnvVarManager) BuildEnvFileContent(envVars map[string]string) string+```++Converts a map of environment variables to `.env` file format.++## Implementation Details++### Priority Merge Algorithm++1. **Start with defaults**: Copy all hardcoded defaults to result map+2. **Apply operator env**: Iterate through operator's environment, find variables with the correct prefix, strip prefix, and override+3. **Apply CR env**: Iterate through CR spec env vars, override with their values (only direct values, not `valueFrom`)++### Prefix Stripping++When the operator environment contains `OPTLF_LANGFLOW_WORKERS=8`, the prefix `OPTLF_` is stripped, resulting in `LANGFLOW_WORKERS=8` in the final environment.++### ValueFrom Support++CR env vars using `valueFrom` (e.g., secrets, configmaps) are NOT evaluated at this stage. They are passed directly to the pod spec and resolved by Kubernetes at runtime. Only env vars with direct `value` fields are merged into the `.env` file.++## Testing++See `env_test.go` for comprehensive test coverage of:+- Three-level priority override+- Prefix filtering+- CR env var override+- Empty CR env vars+- ValueFrom handling+- Real-world scenarios++Run tests:+```bash+go test -v ./internal/controller -run TestEnvVarManager+```++## Best Practices++1. **Use CR spec for instance-specific overrides**: Each OpenRAG instance can have custom settings+2. **Use operator env for organization-wide defaults**: Set in operator deployment for all instances+3. **Modify hardcoded defaults sparingly**: Only change when updating the operator version+4. **Use descriptive names**: Operator env vars include the component in the name (e.g., `OPTLF_LANGFLOW_WORKERS`)+5. **Document overrides**: Use comments in your CRs and operator deployment to explain why overrides are neededdiff --git a/kubernetes/operator/internal/controller/env.go b/kubernetes/operator/internal/controller/env.gonew file mode 100644index 000000000..24e0fb47b--- /dev/null+++ b/kubernetes/operator/internal/controller/env.go@@ -0,0 +1,194 @@+package controller++import (+ "os"+ "strings"++ corev1 "k8s.io/api/core/v1"+)++const (+ LANGFLOW_ENV_PREFIX = "OPTLF_"+ OPENRAGBE_ENV_PREFIX = "OPTORBE_"+ OPENRAGFE_ENV_PREFIX = "OPTORFE_"+)++type EnvVarManager struct {+ // a map makes look up faster and easier+ DefaultLangflowEnvVars map[string]string+ DefaultOpenRagBEEnvVars map[string]string+ DefaultOpenRagFEEnvVars map[string]string+}++func NewEnvVarManager() *EnvVarManager {+ return &EnvVarManager{+ DefaultLangflowEnvVars: map[string]string{+ // Database configuration+ "LANGFLOW_DATABASE_URL": "sqlite:////app/data/langflow.db",++ // Variables to expose to Langflow components+ "LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT": "JWT,OPENRAG_QUERY_FILTER,OPENSEARCH_PASSWORD,OPENSEARCH_URL,OPENSEARCH_INDEX_NAME,DOCLING_SERVE_URL,OWNER,OWNER_NAME,OWNER_EMAIL,CONNECTOR_TYPE,DOCUMENT_ID,SOURCE_URL,ALLOWED_USERS,ALLOWED_GROUPS,FILENAME,MIMETYPE,FILESIZE,SELECTED_EMBEDDING_MODEL,OPENAI_API_KEY,ANTHROPIC_API_KEY,WATSONX_API_KEY,WATSONX_ENDPOINT,WATSONX_PROJECT_ID,OLLAMA_BASE_URL",++ // Authentication and user management+ "LANGFLOW_SKIP_AUTH_AUTO_LOGIN": "true",+ "LANGFLOW_NEW_USER_IS_ACTIVE": "false",+ "LANGFLOW_AUTO_LOGIN": "true",+ "LANGFLOW_ENABLE_SUPERUSER_CLI": "false",++ // Langflow runtime configuration+ "LANGFLOW_WORKERS": "4",+ "LANGFLOW_CONFIG_DIR": "/tmp",+ "LANGFLOW_LOG_LEVEL": "DEBUG",+ "HIDE_GETTING_STARTED_PROGRESS": "true",+ "LANGFLOW_ALEMBIC_LOG_TO_STDOUT": "true",+ "LANGFLOW_DEACTIVATE_TRACING": "true",+ "LANGFLOW_LOAD_FLOWS_PATH": "/app/flows",+ "LANGFUSE_HOST": "https://cloud.langfuse.com",+ "LANGFLOW_KEY_RETRIES": "15",+ "LANGFLOW_KEY_RETRY_DELAY": "2",++ // Flow context defaults+ "JWT": "None",+ "OWNER": "None",+ "OWNER_NAME": "None",+ "OWNER_EMAIL": "None",+ "CONNECTOR_TYPE": "system",+ "CONNECTOR_TYPE_URL": "url",+ "DOCUMENT_ID": "",+ "SOURCE_URL": "",+ "ALLOWED_USERS": "[]",+ "ALLOWED_GROUPS": "[]",+ "OPENRAG_QUERY_FILTER": "{}",+ "FILENAME": "None",+ "MIMETYPE": "None",+ "FILESIZE": "0",+ "SELECTED_EMBEDDING_MODEL": "",++ // Provider API keys (defaults to None, overridden by CR spec)+ "OPENAI_API_KEY": "None",+ "ANTHROPIC_API_KEY": "None",+ "WATSONX_API_KEY": "None",+ "OLLAMA_BASE_URL": "None",+ },+ DefaultOpenRagBEEnvVars: map[string]string{+ // Langflow connection+ "LANGFLOW_URL": "http://langflow:7860",+ "LANGFLOW_TIMEOUT": "2400",+ "LANGFLOW_CONNECT_TIMEOUT": "30",+ "LANGFLOW_AUTO_LOGIN": "true",+ "LANGFLOW_KEY_RETRIES": "15",+ "LANGFLOW_KEY_RETRY_DELAY": "2",+ "LANGFLOW_KEY": "",++ // Backend data paths+ "OPENRAG_DATA_PATH": "/app/backend-data",+ "OPENRAG_DOCUMENTS_PATH": "/app/openrag-documents",+ "OPENRAG_DOCUMENT_PATH": "/app/openrag-documents", // omg which one?+ "OPENRAG_FLOWS_BACKUP_PATH": "/app/backend-data/flow-backups",+ "OPENRAG_KEYS_PATH": "/app/backend-data/keys",+ "OPENRAG_CONFIG_PATH": "/app/backend-data/config",+ "OPENRAG_VERSION": "latest",++ // OpenSearch configuration+ "OPENSEARCH_DATA_PATH": "./opensearch-data",++ // Logging configuration+ "LOG_LEVEL": "DEBUG",+ "LOG_FORMAT": "json",+ "ACCESS_LOG": "true",+ "SERVICE_NAME": "openrag",++ // Environment+ "ENVIRONMENT": "development",++ // Ingestion configuration+ "INGEST_SAMPLE_DATA": "true",+ "DISABLE_INGEST_WITH_LANGFLOW": "false",+ "INGESTION_TIMEOUT": "3600",+ "UPLOAD_BATCH_SIZE": "25",+ "MAX_WORKERS": "4",++ // Segment analytics (default empty, set via CR or operator env)+ "SEGMENT_WRITE_KEY": "",+ },+ DefaultOpenRagFEEnvVars: map[string]string{+ // Frontend environment variables will be added here+ },+ }+}++// GetLangflowEnvVars returns merged Langflow env vars with three-level priority:+// 1. Highest priority: CR spec env vars+// 2. Medium priority: Operator env vars with OPTLF_ prefix+// 3. Lowest priority: Hardcoded defaults+func (m *EnvVarManager) GetLangflowEnvVars(crEnvVars []corev1.EnvVar) map[string]string {+ return m.mergeEnvVars(m.DefaultLangflowEnvVars, LANGFLOW_ENV_PREFIX, crEnvVars)+}++// GetBackendEnvVars returns merged Backend env vars with three-level priority:+// 1. Highest priority: CR spec env vars+// 2. Medium priority: Operator env vars with OPTORBE_ prefix+// 3. Lowest priority: Hardcoded defaults+func (m *EnvVarManager) GetBackendEnvVars(crEnvVars []corev1.EnvVar) map[string]string {+ return m.mergeEnvVars(m.DefaultOpenRagBEEnvVars, OPENRAGBE_ENV_PREFIX, crEnvVars)+}++// GetFrontendEnvVars returns merged Frontend env vars with three-level priority:+// 1. Highest priority: CR spec env vars+// 2. Medium priority: Operator env vars with OPTORFE_ prefix+// 3. Lowest priority: Hardcoded defaults+func (m *EnvVarManager) GetFrontendEnvVars(crEnvVars []corev1.EnvVar) map[string]string {+ return m.mergeEnvVars(m.DefaultOpenRagFEEnvVars, OPENRAGFE_ENV_PREFIX, crEnvVars)+}++// mergeEnvVars implements the three-level override priority:+// Level 1 (Lowest): hardcoded defaults+// Level 2 (Medium): operator environment variables with prefix+// Level 3 (Highest): CR spec env vars+func (m *EnvVarManager) mergeEnvVars(defaults map[string]string, prefix string, crEnvVars []corev1.EnvVar) map[string]string {+ result := make(map[string]string)++ // Level 1: Start with hardcoded defaults (lowest priority)+ for k, v := range defaults {+ result[k] = v+ }++ // Level 2: Override with operator environment variables (medium priority)+ // Read operator's environment and apply any variables with the matching prefix+ for _, envVar := range os.Environ() {+ parts := strings.SplitN(envVar, "=", 2)+ if len(parts) != 2 {+ continue+ }+ key, value := parts[0], parts[1]++ // Check if this env var has the expected prefix+ if strings.HasPrefix(key, prefix) {+ // Remove the prefix to get the actual env var name+ actualKey := strings.TrimPrefix(key, prefix)+ result[actualKey] = value+ }+ }++ // Level 3: Override with CR spec env vars (highest priority)+ for _, envVar := range crEnvVars {+ // Only process direct value assignments (not valueFrom)+ if envVar.Value != "" {+ result[envVar.Name] = envVar.Value+ }+ }++ return result+}++// BuildEnvFileContent converts a map of env vars to .env file format+func (m *EnvVarManager) BuildEnvFileContent(envVars map[string]string) string {+ var b strings.Builder+ for k, v := range envVars {+ b.WriteString(k)+ b.WriteString("=")+ b.WriteString(v)+ b.WriteString("\n")+ }+ return b.String()+}diff --git a/kubernetes/operator/internal/controller/env_example_test.go b/kubernetes/operator/internal/controller/env_example_test.gonew file mode 100644index 000000000..1ec0dd4ae--- /dev/null+++ b/kubernetes/operator/internal/controller/env_example_test.go@@ -0,0 +1,86 @@+package controller++import (+ "fmt"+ "os"++ corev1 "k8s.io/api/core/v1"+)++// Example demonstrates the three-level environment variable priority system+func Example_envVarPriority() {+ // Create the EnvVarManager with hardcoded defaults+ manager := NewEnvVarManager()++ // Simulate operator environment variables (Level 2)+ // In production, these would be set in the operator's deployment+ _ = os.Setenv("OPTLF_LANGFLOW_WORKERS", "8")+ _ = os.Setenv("OPTLF_LANGFLOW_LOG_LEVEL", "INFO")+ defer func() {+ _ = os.Unsetenv("OPTLF_LANGFLOW_WORKERS")+ _ = os.Unsetenv("OPTLF_LANGFLOW_LOG_LEVEL")+ }()++ // Simulate CR spec env vars (Level 3 - highest priority)+ crEnvVars := []corev1.EnvVar{+ {Name: "LANGFLOW_LOG_LEVEL", Value: "ERROR"},+ }++ // Get merged env vars with all three levels applied+ mergedEnvVars := manager.GetLangflowEnvVars(crEnvVars)++ // Check the results+ fmt.Printf("LANGFLOW_AUTO_LOGIN: %s (from defaults)\n", mergedEnvVars["LANGFLOW_AUTO_LOGIN"])+ fmt.Printf("LANGFLOW_WORKERS: %s (from operator env)\n", mergedEnvVars["LANGFLOW_WORKERS"])+ fmt.Printf("LANGFLOW_LOG_LEVEL: %s (from CR spec)\n", mergedEnvVars["LANGFLOW_LOG_LEVEL"])++ // Build the .env file content+ envFileContent := manager.BuildEnvFileContent(mergedEnvVars)+ fmt.Printf("\n.env file would contain %d bytes\n", len(envFileContent))++ // Output:+ // LANGFLOW_AUTO_LOGIN: true (from defaults)+ // LANGFLOW_WORKERS: 8 (from operator env)+ // LANGFLOW_LOG_LEVEL: ERROR (from CR spec)+ //+ // .env file would contain 1209 bytes+}++// Example showing how different components use different prefixes+func Example_componentSpecificPrefixes() {+ manager := &EnvVarManager{+ DefaultLangflowEnvVars: map[string]string{+ "WORKERS": "4",+ },+ DefaultOpenRagBEEnvVars: map[string]string{+ "WORKERS": "2",+ },+ DefaultOpenRagFEEnvVars: map[string]string{+ "WORKERS": "1",+ },+ }++ // Set operator env vars with different prefixes+ _ = os.Setenv("OPTLF_WORKERS", "langflow_8")+ _ = os.Setenv("OPTORBE_WORKERS", "backend_6")+ _ = os.Setenv("OPTORFE_WORKERS", "frontend_4")+ defer func() {+ _ = os.Unsetenv("OPTLF_WORKERS")+ _ = os.Unsetenv("OPTORBE_WORKERS")+ _ = os.Unsetenv("OPTORFE_WORKERS")+ }()++ // Each component gets its own prefix+ lfVars := manager.GetLangflowEnvVars(nil)+ beVars := manager.GetBackendEnvVars(nil)+ feVars := manager.GetFrontendEnvVars(nil)++ fmt.Printf("Langflow WORKERS: %s\n", lfVars["WORKERS"])+ fmt.Printf("Backend WORKERS: %s\n", beVars["WORKERS"])+ fmt.Printf("Frontend WORKERS: %s\n", feVars["WORKERS"])++ // Output:+ // Langflow WORKERS: langflow_8+ // Backend WORKERS: backend_6+ // Frontend WORKERS: frontend_4+}diff --git a/kubernetes/operator/internal/controller/env_test.go b/kubernetes/operator/internal/controller/env_test.gonew file mode 100644index 000000000..75f1a43aa--- /dev/null+++ b/kubernetes/operator/internal/controller/env_test.go@@ -0,0 +1,210 @@+package controller++import (+ "os"+ "testing"++ "github.com/stretchr/testify/assert"+ corev1 "k8s.io/api/core/v1"+)++func TestEnvVarManager_ThreeLevelPriority(t *testing.T) {+ // Create a manager with some defaults+ manager := &EnvVarManager{+ DefaultLangflowEnvVars: map[string]string{+ "VAR_A": "default_a",+ "VAR_B": "default_b",+ "VAR_C": "default_c",+ },+ }++ // Set up operator environment variables (level 2)+ _ = os.Setenv("OPTLF_VAR_B", "operator_b")+ _ = os.Setenv("OPTLF_VAR_C", "operator_c")+ defer func() {+ _ = os.Unsetenv("OPTLF_VAR_B")+ _ = os.Unsetenv("OPTLF_VAR_C")+ }()++ // CR spec env vars (level 3 - highest priority)+ crEnvVars := []corev1.EnvVar{+ {Name: "VAR_C", Value: "cr_c"},+ }++ result := manager.GetLangflowEnvVars(crEnvVars)++ // Verify priority:+ // VAR_A: only in defaults -> should be "default_a"+ // VAR_B: in defaults and operator env -> should be "operator_b"+ // VAR_C: in all three levels -> should be "cr_c" (highest priority)+ assert.Equal(t, "default_a", result["VAR_A"], "VAR_A should use default value")+ assert.Equal(t, "operator_b", result["VAR_B"], "VAR_B should use operator env value")+ assert.Equal(t, "cr_c", result["VAR_C"], "VAR_C should use CR value (highest priority)")+}++func TestEnvVarManager_OperatorEnvPrefixFiltering(t *testing.T) {+ manager := &EnvVarManager{+ DefaultLangflowEnvVars: map[string]string{+ "TEST_VAR": "default",+ },+ }++ // Set various env vars - only OPTLF_ should be picked up+ _ = os.Setenv("OPTLF_TEST_VAR", "langflow_value")+ _ = os.Setenv("OPTORBE_TEST_VAR", "backend_value")+ _ = os.Setenv("OPTORFE_TEST_VAR", "frontend_value")+ _ = os.Setenv("RANDOM_VAR", "random_value")+ defer func() {+ _ = os.Unsetenv("OPTLF_TEST_VAR")+ _ = os.Unsetenv("OPTORBE_TEST_VAR")+ _ = os.Unsetenv("OPTORFE_TEST_VAR")+ _ = os.Unsetenv("RANDOM_VAR")+ }()++ // Test Langflow - should only pick up OPTLF_+ lfResult := manager.GetLangflowEnvVars(nil)+ assert.Equal(t, "langflow_value", lfResult["TEST_VAR"], "Langflow should use OPTLF_ prefixed var")++ // Test Backend - should only pick up OPTORBE_+ manager.DefaultOpenRagBEEnvVars = map[string]string{"TEST_VAR": "default"}+ beResult := manager.GetBackendEnvVars(nil)+ assert.Equal(t, "backend_value", beResult["TEST_VAR"], "Backend should use OPTORBE_ prefixed var")++ // Test Frontend - should only pick up OPTORFE_+ manager.DefaultOpenRagFEEnvVars = map[string]string{"TEST_VAR": "default"}+ feResult := manager.GetFrontendEnvVars(nil)+ assert.Equal(t, "frontend_value", feResult["TEST_VAR"], "Frontend should use OPTORFE_ prefixed var")+}++func TestEnvVarManager_CREnvVarOverride(t *testing.T) {+ manager := &EnvVarManager{+ DefaultLangflowEnvVars: map[string]string{+ "DATABASE_URL": "sqlite:///default.db",+ "LOG_LEVEL": "INFO",+ },+ }++ _ = os.Setenv("OPTLF_DATABASE_URL", "sqlite:///operator.db")+ defer func() {+ _ = os.Unsetenv("OPTLF_DATABASE_URL")+ }()++ // CR overrides everything+ crEnvVars := []corev1.EnvVar{+ {Name: "DATABASE_URL", Value: "postgresql://cr.db"},+ {Name: "LOG_LEVEL", Value: "DEBUG"},+ }++ result := manager.GetLangflowEnvVars(crEnvVars)++ assert.Equal(t, "postgresql://cr.db", result["DATABASE_URL"], "CR should override operator env")+ assert.Equal(t, "DEBUG", result["LOG_LEVEL"], "CR should override defaults")+}++func TestEnvVarManager_EmptyCREnvVars(t *testing.T) {+ manager := &EnvVarManager{+ DefaultLangflowEnvVars: map[string]string{+ "VAR1": "default1",+ },+ }++ result := manager.GetLangflowEnvVars(nil)+ assert.Equal(t, "default1", result["VAR1"], "Should use defaults when no CR env vars")++ result = manager.GetLangflowEnvVars([]corev1.EnvVar{})+ assert.Equal(t, "default1", result["VAR1"], "Should use defaults when empty CR env vars")+}++func TestEnvVarManager_CREnvVarWithValueFrom(t *testing.T) {+ manager := &EnvVarManager{+ DefaultLangflowEnvVars: map[string]string{+ "SECRET_KEY": "default_secret",+ },+ }++ // CR env var with valueFrom should be ignored (can't be evaluated in this context)+ crEnvVars := []corev1.EnvVar{+ {+ Name: "SECRET_KEY",+ ValueFrom: &corev1.EnvVarSource{+ SecretKeyRef: &corev1.SecretKeySelector{+ LocalObjectReference: corev1.LocalObjectReference{Name: "my-secret"},+ Key: "key",+ },+ },+ },+ }++ result := manager.GetLangflowEnvVars(crEnvVars)+ // Should keep default since valueFrom can't be evaluated here+ assert.Equal(t, "default_secret", result["SECRET_KEY"], "Should keep default when CR has valueFrom")+}++func TestEnvVarManager_BuildEnvFileContent(t *testing.T) {+ manager := &EnvVarManager{}++ envVars := map[string]string{+ "VAR1": "value1",+ "VAR2": "value2",+ "VAR3": "value3",+ }++ content := manager.BuildEnvFileContent(envVars)++ // Should contain all three vars in key=value format+ assert.Contains(t, content, "VAR1=value1")+ assert.Contains(t, content, "VAR2=value2")+ assert.Contains(t, content, "VAR3=value3")++ // Should have newlines+ assert.Contains(t, content, "\n")+}++func TestEnvVarManager_RealWorldScenario(t *testing.T) {+ // Simulate a real deployment scenario+ manager := NewEnvVarManager()++ // Operator running with some env vars set+ _ = os.Setenv("OPTLF_LANGFLOW_WORKERS", "8")+ _ = os.Setenv("OPTLF_LANGFLOW_LOG_LEVEL", "INFO")+ defer func() {+ _ = os.Unsetenv("OPTLF_LANGFLOW_WORKERS")+ _ = os.Unsetenv("OPTLF_LANGFLOW_LOG_LEVEL")+ }()++ // User's CR overrides LOG_LEVEL+ crEnvVars := []corev1.EnvVar{+ {Name: "LANGFLOW_LOG_LEVEL", Value: "ERROR"},+ }++ result := manager.GetLangflowEnvVars(crEnvVars)++ // Verify the three-level priority worked correctly+ assert.Equal(t, "true", result["LANGFLOW_AUTO_LOGIN"], "Default should be used")+ assert.Equal(t, "8", result["LANGFLOW_WORKERS"], "Operator env should override default")+ assert.Equal(t, "ERROR", result["LANGFLOW_LOG_LEVEL"], "CR should override operator env")+}++func TestEnvVarManager_NewEnvVarManagerDefaults(t *testing.T) {+ manager := NewEnvVarManager()++ // Verify Langflow defaults+ assert.NotNil(t, manager.DefaultLangflowEnvVars)+ assert.Equal(t, "sqlite:////app/data/langflow.db", manager.DefaultLangflowEnvVars["LANGFLOW_DATABASE_URL"])+ assert.Equal(t, "true", manager.DefaultLangflowEnvVars["LANGFLOW_AUTO_LOGIN"])+ assert.Equal(t, "/app/flows", manager.DefaultLangflowEnvVars["LANGFLOW_LOAD_FLOWS_PATH"])+ assert.Equal(t, "4", manager.DefaultLangflowEnvVars["LANGFLOW_WORKERS"])++ // Verify Backend defaults+ assert.NotNil(t, manager.DefaultOpenRagBEEnvVars)+ assert.Equal(t, "2400", manager.DefaultOpenRagBEEnvVars["LANGFLOW_TIMEOUT"])+ assert.Equal(t, "/app/backend-data", manager.DefaultOpenRagBEEnvVars["OPENRAG_DATA_PATH"])+ assert.Equal(t, "/app/openrag-documents", manager.DefaultOpenRagBEEnvVars["OPENRAG_DOCUMENTS_PATH"])+ assert.Equal(t, "DEBUG", manager.DefaultOpenRagBEEnvVars["LOG_LEVEL"])+ assert.Equal(t, "json", manager.DefaultOpenRagBEEnvVars["LOG_FORMAT"])+ assert.Equal(t, "3600", manager.DefaultOpenRagBEEnvVars["INGESTION_TIMEOUT"])+ assert.Equal(t, "4", manager.DefaultOpenRagBEEnvVars["MAX_WORKERS"])++ // Verify Frontend defaults (empty for now)+ assert.NotNil(t, manager.DefaultOpenRagFEEnvVars)+}diff --git a/kubernetes/operator/internal/controller/openrag_controller.go b/kubernetes/operator/internal/controller/openrag_controller.goindex 6f8fcb744..e5d9ca534 100644--- a/kubernetes/operator/internal/controller/openrag_controller.go+++ b/kubernetes/operator/internal/controller/openrag_controller.go@@ -8,7 +8,6 @@ import ("encoding/hex""encoding/json""fmt"- "strings"appsv1 "k8s.io/api/apps/v1"corev1 "k8s.io/api/core/v1"@@ -32,12 +31,17 @@ const (// OpenRAGReconciler reconciles an OpenRAG object.type OpenRAGReconciler struct {+ EnvVarManager *EnvVarManagerclient.ClientScheme *runtime.Scheme}func NewOpenRAGReconciler(c client.Client, s *runtime.Scheme) *OpenRAGReconciler {- return &OpenRAGReconciler{Client: c, Scheme: s}+ return &OpenRAGReconciler{+ EnvVarManager: NewEnvVarManager(),+ Client: c,+ Scheme: s,+ }}// +kubebuilder:rbac:groups=openr.ag,resources=openrags,verbs=get;list;watch;create;update;patch;delete@@ -242,100 +246,87 @@ func (r *OpenRAGReconciler) reconcileEnvSecrets(ctx context.Context, o *openragv}func (r *OpenRAGReconciler) buildBackendEnv(o *openragv1alpha1.OpenRAG) string {- var b strings.Builder- w := func(k, v string) { fmt.Fprintf(&b, "%s=%s\n", k, v) }+ // Start with defaults, operator env, and CR env (three-level priority)+ envVars := r.EnvVarManager.GetBackendEnvVars(o.Spec.Backend.Env)- // Operator-derived values- w("LANGFLOW_URL", "http://"+resourceName(o.Name, "lf")+":7860")+ // Operator-derived values (always set)+ envVars["LANGFLOW_URL"] = "http://" + resourceName(o.Name, "lf") + ":7860"+ // Override with CR-specific configurationif o.Spec.TenantID != "" {- w("TENANT_ID", o.Spec.TenantID)- }-- // Flow IDs- if f := o.Spec.Backend.FlowIDs; f != nil {- if f.Chat != "" {- w("LANGFLOW_CHAT_FLOW_ID", f.Chat)- }- if f.Ingest != "" {- w("LANGFLOW_INGEST_FLOW_ID", f.Ingest)- }- if f.URLIngest != "" {- w("LANGFLOW_URL_INGEST_FLOW_ID", f.URLIngest)- }- if f.Nudges != "" {- w("NUDGES_FLOW_ID", f.Nudges)- }+ envVars["TENANT_ID"] = o.Spec.TenantID}- // OpenSearch+ // OpenSearch configuration from CR specif os := o.Spec.OpenSearch; os != nil {- w("OPENSEARCH_HOST", os.Host)+ envVars["OPENSEARCH_HOST"] = os.Hostport := os.Portif port == 0 {port = 9200}- w("OPENSEARCH_PORT", fmt.Sprintf("%d", port))+ envVars["OPENSEARCH_PORT"] = fmt.Sprintf("%d", port)scheme := os.Schemeif scheme == "" {scheme = "https"}- w("OPENSEARCH_URL", fmt.Sprintf("%s://%s:%d", scheme, os.Host, port))+ envVars["OPENSEARCH_URL"] = fmt.Sprintf("%s://%s:%d", scheme, os.Host, port)if os.IndexName != "" {- w("OPENSEARCH_INDEX_NAME", os.IndexName)+ envVars["OPENSEARCH_INDEX_NAME"] = os.IndexName}// Username injected as env var from credentials secret when set;// fall back to the common default.if os.CredentialsSecret == "" {- w("OPENSEARCH_USERNAME", "admin")+ envVars["OPENSEARCH_USERNAME"] = "admin"}}- // WatsonX non-sensitive fields+ // WatsonX configuration from CR specif wx := o.Spec.WatsonX; wx != nil {if wx.Endpoint != "" {- w("WATSONX_ENDPOINT", wx.Endpoint)+ envVars["WATSONX_ENDPOINT"] = wx.Endpoint}if wx.ProjectID != "" {- w("WATSONX_PROJECT_ID", wx.ProjectID)+ envVars["WATSONX_PROJECT_ID"] = wx.ProjectID}}- // LLM / Embedding+ // LLM configuration from CR specif l := o.Spec.LLM; l != nil {if l.Provider != "" {- w("LLM_PROVIDER", l.Provider)+ envVars["LLM_PROVIDER"] = l.Provider}if l.Model != "" {- w("LLM_MODEL", l.Model)+ envVars["LLM_MODEL"] = l.Model}}++ // Embedding configuration from CR specif e := o.Spec.Embedding; e != nil {if e.Provider != "" {- w("EMBEDDING_PROVIDER", e.Provider)+ envVars["EMBEDDING_PROVIDER"] = e.Provider}if e.Model != "" {- w("EMBEDDING_MODEL", e.Model)+ envVars["EMBEDDING_MODEL"] = e.Model}}- // OAuth non-sensitive fields+ // OAuth configuration from CR specif o.Spec.Backend.IBMAuthEnabled {- w("IBM_AUTH_ENABLED", "true")+ envVars["IBM_AUTH_ENABLED"] = "true"}if o.Spec.Backend.OAuthBrokerURL != "" {- w("OAUTH_BROKER_URL", o.Spec.Backend.OAuthBrokerURL)+ envVars["OAUTH_BROKER_URL"] = o.Spec.Backend.OAuthBrokerURL}if oa := o.Spec.Backend.OAuth; oa != nil {if oa.Google != nil && oa.Google.ClientID != "" {- w("GOOGLE_OAUTH_CLIENT_ID", oa.Google.ClientID)+ envVars["GOOGLE_OAUTH_CLIENT_ID"] = oa.Google.ClientID}if oa.Microsoft != nil && oa.Microsoft.ClientID != "" {- w("MICROSOFT_GRAPH_OAUTH_CLIENT_ID", oa.Microsoft.ClientID)+ envVars["MICROSOFT_GRAPH_OAUTH_CLIENT_ID"] = oa.Microsoft.ClientID}}- // Docling+ // Docling configuration from CR specif d := o.Spec.Docling; d != nil {scheme := d.Schemeif scheme == "" {@@ -345,150 +336,72 @@ func (r *OpenRAGReconciler) buildBackendEnv(o *openragv1alpha1.OpenRAG) string {if port == 0 {port = 5001}- w("DOCLING_SERVE_URL", fmt.Sprintf("%s://%s:%d", scheme, d.Host, port))- }-- // Fixed runtime defaults- w("LANGFLOW_TIMEOUT", "2400")- w("LANGFLOW_CONNECT_TIMEOUT", "30")- w("INGESTION_TIMEOUT", "3600")- w("UPLOAD_BATCH_SIZE", "25")- w("LANGFLOW_KEY_RETRIES", "15")- w("LANGFLOW_KEY_RETRY_DELAY", "2")- w("LANGFLOW_KEY", "")- w("LANGFLOW_AUTO_LOGIN", "true")- w("OPENRAG_DATA_PATH", "/app/backend-data")- w("OPENRAG_DOCUMENTS_PATH", "/app/openrag-documents")- w("OPENRAG_DOCUMENT_PATH", "/app/openrag-documents")- w("OPENRAG_FLOWS_BACKUP_PATH", "/app/backend-data/flow-backups")- w("OPENRAG_KEYS_PATH", "/app/backend-data/keys")- w("OPENRAG_CONFIG_PATH", "/app/backend-data/config")- w("OPENRAG_VERSION", "latest")- w("OPENSEARCH_DATA_PATH", "./opensearch-data")- w("LOG_LEVEL", "DEBUG")- w("LOG_FORMAT", "json")- w("ACCESS_LOG", "true")- w("SERVICE_NAME", "openrag")- w("ENVIRONMENT", "development")- w("INGEST_SAMPLE_DATA", "true")- w("DISABLE_INGEST_WITH_LANGFLOW", "false")- w("MAX_WORKERS", "4")- w("SEGMENT_WRITE_KEY", "kUm1zOjl8CGbtMmEVOtmAaqyIpU7ExFb")-- return b.String()+ envVars["DOCLING_SERVE_URL"] = fmt.Sprintf("%s://%s:%d", scheme, d.Host, port)+ }++ // Convert map to .env file format+ return r.EnvVarManager.BuildEnvFileContent(envVars)}func (r *OpenRAGReconciler) buildLangflowEnv(o *openragv1alpha1.OpenRAG) string {- var b strings.Builder- w := func(k, v string) { fmt.Fprintf(&b, "%s=%s\n", k, v) }+ // Start with defaults, operator env, and CR env (three-level priority)+ envVars := r.EnvVarManager.GetLangflowEnvVars(o.Spec.Langflow.Env)+ // Override with CR-specific configurationif o.Spec.TenantID != "" {- w("TENANT_ID", o.Spec.TenantID)+ envVars["TENANT_ID"] = o.Spec.TenantID}- // OpenSearch+ // OpenSearch configuration from CR specif os := o.Spec.OpenSearch; os != nil {- w("OPENSEARCH_HOST", os.Host)+ envVars["OPENSEARCH_HOST"] = os.Hostport := os.Portif port == 0 {port = 9200}- w("OPENSEARCH_PORT", fmt.Sprintf("%d", port))+ envVars["OPENSEARCH_PORT"] = fmt.Sprintf("%d", port)scheme := os.Schemeif scheme == "" {scheme = "https"}- w("OPENSEARCH_URL", fmt.Sprintf("%s://%s:%d", scheme, os.Host, port))+ envVars["OPENSEARCH_URL"] = fmt.Sprintf("%s://%s:%d", scheme, os.Host, port)if os.IndexName != "" {- w("OPENSEARCH_INDEX_NAME", os.IndexName)+ envVars["OPENSEARCH_INDEX_NAME"] = os.IndexName}}- // WatsonX non-sensitive fields+ // WatsonX configuration from CR specif wx := o.Spec.WatsonX; wx != nil {if wx.Endpoint != "" {- w("WATSONX_ENDPOINT", wx.Endpoint)+ envVars["WATSONX_ENDPOINT"] = wx.Endpoint}if wx.ProjectID != "" {- w("WATSONX_PROJECT_ID", wx.ProjectID)+ envVars["WATSONX_PROJECT_ID"] = wx.ProjectID}}- // LLM / Embedding+ // LLM configuration from CR specif l := o.Spec.LLM; l != nil {if l.Provider != "" {- w("LLM_PROVIDER", l.Provider)+ envVars["LLM_PROVIDER"] = l.Provider}if l.Model != "" {- w("LLM_MODEL", l.Model)+ envVars["LLM_MODEL"] = l.Model}}++ // Embedding configuration from CR specif e := o.Spec.Embedding; e != nil {if e.Provider != "" {- w("EMBEDDING_PROVIDER", e.Provider)+ envVars["EMBEDDING_PROVIDER"] = e.Provider}if e.Model != "" {- w("EMBEDDING_MODEL", e.Model)+ envVars["EMBEDDING_MODEL"] = e.Model}}- // Docling- if d := o.Spec.Docling; d != nil {- scheme := d.Scheme- if scheme == "" {- scheme = "http"- }- port := d.Port- if port == 0 {- port = 5001- }- w("DOCLING_SERVE_URL", fmt.Sprintf("%s://%s:%d", scheme, d.Host, port))- }-- // Database URL- dbURL := o.Spec.Langflow.DatabaseURL- if dbURL == "" {- dbURL = "sqlite:////app/data/langflow.db"- }- w("LANGFLOW_DATABASE_URL", dbURL)-- // Fixed runtime defaults- w("LANGFLOW_VARIABLES_TO_GET_FROM_ENVIRONMENT", "JWT,OPENRAG_QUERY_FILTER,OPENSEARCH_PASSWORD,OPENSEARCH_URL,OPENSEARCH_INDEX_NAME,DOCLING_SERVE_URL,OWNER,OWNER_NAME,OWNER_EMAIL,CONNECTOR_TYPE,DOCUMENT_ID,SOURCE_URL,ALLOWED_USERS,ALLOWED_GROUPS,FILENAME,MIMETYPE,FILESIZE,SELECTED_EMBEDDING_MODEL,OPENAI_API_KEY,ANTHROPIC_API_KEY,WATSONX_API_KEY,WATSONX_ENDPOINT,WATSONX_PROJECT_ID,OLLAMA_BASE_URL")- w("LANGFLOW_SKIP_AUTH_AUTO_LOGIN", "true")- w("LANGFLOW_NEW_USER_IS_ACTIVE", "false")- w("LANGFLOW_WORKERS", "4")- w("LANGFLOW_CONFIG_DIR", "/tmp")- w("LANGFLOW_LOG_LEVEL", "DEBUG")- w("HIDE_GETTING_STARTED_PROGRESS", "true")- w("LANGFLOW_AUTO_LOGIN", "true")- w("LANGFLOW_ENABLE_SUPERUSER_CLI", "false")- w("LANGFLOW_ALEMBIC_LOG_TO_STDOUT", "true")- w("LANGFLOW_DEACTIVATE_TRACING", "true")- w("LANGFLOW_LOAD_FLOWS_PATH", "/app/flows")- w("LANGFUSE_HOST", "https://cloud.langfuse.com")- w("LANGFLOW_KEY_RETRIES", "15")- w("LANGFLOW_KEY_RETRY_DELAY", "2")- // Flow context defaults- w("JWT", "None")- w("OWNER", "None")- w("OWNER_NAME", "None")- w("OWNER_EMAIL", "None")- w("CONNECTOR_TYPE", "system")- w("CONNECTOR_TYPE_URL", "url")- w("DOCUMENT_ID", "")- w("SOURCE_URL", "")- w("ALLOWED_USERS", "[]")- w("ALLOWED_GROUPS", "[]")- w("OPENRAG_QUERY_FILTER", "{}")- w("FILENAME", "None")- w("MIMETYPE", "None")- w("FILESIZE", "0")- w("SELECTED_EMBEDDING_MODEL", "")- w("OPENAI_API_KEY", "None")- w("ANTHROPIC_API_KEY", "None")- w("OLLAMA_BASE_URL", "None")-- return b.String()+ // Convert map to .env file format+ return r.EnvVarManager.BuildEnvFileContent(envVars)}func (r *OpenRAGReconciler) reconcilePVCs(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {