OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
feat: Operator config and new domain name (#1509)
mingcb5acc049792
diff --git a/.github/workflows/operator-ci.yml b/.github/workflows/operator-ci.ymlindex 2c72188f9..612483d3f 100644--- a/.github/workflows/operator-ci.yml+++ b/.github/workflows/operator-ci.yml@@ -54,6 +54,9 @@ jobs:./bin/controller-gen object:headerFile="hack/boilerplate.go.txt" paths="./..."git diff --exit-code api/+ - name: go test+ run: go test ./... -race -coverprofile=cover.out+- name: golangci-lintuses: golangci/golangci-lint-action@v7with:diff --git a/kubernetes/operator/PROJECT b/kubernetes/operator/PROJECTindex 1fafb9457..e5bd12dbe 100644--- a/kubernetes/operator/PROJECT+++ b/kubernetes/operator/PROJECT@@ -2,7 +2,7 @@# This file is used to track the info used to scaffold your project# and allow the plugins properly work.# More info: https://book.kubebuilder.io/reference/project-config.html-domain: openrag.io+domain: openr.aglayout:- go.kubebuilder.io/v4projectName: openrag-operator@@ -12,7 +12,7 @@ resources:crdVersion: v1namespaced: truecontroller: true- domain: openrag.io+ domain: openr.aggroup: openragkind: OpenRAGpath: github.com/langflow-ai/openrag-operator/api/v1alpha1diff --git a/kubernetes/operator/README.md b/kubernetes/operator/README.mdindex f41726b2a..f8d04b4a6 100644--- a/kubernetes/operator/README.md+++ b/kubernetes/operator/README.md@@ -9,6 +9,50 @@ External dependencies (OpenSearch, Docling) are referenced by connection config- Go 1.26.0 (`gvm use go1.26.0`)- kubectl pointed at a cluster+## Local development cluster (kind + podman)++### 1. Start the podman machine++```bash+podman machine start+```++### 2. Configure kind to use podman++```bash+export KIND_EXPERIMENTAL_PROVIDER=podman+```++Add this to your shell profile (`~/.zshrc` or `~/.bashrc`) to make it permanent.++### 3. Create the cluster++```bash+kind create cluster --name openrag+```++Verify it is running:++```bash+kubectl cluster-info --context kind-openrag+kubectl get nodes+```++### 4. Load a locally built operator image (optional)++If you built the image locally instead of pulling from GHCR:++```bash+make docker-build IMG=openrag-operator:dev+podman save openrag-operator:dev | kind load image-archive /dev/stdin --name openrag+```++### 5. Tear down++```bash+kind delete cluster --name openrag+```+## Quick start```bash@@ -30,7 +74,7 @@ kubectl get openrag## CR overview```yaml-apiVersion: openrag.io/v1alpha1+apiVersion: openr.ag/v1alpha1kind: OpenRAGmetadata:name: my-openragdiff --git a/kubernetes/operator/api/v1alpha1/groupversion_info.go b/kubernetes/operator/api/v1alpha1/groupversion_info.goindex bd038bd81..50ab17b42 100644--- a/kubernetes/operator/api/v1alpha1/groupversion_info.go+++ b/kubernetes/operator/api/v1alpha1/groupversion_info.go@@ -1,6 +1,6 @@-// Package v1alpha1 contains API Schema definitions for the openrag.io v1alpha1 API group.+// Package v1alpha1 contains API Schema definitions for the openr.ag v1alpha1 API group.// +kubebuilder:object:generate=true-// +groupName=openrag.io+// +groupName=openr.agpackage v1alpha1import (@@ -9,7 +9,7 @@ import ()var (- GroupVersion = schema.GroupVersion{Group: "openrag.io", Version: "v1alpha1"}+ GroupVersion = schema.GroupVersion{Group: "openr.ag", Version: "v1alpha1"}SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion}AddToScheme = SchemeBuilder.AddToScheme)diff --git a/kubernetes/operator/api/v1alpha1/openrag_types.go b/kubernetes/operator/api/v1alpha1/openrag_types.goindex 02c65d418..444dc7686 100644--- a/kubernetes/operator/api/v1alpha1/openrag_types.go+++ b/kubernetes/operator/api/v1alpha1/openrag_types.go@@ -149,6 +149,14 @@ type NetworkPolicySpec struct {// OpenRAGSpec defines the desired state of an OpenRAG instance.type OpenRAGSpec struct {+ // TargetNamespace is the namespace where all OpenRAG resources (deployments,+ // services, service accounts) are created. The operator creates this namespace+ // if it does not exist and deletes it when the CR is deleted.+ // Defaults to the namespace of the CR itself. Cannot be "default".+ // +optional+ // +kubebuilder:validation:XValidation:rule="self != 'default'",message="targetNamespace must not be 'default'"+ TargetNamespace string `json:"targetNamespace,omitempty"`+// ImagePullSecrets for private registries, applied to all component pods.// +optionalImagePullSecrets []corev1.LocalObjectReference `json:"imagePullSecrets,omitempty"`diff --git a/kubernetes/operator/cmd/main.go b/kubernetes/operator/cmd/main.goindex 8b5bc0894..c834f6aed 100644--- a/kubernetes/operator/cmd/main.go+++ b/kubernetes/operator/cmd/main.go@@ -16,6 +16,7 @@ import (metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server"openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ "github.com/langflow-ai/openrag-operator/internal/config""github.com/langflow-ai/openrag-operator/internal/controller")@@ -33,35 +34,26 @@ func init() {}func main() {- var metricsAddr string- var enableLeaderElection bool- var probeAddr string-- flag.StringVar(&metricsAddr, "metrics-bind-address", ":8080", "The address the metric endpoint binds to.")- flag.StringVar(&probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.")- flag.BoolVar(&enableLeaderElection, "leader-elect", false, "Enable leader election for controller manager.")+ cfg := config.NewOperatorConfig()opts := zap.Options{Development: true}opts.BindFlags(flag.CommandLine)- flag.Parse()ctrl.SetLogger(zap.New(zap.UseFlagOptions(&opts)))mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{Scheme: scheme,- Metrics: metricsserver.Options{BindAddress: metricsAddr},- HealthProbeBindAddress: probeAddr,- LeaderElection: enableLeaderElection,- LeaderElectionID: "openrag-operator.openrag.io",+ Metrics: metricsserver.Options{BindAddress: cfg.MetricsBindAddress},+ HealthProbeBindAddress: cfg.HealthProbeBindAddress,+ LeaderElection: cfg.LeaderElectionEnabled,+ LeaderElectionID: "openrag-operator.openr.ag",})if err != nil {setupLog.Error(err, "unable to start manager")os.Exit(1)}- if err = (&controller.OpenRAGReconciler{- Client: mgr.GetClient(),- Scheme: mgr.GetScheme(),- }).SetupWithManager(mgr); err != nil {+ err = controller.NewOpenRAGReconciler(mgr.GetClient(), mgr.GetScheme()).SetupWithManager(mgr)+ if err != nil {setupLog.Error(err, "unable to create controller", "controller", "OpenRAG")os.Exit(1)}diff --git a/kubernetes/operator/config/crd/bases/openrag.io_openrags.yaml b/kubernetes/operator/config/crd/bases/openr.ag_openrags.yamlsimilarity index 99%rename from kubernetes/operator/config/crd/bases/openrag.io_openrags.yamlrename to kubernetes/operator/config/crd/bases/openr.ag_openrags.yamlindex 93e162463..41f5d13ff 100644--- a/kubernetes/operator/config/crd/bases/openrag.io_openrags.yaml+++ b/kubernetes/operator/config/crd/bases/openr.ag_openrags.yaml@@ -4,9 +4,9 @@ kind: CustomResourceDefinitionmetadata:annotations:controller-gen.kubebuilder.io/version: v0.16.4- name: openrags.openrag.io+ name: openrags.openr.agspec:- group: openrag.io+ group: openr.agnames:kind: OpenRAGlistKind: OpenRAGList@@ -3693,6 +3693,16 @@ spec:required:- hosttype: object+ targetNamespace:+ description: |-+ TargetNamespace is the namespace where all OpenRAG resources (deployments,+ services, service accounts) are created. The operator creates this namespace+ if it does not exist and deletes it when the CR is deleted.+ Defaults to the namespace of the CR itself. Cannot be "default".+ type: string+ x-kubernetes-validations:+ - message: targetNamespace must not be 'default'+ rule: self != 'default'required:- backend- frontenddiff --git a/kubernetes/operator/config/crd/kustomization.yaml b/kubernetes/operator/config/crd/kustomization.yamlindex 6737d1d1d..946d421b9 100644--- a/kubernetes/operator/config/crd/kustomization.yaml+++ b/kubernetes/operator/config/crd/kustomization.yaml@@ -1,5 +1,5 @@resources:-- bases/openrag.io_openrags.yaml+- bases/openr.ag_openrags.yaml#+kubebuilder:scaffold:crdkustomizeresourcepatches:diff --git a/kubernetes/operator/config/rbac/role.yaml b/kubernetes/operator/config/rbac/role.yamlindex de6c87fe8..067febe1e 100644--- a/kubernetes/operator/config/rbac/role.yaml+++ b/kubernetes/operator/config/rbac/role.yaml@@ -4,6 +4,16 @@ kind: ClusterRolemetadata:name: manager-rolerules:+- apiGroups:+ - ""+ resources:+ - namespaces+ verbs:+ - create+ - delete+ - get+ - list+ - watch- apiGroups:- ""resources:@@ -44,7 +54,7 @@ rules:- update- watch- apiGroups:- - openrag.io+ - openr.agresources:- openragsverbs:@@ -56,13 +66,13 @@ rules:- update- watch- apiGroups:- - openrag.io+ - openr.agresources:- openrags/finalizersverbs:- update- apiGroups:- - openrag.io+ - openr.agresources:- openrags/statusverbs:diff --git a/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yaml b/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yamlindex fce3e6eb1..78fdccb41 100644--- a/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yaml+++ b/kubernetes/operator/config/samples/openrag_v1alpha1_openrag.yaml@@ -1,4 +1,4 @@-apiVersion: openrag.io/v1alpha1+apiVersion: openr.ag/v1alpha1kind: OpenRAGmetadata:name: my-openragdiff --git a/kubernetes/operator/go.mod b/kubernetes/operator/go.modindex 820aeeaf4..2bd836ec7 100644--- a/kubernetes/operator/go.mod+++ b/kubernetes/operator/go.mod@@ -3,6 +3,7 @@ module github.com/langflow-ai/openrag-operatorgo 1.26.0require (+ github.com/stretchr/testify v1.11.1k8s.io/api v0.33.2k8s.io/apimachinery v0.33.2k8s.io/client-go v0.33.2@@ -34,6 +35,7 @@ require (github.com/modern-go/reflect2 v1.0.2 // indirectgithub.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirectgithub.com/pkg/errors v0.9.1 // indirect+ github.com/pmezard/go-difflib v1.0.0 // indirectgithub.com/prometheus/client_golang v1.22.0 // indirectgithub.com/prometheus/client_model v0.6.1 // indirectgithub.com/prometheus/common v0.62.0 // indirectdiff --git a/kubernetes/operator/go.sum b/kubernetes/operator/go.sumindex dfd366168..bd5293434 100644--- a/kubernetes/operator/go.sum+++ b/kubernetes/operator/go.sum@@ -103,8 +103,8 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVgithub.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=diff --git a/kubernetes/operator/internal/config/config.go b/kubernetes/operator/internal/config/config.gonew file mode 100644index 000000000..9abb882a7--- /dev/null+++ b/kubernetes/operator/internal/config/config.go@@ -0,0 +1,46 @@+package config++import (+ "os"+ "strings"+)++const (+ DefaultNamespace = "openrag-control"+ metricsBindAddressEnv = "METRICS_BIND_ADDRESS"+ healthProbeBindAddressEnv = "HEALTH_PROBE_BIND_ADDRESS"+ leaderElectionNamespaceEnv = "LEADER_ELECTION_NAMESPACE"+ enableHTTP2Env = "ENABLE_HTTP2"+ secureMetricsEnv = "SECURE_METRICS"+ environment = "Environment"+)++type OperatorConfig struct {+ HealthProbeBindAddress string+ MetricsBindAddress string+ LeaderElectionNamespace string+ LeaderElectionEnabled bool+ EnableHTTP2 bool+ SecureMetrics bool+ Environment string+}++func NewOperatorConfig() OperatorConfig {+ return OperatorConfig{+ MetricsBindAddress: getEnv(metricsBindAddressEnv, ":9090"),+ HealthProbeBindAddress: getEnv(healthProbeBindAddressEnv, ":8080"),+ LeaderElectionNamespace: getEnv(leaderElectionNamespaceEnv, ""),+ LeaderElectionEnabled: getEnv(leaderElectionNamespaceEnv, "") != "",+ EnableHTTP2: strings.ToLower(getEnv(enableHTTP2Env, "false")) == "true",+ SecureMetrics: strings.ToLower(getEnv(secureMetricsEnv, "false")) == "true",+ Environment: getEnv(environment, "dev"),+ }+}++// getEnv reads an environment variable or returns a default value+func getEnv(key, defaultValue string) string {+ if value, exists := os.LookupEnv(key); exists {+ return value+ }+ return defaultValue+}diff --git a/kubernetes/operator/internal/controller/openrag_controller.go b/kubernetes/operator/internal/controller/openrag_controller.goindex dc73eeae8..cabdbb8d6 100644--- a/kubernetes/operator/internal/controller/openrag_controller.go+++ b/kubernetes/operator/internal/controller/openrag_controller.go@@ -13,21 +13,29 @@ import ("k8s.io/apimachinery/pkg/util/intstr"ctrl "sigs.k8s.io/controller-runtime""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")+const finalizer = "openr.ag/namespace-cleanup"+// OpenRAGReconciler reconciles an OpenRAG object.type OpenRAGReconciler struct {client.ClientScheme *runtime.Scheme}-// +kubebuilder:rbac:groups=openrag.io,resources=openrags,verbs=get;list;watch;create;update;patch;delete-// +kubebuilder:rbac:groups=openrag.io,resources=openrags/status,verbs=get;update;patch-// +kubebuilder:rbac:groups=openrag.io,resources=openrags/finalizers,verbs=update+func NewOpenRAGReconciler(c client.Client, s *runtime.Scheme) *OpenRAGReconciler {+ return &OpenRAGReconciler{Client: c, Scheme: s}+}++// +kubebuilder:rbac:groups=openr.ag,resources=openrags,verbs=get;list;watch;create;update;patch;delete+// +kubebuilder:rbac:groups=openr.ag,resources=openrags/status,verbs=get;update;patch+// +kubebuilder:rbac:groups=openr.ag,resources=openrags/finalizers,verbs=update// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete+// +kubebuilder:rbac:groups=core,resources=namespaces,verbs=get;list;watch;create;delete// +kubebuilder:rbac:groups=core,resources=services,verbs=get;list;watch;create;update;patch;delete// +kubebuilder:rbac:groups=core,resources=serviceaccounts,verbs=get;list;watch;create;update;patch;delete// +kubebuilder:rbac:groups=core,resources=secrets,verbs=get;list;watch;create;update;patch;delete@@ -45,35 +53,104 @@ func (r *OpenRAGReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctreturn ctrl.Result{}, err}- if err := r.reconcileServiceAccounts(ctx, instance); err != nil {+ // Handle deletion when a TargetNamespace was managed by the operator.+ if !instance.DeletionTimestamp.IsZero() {+ return ctrl.Result{}, r.handleDeletion(ctx, instance)+ }++ // Add finalizer when we own a target namespace distinct from the CR namespace.+ if instance.Spec.TargetNamespace != "" && instance.Spec.TargetNamespace != instance.Namespace {+ if !controllerutil.ContainsFinalizer(instance, finalizer) {+ controllerutil.AddFinalizer(instance, finalizer)+ if err := r.Update(ctx, instance); err != nil {+ return ctrl.Result{}, err+ }+ }+ }++ targetNS := targetNamespace(instance)++ if err := r.reconcileNamespace(ctx, instance, targetNS); err != nil {+ return ctrl.Result{}, fmt.Errorf("namespace: %w", err)+ }+ if err := r.reconcileServiceAccounts(ctx, instance, targetNS); err != nil {return ctrl.Result{}, fmt.Errorf("service accounts: %w", err)}- if err := r.reconcileServices(ctx, instance); err != nil {+ if err := r.reconcileServices(ctx, instance, targetNS); err != nil {return ctrl.Result{}, fmt.Errorf("services: %w", err)}- if err := r.reconcileDeployments(ctx, instance); err != nil {+ if err := r.reconcileDeployments(ctx, instance, targetNS); err != nil {return ctrl.Result{}, fmt.Errorf("deployments: %w", err)}if instance.Spec.NetworkPolicy.Enabled {- if err := r.reconcileNetworkPolicy(ctx, instance); err != nil {+ if err := r.reconcileNetworkPolicy(ctx, instance, targetNS); err != nil {return ctrl.Result{}, fmt.Errorf("network policy: %w", err)}}- logger.Info("reconciled OpenRAG instance", "name", instance.Name)+ logger.Info("reconciled OpenRAG instance", "name", instance.Name, "targetNamespace", targetNS)return ctrl.Result{}, nil}-func (r *OpenRAGReconciler) reconcileServiceAccounts(ctx context.Context, o *openragv1alpha1.OpenRAG) error {+// handleDeletion removes the target namespace (and all resources within it) when+// the CR is deleted, then strips the finalizer so the CR itself can be removed.+func (r *OpenRAGReconciler) handleDeletion(ctx context.Context, o *openragv1alpha1.OpenRAG) error {+ if !controllerutil.ContainsFinalizer(o, finalizer) {+ return nil+ }++ ns := &corev1.Namespace{}+ err := r.Get(ctx, client.ObjectKey{Name: o.Spec.TargetNamespace}, ns)+ if err != nil && !errors.IsNotFound(err) {+ return err+ }+ if err == nil {+ // Only delete if the namespace was created by this operator for this CR.+ if ns.Labels[managedByLabel] == o.Name {+ if err := r.Delete(ctx, ns); err != nil && !errors.IsNotFound(err) {+ return err+ }+ }+ }++ controllerutil.RemoveFinalizer(o, finalizer)+ return r.Update(ctx, o)+}++// reconcileNamespace ensures the target namespace exists, labelled as managed by+// this CR. It is a no-op when targetNS equals the CR's own namespace.+func (r *OpenRAGReconciler) reconcileNamespace(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {+ if targetNS == o.Namespace {+ return nil+ }++ ns := &corev1.Namespace{}+ err := r.Get(ctx, client.ObjectKey{Name: targetNS}, ns)+ if errors.IsNotFound(err) {+ ns = &corev1.Namespace{+ ObjectMeta: metav1.ObjectMeta{+ Name: targetNS,+ Labels: map[string]string{+ managedByLabel: o.Name,+ "app.kubernetes.io/managed-by": "openrag-operator",+ },+ },+ }+ return r.Create(ctx, ns)+ }+ return err+}++func (r *OpenRAGReconciler) reconcileServiceAccounts(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {for _, role := range []string{"fe", "be", "lf"} {sa := &corev1.ServiceAccount{ObjectMeta: metav1.ObjectMeta{Name: saName(o.Name, role),- Namespace: o.Namespace,+ Namespace: targetNS,Labels: componentLabels(o.Name, role),},}- if err := ctrl.SetControllerReference(o, sa, r.Scheme); err != nil {+ if err := r.setOwnerOrLabel(o, sa, targetNS); err != nil {return err}if err := r.createOrUpdate(ctx, sa); err != nil {@@ -83,7 +160,7 @@ func (r *OpenRAGReconciler) reconcileServiceAccounts(ctx context.Context, o *opereturn nil}-func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1alpha1.OpenRAG) error {+func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {type svcDef struct {role stringport int32@@ -97,7 +174,7 @@ func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1asvc := &corev1.Service{ObjectMeta: metav1.ObjectMeta{Name: resourceName(o.Name, d.role),- Namespace: o.Namespace,+ Namespace: targetNS,Labels: componentLabels(o.Name, d.role),},Spec: corev1.ServiceSpec{@@ -108,7 +185,7 @@ func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1a},},}- if err := ctrl.SetControllerReference(o, svc, r.Scheme); err != nil {+ if err := r.setOwnerOrLabel(o, svc, targetNS); err != nil {return err}if err := r.createOrUpdate(ctx, svc); err != nil {@@ -118,14 +195,14 @@ func (r *OpenRAGReconciler) reconcileServices(ctx context.Context, o *openragv1areturn nil}-func (r *OpenRAGReconciler) reconcileDeployments(ctx context.Context, o *openragv1alpha1.OpenRAG) error {+func (r *OpenRAGReconciler) reconcileDeployments(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {deploys := []client.Object{- r.frontendDeployment(o),- r.backendDeployment(o),- r.langflowDeployment(o),+ r.frontendDeployment(o, targetNS),+ r.backendDeployment(o, targetNS),+ r.langflowDeployment(o, targetNS),}for _, d := range deploys {- if err := ctrl.SetControllerReference(o, d, r.Scheme); err != nil {+ if err := r.setOwnerOrLabel(o, d, targetNS); err != nil {return err}if err := r.createOrUpdate(ctx, d); err != nil {@@ -135,13 +212,13 @@ func (r *OpenRAGReconciler) reconcileDeployments(ctx context.Context, o *openragreturn nil}-func (r *OpenRAGReconciler) frontendDeployment(o *openragv1alpha1.OpenRAG) *appsv1.Deployment {+func (r *OpenRAGReconciler) frontendDeployment(o *openragv1alpha1.OpenRAG, targetNS string) *appsv1.Deployment {spec := o.Spec.Frontendreplicas := replicasOrDefault(spec.Replicas)return &appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: resourceName(o.Name, "fe"),- Namespace: o.Namespace,+ Namespace: targetNS,Labels: componentLabels(o.Name, "fe"),},Spec: appsv1.DeploymentSpec{@@ -176,7 +253,7 @@ func (r *OpenRAGReconciler) frontendDeployment(o *openragv1alpha1.OpenRAG) *apps}}-func (r *OpenRAGReconciler) backendDeployment(o *openragv1alpha1.OpenRAG) *appsv1.Deployment {+func (r *OpenRAGReconciler) backendDeployment(o *openragv1alpha1.OpenRAG, targetNS string) *appsv1.Deployment {spec := o.Spec.Backendreplicas := replicasOrDefault(spec.Replicas)@@ -213,7 +290,7 @@ func (r *OpenRAGReconciler) backendDeployment(o *openragv1alpha1.OpenRAG) *appsvreturn &appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: resourceName(o.Name, "be"),- Namespace: o.Namespace,+ Namespace: targetNS,Labels: componentLabels(o.Name, "be"),},Spec: appsv1.DeploymentSpec{@@ -248,7 +325,7 @@ func (r *OpenRAGReconciler) backendDeployment(o *openragv1alpha1.OpenRAG) *appsv}}-func (r *OpenRAGReconciler) langflowDeployment(o *openragv1alpha1.OpenRAG) *appsv1.Deployment {+func (r *OpenRAGReconciler) langflowDeployment(o *openragv1alpha1.OpenRAG, targetNS string) *appsv1.Deployment {spec := o.Spec.Langflowreplicas := replicasOrDefault(spec.Replicas)@@ -290,7 +367,7 @@ func (r *OpenRAGReconciler) langflowDeployment(o *openragv1alpha1.OpenRAG) *appsreturn &appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{Name: resourceName(o.Name, "lf"),- Namespace: o.Namespace,+ Namespace: targetNS,Labels: componentLabels(o.Name, "lf"),},Spec: appsv1.DeploymentSpec{@@ -327,18 +404,15 @@ func (r *OpenRAGReconciler) langflowDeployment(o *openragv1alpha1.OpenRAG) *apps}}-func (r *OpenRAGReconciler) reconcileNetworkPolicy(ctx context.Context, o *openragv1alpha1.OpenRAG) error {+func (r *OpenRAGReconciler) reconcileNetworkPolicy(ctx context.Context, o *openragv1alpha1.OpenRAG, targetNS string) error {labels := componentLabels(o.Name, "lf")egress := []networkingv1.NetworkPolicyEgressRule{- // langflow -> itself{Ports: []networkingv1.NetworkPolicyPort{tcpPort(7860)},To: []networkingv1.NetworkPolicyPeer{{PodSelector: &metav1.LabelSelector{MatchLabels: labels}}},},- // DNS{Ports: []networkingv1.NetworkPolicyPort{udpPort(53), tcpPort(53)}},- // OpenSearch + external HTTPS{Ports: []networkingv1.NetworkPolicyPort{tcpPort(9200), tcpPort(443)}},}@@ -351,7 +425,7 @@ func (r *OpenRAGReconciler) reconcileNetworkPolicy(ctx context.Context, o *openrnp := &networkingv1.NetworkPolicy{ObjectMeta: metav1.ObjectMeta{Name: resourceName(o.Name, "lf-netpol"),- Namespace: o.Namespace,+ Namespace: targetNS,Labels: labels,},Spec: networkingv1.NetworkPolicySpec{@@ -367,12 +441,28 @@ func (r *OpenRAGReconciler) reconcileNetworkPolicy(ctx context.Context, o *openrEgress: egress,},}- if err := ctrl.SetControllerReference(o, np, r.Scheme); err != nil {+ if err := r.setOwnerOrLabel(o, np, targetNS); err != nil {return err}return r.createOrUpdate(ctx, np)}+// setOwnerOrLabel sets a controller owner reference when the resource lives in the+// same namespace as the CR. For cross-namespace resources it falls back to a label+// since Kubernetes forbids cross-namespace owner references.+func (r *OpenRAGReconciler) setOwnerOrLabel(o *openragv1alpha1.OpenRAG, obj client.Object, targetNS string) error {+ if targetNS == o.Namespace {+ return ctrl.SetControllerReference(o, obj, r.Scheme)+ }+ labels := obj.GetLabels()+ if labels == nil {+ labels = make(map[string]string)+ }+ labels[managedByLabel] = o.Name+ obj.SetLabels(labels)+ return nil+}+func (r *OpenRAGReconciler) createOrUpdate(ctx context.Context, obj client.Object) error {existing := obj.DeepCopyObject().(client.Object)err := r.Get(ctx, client.ObjectKeyFromObject(obj), existing)@@ -399,6 +489,15 @@ func (r *OpenRAGReconciler) SetupWithManager(mgr ctrl.Manager) error {// helpers+const managedByLabel = "openr.ag/managed-by"++func targetNamespace(o *openragv1alpha1.OpenRAG) string {+ if o.Spec.TargetNamespace != "" {+ return o.Spec.TargetNamespace+ }+ return o.Namespace+}+func resourceName(crName, role string) string {return crName + "-openrag-" + role}diff --git a/kubernetes/operator/internal/controller/openrag_controller_test.go b/kubernetes/operator/internal/controller/openrag_controller_test.gonew file mode 100644index 000000000..2e68858c5--- /dev/null+++ b/kubernetes/operator/internal/controller/openrag_controller_test.go@@ -0,0 +1,366 @@+package controller++import (+ "context"+ "testing"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+ appsv1 "k8s.io/api/apps/v1"+ corev1 "k8s.io/api/core/v1"+ "k8s.io/apimachinery/pkg/api/resource"+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ "k8s.io/apimachinery/pkg/runtime"+ "k8s.io/apimachinery/pkg/types"+ clientgoscheme "k8s.io/client-go/kubernetes/scheme"+ ctrl "sigs.k8s.io/controller-runtime"+ "sigs.k8s.io/controller-runtime/pkg/client"+ "sigs.k8s.io/controller-runtime/pkg/client/fake"+ "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"++ openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+)++// newScheme builds a scheme with all types the controller needs.+func newScheme(t *testing.T) *runtime.Scheme {+ t.Helper()+ s := runtime.NewScheme()+ require.NoError(t, clientgoscheme.AddToScheme(s))+ require.NoError(t, appsv1.AddToScheme(s))+ require.NoError(t, corev1.AddToScheme(s))+ require.NoError(t, openragv1alpha1.AddToScheme(s))+ return s+}++// minimalCR returns a valid OpenRAG CR with the minimum required fields set.+func minimalCR(name, namespace string) *openragv1alpha1.OpenRAG {+ return &openragv1alpha1.OpenRAG{+ ObjectMeta: metav1.ObjectMeta{+ Name: name,+ Namespace: namespace,+ },+ Spec: openragv1alpha1.OpenRAGSpec{+ Frontend: openragv1alpha1.FrontendSpec{+ ComponentSpec: openragv1alpha1.ComponentSpec{Image: "langflowai/openrag-frontend:latest"},+ },+ Backend: openragv1alpha1.BackendSpec{+ ComponentSpec: openragv1alpha1.ComponentSpec{Image: "langflowai/openrag-backend:latest"},+ },+ Langflow: openragv1alpha1.LangflowSpec{+ ComponentSpec: openragv1alpha1.ComponentSpec{Image: "langflowai/openrag-langflow:latest"},+ },+ },+ }+}++func reconciler(s *runtime.Scheme, objs ...client.Object) (*OpenRAGReconciler, client.Client) {+ c := fake.NewClientBuilder().WithScheme(s).WithObjects(objs...).WithStatusSubresource(&openragv1alpha1.OpenRAG{}).Build()+ return NewOpenRAGReconciler(c, s), c+}++func reconcileOnce(t *testing.T, r *OpenRAGReconciler, cr *openragv1alpha1.OpenRAG) ctrl.Result {+ t.Helper()+ res, err := r.Reconcile(context.Background(), ctrl.Request{+ NamespacedName: types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace},+ })+ require.NoError(t, err)+ return res+}++// ---------------------------------------------------------------------------+// targetNamespace helper+// ---------------------------------------------------------------------------++func TestTargetNamespace_DefaultsToCRNamespace(t *testing.T) {+ cr := minimalCR("my-openrag", "my-ns")+ assert.Equal(t, "my-ns", targetNamespace(cr))+}++func TestTargetNamespace_UsesSpecField(t *testing.T) {+ cr := minimalCR("my-openrag", "my-ns")+ cr.Spec.TargetNamespace = "tenant-ns"+ assert.Equal(t, "tenant-ns", targetNamespace(cr))+}++// ---------------------------------------------------------------------------+// resourceName / saName helpers+// ---------------------------------------------------------------------------++func TestResourceName(t *testing.T) {+ assert.Equal(t, "my-openrag-openrag-fe", resourceName("my-openrag", "fe"))+ assert.Equal(t, "my-openrag-openrag-be", resourceName("my-openrag", "be"))+ assert.Equal(t, "my-openrag-openrag-lf", resourceName("my-openrag", "lf"))+}++func TestSAName(t *testing.T) {+ assert.Equal(t, "openrag-my-openrag-fe", saName("my-openrag", "fe"))+}++// ---------------------------------------------------------------------------+// Reconcile — same namespace (no targetNamespace)+// ---------------------------------------------------------------------------++func TestReconcile_CreatesDeployments(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{"fe", "be", "lf"} {+ d := &appsv1.Deployment{}+ require.NoError(t, c.Get(context.Background(),+ types.NamespacedName{Name: resourceName(cr.Name, role), Namespace: "my-ns"}, d),+ "deployment for role %s should exist", role)+ }+}++func TestReconcile_CreatesServices(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "my-ns")+ r, c := reconciler(s, cr)++ reconcileOnce(t, r, cr)++ ports := map[string]int32{"fe": 3000, "be": 8000, "lf": 7860}+ for role, port := range ports {+ svc := &corev1.Service{}+ require.NoError(t, c.Get(context.Background(),+ types.NamespacedName{Name: resourceName(cr.Name, role), Namespace: "my-ns"}, svc))+ assert.Equal(t, port, svc.Spec.Ports[0].Port, "service port for role %s", role)+ }+}++func TestReconcile_CreatesServiceAccounts(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{"fe", "be", "lf"} {+ sa := &corev1.ServiceAccount{}+ require.NoError(t, c.Get(context.Background(),+ types.NamespacedName{Name: saName(cr.Name, role), Namespace: "my-ns"}, sa),+ "service account for role %s should exist", role)+ }+}++func TestReconcile_SetsOwnerReferences_SameNamespace(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "my-ns")+ r, c := reconciler(s, cr)++ reconcileOnce(t, r, cr)++ d := &appsv1.Deployment{}+ require.NoError(t, c.Get(context.Background(),+ types.NamespacedName{Name: resourceName(cr.Name, "fe"), Namespace: "my-ns"}, d))+ require.Len(t, d.OwnerReferences, 1)+ assert.Equal(t, cr.Name, d.OwnerReferences[0].Name)+}++func TestReconcile_FrontendEnvContainsBackendHost(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "my-ns")+ r, c := reconciler(s, cr)++ reconcileOnce(t, r, cr)++ d := &appsv1.Deployment{}+ require.NoError(t, c.Get(context.Background(),+ types.NamespacedName{Name: resourceName(cr.Name, "fe"), Namespace: "my-ns"}, d))++ var backendHost string+ for _, e := range d.Spec.Template.Spec.Containers[0].Env {+ if e.Name == "OPENRAG_BACKEND_HOST" {+ backendHost = e.Value+ }+ }+ assert.Equal(t, resourceName(cr.Name, "be"), backendHost)+}++func TestReconcile_BackendMountsEnvSecret(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "my-ns")+ cr.Spec.Backend.EnvSecret = "my-backend-secret"+ r, c := reconciler(s, cr)++ reconcileOnce(t, r, cr)++ d := &appsv1.Deployment{}+ require.NoError(t, c.Get(context.Background(),+ types.NamespacedName{Name: resourceName(cr.Name, "be"), Namespace: "my-ns"}, d))++ var found bool+ for _, v := range d.Spec.Template.Spec.Volumes {+ if v.Name == "backend-env" {+ assert.Equal(t, "my-backend-secret", v.Secret.SecretName)+ found = true+ }+ }+ assert.True(t, found, "backend-env volume should exist")+}++func TestReconcile_LangflowMountsPVC(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "my-ns")+ size := resource.MustParse("10Gi")+ cr.Spec.Langflow.Storage = &openragv1alpha1.PersistenceSpec{Enabled: true, Size: size}+ r, c := reconciler(s, cr)++ reconcileOnce(t, r, cr)++ d := &appsv1.Deployment{}+ require.NoError(t, c.Get(context.Background(),+ types.NamespacedName{Name: resourceName(cr.Name, "lf"), Namespace: "my-ns"}, d))++ var found bool+ for _, v := range d.Spec.Template.Spec.Volumes {+ if v.Name == "langflow-data" {+ assert.Equal(t, resourceName(cr.Name, "lf-data"), v.PersistentVolumeClaim.ClaimName)+ found = true+ }+ }+ assert.True(t, found, "langflow-data volume should exist")+}++// ---------------------------------------------------------------------------+// Reconcile — target namespace+// ---------------------------------------------------------------------------++func TestReconcile_CreatesTargetNamespace(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "operator-ns")+ cr.Spec.TargetNamespace = "tenant-ns"+ r, c := reconciler(s, cr)++ reconcileOnce(t, r, cr)++ ns := &corev1.Namespace{}+ require.NoError(t, c.Get(context.Background(), types.NamespacedName{Name: "tenant-ns"}, ns))+ assert.Equal(t, cr.Name, ns.Labels[managedByLabel])+}++func TestReconcile_AddsFinalizer_WhenTargetNamespaceDiffers(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "operator-ns")+ cr.Spec.TargetNamespace = "tenant-ns"+ r, c := reconciler(s, cr)++ reconcileOnce(t, r, cr)++ updated := &openragv1alpha1.OpenRAG{}+ require.NoError(t, c.Get(context.Background(),+ types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace}, updated))+ assert.True(t, controllerutil.ContainsFinalizer(updated, finalizer))+}++func TestReconcile_NoFinalizer_WhenSameNamespace(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "my-ns")+ r, c := reconciler(s, cr)++ reconcileOnce(t, r, cr)++ 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))+}++func TestReconcile_ResourcesInTargetNamespace(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "operator-ns")+ cr.Spec.TargetNamespace = "tenant-ns"+ r, c := reconciler(s, cr)++ reconcileOnce(t, r, cr)++ d := &appsv1.Deployment{}+ require.NoError(t, c.Get(context.Background(),+ types.NamespacedName{Name: resourceName(cr.Name, "fe"), Namespace: "tenant-ns"}, d))+ // Cross-namespace: no owner references, managed-by label instead.+ assert.Empty(t, d.OwnerReferences)+ assert.Equal(t, cr.Name, d.Labels[managedByLabel])+}++func TestReconcile_SkipsNamespaceCreation_WhenSameAsCR(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "my-ns")+ r, c := reconciler(s, cr)++ reconcileOnce(t, r, cr)++ // Only the CR namespace should exist, not a separate one.+ nsList := &corev1.NamespaceList{}+ require.NoError(t, c.List(context.Background(), nsList))+ for _, ns := range nsList.Items {+ assert.NotEqual(t, "openrag-operator", ns.Labels["app.kubernetes.io/managed-by"],+ "operator should not have created a new namespace")+ }+}++// ---------------------------------------------------------------------------+// Deletion handling+// ---------------------------------------------------------------------------++func TestReconcile_Deletion_DeletesOwnedNamespace(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "operator-ns")+ cr.Spec.TargetNamespace = "tenant-ns"+ now := metav1.Now()+ cr.DeletionTimestamp = &now+ controllerutil.AddFinalizer(cr, finalizer)++ // Pre-create the target namespace labelled as owned by this CR.+ ns := &corev1.Namespace{+ ObjectMeta: metav1.ObjectMeta{+ Name: "tenant-ns",+ Labels: map[string]string{managedByLabel: cr.Name},+ },+ }++ r, c := reconciler(s, cr, ns)+ _, err := r.Reconcile(context.Background(), ctrl.Request{+ NamespacedName: types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace},+ })+ require.NoError(t, err)++ // Namespace should be deleted.+ remaining := &corev1.Namespace{}+ err = c.Get(context.Background(), types.NamespacedName{Name: "tenant-ns"}, remaining)+ assert.True(t, err != nil, "namespace should have been deleted")++ // After the finalizer is removed the fake client deletes the CR — NotFound is correct.+ updated := &openragv1alpha1.OpenRAG{}+ err = c.Get(context.Background(), types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace}, updated)+ assert.True(t, err != nil, "CR should be gone after finalizer removal")+}++func TestReconcile_Deletion_SkipsUnmanagedNamespace(t *testing.T) {+ s := newScheme(t)+ cr := minimalCR("my-openrag", "operator-ns")+ cr.Spec.TargetNamespace = "tenant-ns"+ now := metav1.Now()+ cr.DeletionTimestamp = &now+ controllerutil.AddFinalizer(cr, finalizer)++ // Namespace exists but belongs to someone else.+ ns := &corev1.Namespace{+ ObjectMeta: metav1.ObjectMeta{+ Name: "tenant-ns",+ Labels: map[string]string{managedByLabel: "other-cr"},+ },+ }++ r, c := reconciler(s, cr, ns)+ _, err := r.Reconcile(context.Background(), ctrl.Request{+ NamespacedName: types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace},+ })+ require.NoError(t, err)++ // Namespace should NOT be deleted.+ remaining := &corev1.Namespace{}+ require.NoError(t, c.Get(context.Background(), types.NamespacedName{Name: "tenant-ns"}, remaining))+}