OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
feat: generated client for kubernetes crd (#1673)
ming76b0cd8a29bc
diff --git a/.github/workflows/operator-ci.yml b/.github/workflows/operator-ci.ymlindex 5db9aa791..b025a583f 100644--- a/.github/workflows/operator-ci.yml+++ b/.github/workflows/operator-ci.yml@@ -56,6 +56,16 @@ jobs:./bin/controller-gen object:headerFile="hack/boilerplate.go.txt" paths="./..."git diff --exit-code api/+ - name: Check generated typed client is up to date+ run: |+ # Ensure code-generator is available in module cache+ go mod download k8s.io/code-generator+ make generate-client+ git diff --exit-code pkg/generated/+ env:+ # Suppress verbose output during CI+ KUBE_VERBOSE: "0"+- name: go testrun: go test ./... -race -coverprofile=cover.outdiff --git a/kubernetes/operator/CLIENT_GENERATION.md b/kubernetes/operator/CLIENT_GENERATION.mdnew file mode 100644index 000000000..181612b52--- /dev/null+++ b/kubernetes/operator/CLIENT_GENERATION.md@@ -0,0 +1,367 @@+# Typed Kubernetes Client Generation for OpenRAG++This document explains how to generate and use typed Kubernetes clients for the OpenRAG CRDs.++## Overview++Instead of using `unstructured.Unstructured`, you can now use strongly-typed Go clients that provide:+- **Compile-time type safety** - Catch errors during development, not runtime+- **IDE auto-completion** - Better developer experience+- **Cleaner code** - No manual field path navigation or type assertions++## Generating the Clientset++### Prerequisites++```bash+# Install code-generator dependency+go get k8s.io/[email protected]+```++### Generate Clients++```bash+# Generate clientset, listers, and informers+make generate-client+```++This will create the following packages:+- `pkg/generated/clientset/versioned` - Typed clientset+- `pkg/generated/listers/api/v1alpha1` - Listers for efficient reads+- `pkg/generated/informers/externalversions` - Informers for watching resources++## Usage Examples++### Before (Using Unstructured)++```go+import (+ "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"+ "k8s.io/apimachinery/pkg/runtime/schema"+)++// Create unstructured client+dynamicClient, err := dynamic.NewForConfig(config)+gvr := schema.GroupVersionResource{+ Group: "openr.ag",+ Version: "v1alpha1",+ Resource: "openrags",+}++// Get OpenRAG (weakly typed - runtime errors)+obj, err := dynamicClient.Resource(gvr).Namespace("default").Get(ctx, "my-openrag", metav1.GetOptions{})+if err != nil {+ return err+}++// Manual field navigation (error-prone)+spec, found, err := unstructured.NestedMap(obj.Object, "spec")+backend, found, err := unstructured.NestedMap(spec, "backend")+image, found, err := unstructured.NestedString(backend, "image")+// No compile-time type checking!+```++### After (Using Typed Client)++```go+import (+ openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ clientset "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"+)++// Create typed client+client, err := clientset.NewForConfig(config)++// Get OpenRAG (strongly typed - compile-time safety!)+openrag, err := client.OpenrV1alpha1().OpenRAGs("default").Get(ctx, "my-openrag", metav1.GetOptions{})+if err != nil {+ return err+}++// Direct field access with type safety+image := openrag.Spec.Backend.Image // ✅ Type-safe!+replicas := openrag.Spec.Backend.Replicas // ✅ Auto-complete!+```++## Full Example: Creating an OpenRAG Instance++```go+package main++import (+ "context"+ "fmt"++ corev1 "k8s.io/api/core/v1"+ "k8s.io/apimachinery/pkg/api/resource"+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ "k8s.io/client-go/tools/clientcmd"+ "k8s.io/utils/ptr"++ openragv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ clientset "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"+)++func main() {+ // Load kubeconfig+ config, err := clientcmd.BuildConfigFromFlags("", "/path/to/kubeconfig")+ if err != nil {+ panic(err)+ }++ // Create OpenRAG typed client+ client, err := clientset.NewForConfig(config)+ if err != nil {+ panic(err)+ }++ // Define OpenRAG instance+ openrag := &openragv1alpha1.OpenRAG{+ ObjectMeta: metav1.ObjectMeta{+ Name: "my-openrag",+ Namespace: "default",+ },+ Spec: openragv1alpha1.OpenRAGSpec{+ TenantID: "tenant-123",+ Frontend: openragv1alpha1.FrontendSpec{+ ComponentSpec: openragv1alpha1.ComponentSpec{+ Image: "myregistry/openrag-frontend:v1.0.0",+ Replicas: ptr.To(int32(2)),+ Resources: corev1.ResourceRequirements{+ Requests: corev1.ResourceList{+ corev1.ResourceCPU: resource.MustParse("100m"),+ corev1.ResourceMemory: resource.MustParse("256Mi"),+ },+ },+ },+ },+ Backend: openragv1alpha1.BackendSpec{+ ComponentSpec: openragv1alpha1.ComponentSpec{+ Image: "myregistry/openrag-backend:v1.0.0",+ Replicas: ptr.To(int32(3)),+ Env: []corev1.EnvVar{+ {Name: "CUSTOM_VAR", Value: "custom_value"},+ },+ },+ Storage: &openragv1alpha1.PersistenceSpec{+ Enabled: true,+ Size: resource.MustParse("10Gi"),+ },+ },+ Langflow: openragv1alpha1.LangflowSpec{+ ComponentSpec: openragv1alpha1.ComponentSpec{+ Image: "myregistry/langflow:v1.0.0",+ Replicas: ptr.To(int32(2)),+ },+ PVCReclaimPolicy: openragv1alpha1.PVCReclaimRetain,+ },+ },+ }++ // Create the resource+ result, err := client.OpenrV1alpha1().OpenRAGs("default").Create(+ context.Background(),+ openrag,+ metav1.CreateOptions{},+ )+ if err != nil {+ panic(err)+ }++ fmt.Printf("Created OpenRAG: %s\n", result.Name)++ // Update the resource+ result.Spec.Backend.Replicas = ptr.To(int32(5))+ updated, err := client.OpenrV1alpha1().OpenRAGs("default").Update(+ context.Background(),+ result,+ metav1.UpdateOptions{},+ )+ if err != nil {+ panic(err)+ }++ fmt.Printf("Updated OpenRAG backend replicas to: %d\n", *updated.Spec.Backend.Replicas)++ // List all OpenRAG instances+ list, err := client.OpenrV1alpha1().OpenRAGs("").List(+ context.Background(),+ metav1.ListOptions{},+ )+ if err != nil {+ panic(err)+ }++ fmt.Printf("Found %d OpenRAG instances\n", len(list.Items))+ for _, item := range list.Items {+ fmt.Printf(" - %s/%s (Phase: %s)\n", item.Namespace, item.Name, item.Status.Phase)+ }+}+```++## Using Informers (Efficient Watching)++Informers provide efficient caching and watching of resources:++```go+import (+ "time"++ "k8s.io/client-go/tools/cache"++ informers "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions"+)++// Create informer factory+informerFactory := informers.NewSharedInformerFactory(client, time.Minute*10)++// Get OpenRAG informer+openragInformer := informerFactory.Openr().V1alpha1().OpenRAGs()++// Add event handlers+openragInformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{+ AddFunc: func(obj interface{}) {+ openrag := obj.(*openragv1alpha1.OpenRAG)+ fmt.Printf("OpenRAG added: %s/%s\n", openrag.Namespace, openrag.Name)+ },+ UpdateFunc: func(old, new interface{}) {+ newOpenRAG := new.(*openragv1alpha1.OpenRAG)+ fmt.Printf("OpenRAG updated: %s/%s\n", newOpenRAG.Namespace, newOpenRAG.Name)+ },+ DeleteFunc: func(obj interface{}) {+ openrag := obj.(*openragv1alpha1.OpenRAG)+ fmt.Printf("OpenRAG deleted: %s/%s\n", openrag.Namespace, openrag.Name)+ },+})++// Start informers+stopCh := make(chan struct{})+defer close(stopCh)+informerFactory.Start(stopCh)++// Wait for cache sync+if !cache.WaitForCacheSync(stopCh, openragInformer.Informer().HasSynced) {+ panic("Failed to sync cache")+}++// Now use the lister for efficient reads+lister := openragInformer.Lister()+openrags, err := lister.OpenRAGs("default").List(labels.Everything())+```++## Benefits++### Type Safety+```go+// ❌ Unstructured - Runtime error+image := obj.Object["spec"].(map[string]interface{})["backend"].(map[string]interface{})["image"].(string)++// ✅ Typed - Compile-time error if field doesn't exist+image := openrag.Spec.Backend.Image+```++### IDE Support+- Auto-completion for all fields+- Jump to definition+- Inline documentation+- Refactoring support++### Cleaner Code+- No type assertions+- No manual field path navigation+- Easier to read and maintain++## Regenerating Clients++Run this command whenever you modify the CRD types:++```bash+make generate # Regenerate DeepCopy methods+make generate-client # Regenerate clientsets, listers, informers+```++## Distribution++### Option 1: Publish as Go Module (Recommended)++Users can import directly:++```go+import clientset "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"+```++### Option 2: Copy Generated Code++If users don't want to depend on your entire module, they can copy the generated code to their project:++```bash+cp -r pkg/generated /path/to/their/project/+```++## Troubleshooting++### `code-generator` not found++If you see this error:+```+Error: k8s.io/code-generator not found in module cache+```++Run:+```bash+go mod download k8s.io/code-generator+# OR+go get k8s.io/[email protected]+go mod tidy+```++The dependency is already in `go.mod`, so `go mod download` should be sufficient.++### Permission denied on script++```bash+chmod +x hack/update-codegen.sh+```++### Generated code not in version control++It's recommended to commit generated code to version control so users can use it without running code generation.++### CI Check Failures++If your pull request fails with:++```text+Error: git diff --exit-code pkg/generated/+```++This means you modified the API types but didn't regenerate the typed client. Fix it:++```bash+make generate-client+git add pkg/generated/+git commit --amend --no-edit+git push --force-with-lease+```++Our CI automatically verifies that generated code is up to date to prevent inconsistencies.++## Contributing++When modifying API types in `api/v1alpha1/`, always run:++```bash+make generate # Regenerate deepcopy code+make manifests # Regenerate CRDs and RBAC+make generate-client # Regenerate typed client+git add api/ config/ pkg/generated/+git commit -m "feat: add new field to OpenRAG spec"+```++See [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md) for more details.++## References++- [Kubernetes Code Generator](https://github.com/kubernetes/code-generator)+- [Sample Controller](https://github.com/kubernetes/sample-controller)+- [Client-go Documentation](https://github.com/kubernetes/client-go)diff --git a/kubernetes/operator/Makefile b/kubernetes/operator/Makefileindex d5438be40..bfa237b23 100644--- a/kubernetes/operator/Makefile+++ b/kubernetes/operator/Makefile@@ -4,10 +4,11 @@# under ~/.gvm/gos/go1.26.0, otherwise falls back to whatever 'go' is in PATH.## Quick start:-# make deps # install controller-gen, kustomize, envtest into ./bin-# make manifests # generate CRD + RBAC YAML under config/-# make generate # regenerate zz_generated.deepcopy.go-# make build # compile the operator binary+# make deps # install controller-gen, kustomize, envtest into ./bin+# make manifests # generate CRD + RBAC YAML under config/+# make generate # regenerate zz_generated.deepcopy.go+# make generate-client # generate typed clientsets, listers, and informers+# make build # compile the operator binary# Image to push/pull for the operator container.IMG ?= ghcr.io/langflow-ai/openrag-operator:latest@@ -55,6 +56,14 @@ manifests: controller-gen ## Generate CRD and RBAC manifests from Go type markergenerate: controller-gen ## Regenerate zz_generated.deepcopy.go from type definitions.$(CONTROLLER_GEN) object:headerFile="hack/boilerplate.go.txt" paths="./..."+.PHONY: generate-client+generate-client: ## Generate typed clientsets, listers, and informers.+ @echo "Generating typed clientsets..."+ bash hack/update-codegen.sh+ @echo ""+ @echo "⚠️ Remember to commit the generated files in pkg/generated/"+ @echo " CI will verify these are up to date on pull requests"+.PHONY: fmtfmt: ## Run go fmt.go fmt ./...diff --git a/kubernetes/operator/api/v1alpha1/doc.go b/kubernetes/operator/api/v1alpha1/doc.gonew file mode 100644index 000000000..421c68587--- /dev/null+++ b/kubernetes/operator/api/v1alpha1/doc.go@@ -0,0 +1,16 @@+// Package v1alpha1 contains API Schema definitions for the openr.ag v1alpha1 API group.+// +k8s:deepcopy-gen=package+// +groupName=openr.ag+package v1alpha1++import (+ "k8s.io/apimachinery/pkg/runtime/schema"+)++// SchemeGroupVersion is group version used to register these objects+var SchemeGroupVersion = schema.GroupVersion{Group: "openr.ag", Version: "v1alpha1"}++// Resource takes an unqualified resource and returns a Group qualified GroupResource+func Resource(resource string) schema.GroupResource {+ return SchemeGroupVersion.WithResource(resource).GroupResource()+}diff --git a/kubernetes/operator/api/v1alpha1/openrag_types.go b/kubernetes/operator/api/v1alpha1/openrag_types.goindex d64e6adb9..f2bfa0ef6 100644--- a/kubernetes/operator/api/v1alpha1/openrag_types.go+++ b/kubernetes/operator/api/v1alpha1/openrag_types.go@@ -710,6 +710,7 @@ type OpenRAGStatus struct {// +kubebuilder:printcolumn:name="Frontend",type="string",JSONPath=".spec.frontend.image"// +kubebuilder:printcolumn:name="Backend",type="string",JSONPath=".spec.backend.image"// +kubebuilder:printcolumn:name="Langflow",type="string",JSONPath=".spec.langflow.image"+// +genclient// OpenRAG is the Schema for the openrags API.type OpenRAG struct {diff --git a/kubernetes/operator/go.mod b/kubernetes/operator/go.modindex 2bd836ec7..e0a8bb356 100644--- a/kubernetes/operator/go.mod+++ b/kubernetes/operator/go.mod@@ -7,13 +7,15 @@ require (k8s.io/api v0.33.2k8s.io/apimachinery v0.33.2k8s.io/client-go v0.33.2- sigs.k8s.io/controller-runtime v0.21.0+ k8s.io/code-generator v0.33.0+ k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738+ sigs.k8s.io/controller-runtime v0.19.7)require (github.com/beorn7/perks v1.0.1 // indirectgithub.com/cespare/xxhash/v2 v2.3.0 // indirect- github.com/davecgh/go-spew v1.1.1 // indirect+ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirectgithub.com/emicklei/go-restful/v3 v3.11.0 // indirectgithub.com/evanphx/json-patch/v5 v5.9.11 // indirectgithub.com/fsnotify/fsnotify v1.7.0 // indirect@@ -24,7 +26,6 @@ require (github.com/go-openapi/jsonreference v0.20.2 // indirectgithub.com/go-openapi/swag v0.23.0 // indirectgithub.com/gogo/protobuf v1.3.2 // indirect- github.com/google/btree v1.1.3 // indirectgithub.com/google/gnostic-models v0.6.9 // indirectgithub.com/google/go-cmp v0.7.0 // indirectgithub.com/google/uuid v1.6.0 // indirect@@ -35,7 +36,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 // indirect+ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirectgithub.com/prometheus/client_golang v1.22.0 // indirectgithub.com/prometheus/client_model v0.6.1 // indirectgithub.com/prometheus/common v0.62.0 // indirect@@ -44,6 +45,8 @@ require (github.com/x448/float16 v0.8.4 // indirectgo.uber.org/multierr v1.11.0 // indirectgo.uber.org/zap v1.27.1 // indirect+ golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc // indirect+ golang.org/x/mod v0.21.0 // indirectgolang.org/x/net v0.38.0 // indirectgolang.org/x/oauth2 v0.27.0 // indirectgolang.org/x/sync v0.12.0 // indirect@@ -51,15 +54,16 @@ require (golang.org/x/term v0.30.0 // indirectgolang.org/x/text v0.23.0 // indirectgolang.org/x/time v0.9.0 // indirect+ golang.org/x/tools v0.26.0 // indirectgomodules.xyz/jsonpatch/v2 v2.4.0 // indirectgoogle.golang.org/protobuf v1.36.5 // indirectgopkg.in/evanphx/json-patch.v4 v4.12.0 // indirectgopkg.in/inf.v0 v0.9.1 // indirectgopkg.in/yaml.v3 v3.0.1 // indirect- k8s.io/apiextensions-apiserver v0.33.0 // indirect+ k8s.io/apiextensions-apiserver v0.31.4 // indirect+ k8s.io/gengo/v2 v2.0.0-20250207200755-1244d31929d7 // indirectk8s.io/klog/v2 v2.130.1 // indirectk8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff // indirect- k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 // indirectsigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 // indirectsigs.k8s.io/randfill v1.0.0 // indirectsigs.k8s.io/structured-merge-diff/v4 v4.6.0 // indirectdiff --git a/kubernetes/operator/go.sum b/kubernetes/operator/go.sumindex bd5293434..62ea18dbc 100644--- a/kubernetes/operator/go.sum+++ b/kubernetes/operator/go.sum@@ -1,13 +1,12 @@github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=-github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM=-github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ=github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=github.com/emicklei/go-restful/v3 v3.11.0 h1:rAQeMHw1c7zTmncogyy8VvRZwtkmkZ4FxERmMY4rD+g=github.com/emicklei/go-restful/v3 v3.11.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc=github.com/evanphx/json-patch v0.5.2 h1:xVCHIVMUu1wtM/VkR9jVZ45N3FhZfYMMYGorLCR8P3k=@@ -34,8 +33,6 @@ github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vgithub.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=-github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg=-github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=github.com/google/gnostic-models v0.6.9 h1:MU/8wDLif2qCXZmzncUQ/BOfxWfthHi63KqpoNbWqVw=github.com/google/gnostic-models v0.6.9/go.mod h1:CiWsm0s6BSQd1hRn8/QmxqB6BesYcbSZxsz9b0KuDBw=github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=@@ -74,14 +71,15 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Ggithub.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=-github.com/onsi/ginkgo/v2 v2.22.0 h1:Yed107/8DjTr0lKCNt7Dn8yQ6ybuDRQoMGrNFKzMfHg=-github.com/onsi/ginkgo/v2 v2.22.0/go.mod h1:7Du3c42kxCUegi0IImZ1wUQzMBVecgIHjR1C+NkhLQo=-github.com/onsi/gomega v1.36.1 h1:bJDPBO7ibjxcbHMgSCoo4Yj18UWbKDlLwX1x9sybDcw=-github.com/onsi/gomega v1.36.1/go.mod h1:PvZbdDc8J6XJEpDK4HCuRBm8a6Fzp9/DmhC9C7yFlog=+github.com/onsi/ginkgo/v2 v2.21.0 h1:7rg/4f3rB88pb5obDgNZrNHrQ4e6WpjonchcpuBRnZM=+github.com/onsi/ginkgo/v2 v2.21.0/go.mod h1:7Du3c42kxCUegi0IImZ1wUQzMBVecgIHjR1C+NkhLQo=+github.com/onsi/gomega v1.35.1 h1:Cwbd75ZBPxFSuZ6T+rN/WCb/gOc6YgFBXLlZLhC7Ds4=+github.com/onsi/gomega v1.35.1/go.mod h1:PvZbdDc8J6XJEpDK4HCuRBm8a6Fzp9/DmhC9C7yFlog=github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=@@ -118,8 +116,12 @@ go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=+golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc h1:mCRnTeVUjcrhlRmO0VK8a6k6Rrf6TF9htwo2pJVSjIU=+golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=+golang.org/x/mod v0.21.0 h1:vvrHzRwRfVKSiLrG+d4FMl/Qi4ukBCE6kZlTUkDYRT0=+golang.org/x/mod v0.21.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=@@ -172,20 +174,24 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=k8s.io/api v0.33.2 h1:YgwIS5jKfA+BZg//OQhkJNIfie/kmRsO0BmNaVSimvY=k8s.io/api v0.33.2/go.mod h1:fhrbphQJSM2cXzCWgqU29xLDuks4mu7ti9vveEnpSXs=-k8s.io/apiextensions-apiserver v0.33.0 h1:d2qpYL7Mngbsc1taA4IjJPRJ9ilnsXIrndH+r9IimOs=-k8s.io/apiextensions-apiserver v0.33.0/go.mod h1:VeJ8u9dEEN+tbETo+lFkwaaZPg6uFKLGj5vyNEwwSzc=+k8s.io/apiextensions-apiserver v0.31.4 h1:FxbqzSvy92Ca9DIs5jqot883G0Ln/PGXfm/07t39LS0=+k8s.io/apiextensions-apiserver v0.31.4/go.mod h1:hIW9YU8UsqZqIWGG99/gsdIU0Ar45Qd3A12QOe/rvpg=k8s.io/apimachinery v0.33.2 h1:IHFVhqg59mb8PJWTLi8m1mAoepkUNYmptHsV+Z1m5jY=k8s.io/apimachinery v0.33.2/go.mod h1:BHW0YOu7n22fFv/JkYOEfkUYNRN0fj0BlvMFWA7b+SM=k8s.io/client-go v0.33.2 h1:z8CIcc0P581x/J1ZYf4CNzRKxRvQAwoAolYPbtQes+E=k8s.io/client-go v0.33.2/go.mod h1:9mCgT4wROvL948w6f6ArJNb7yQd7QsvqavDeZHvNmHo=+k8s.io/code-generator v0.33.0 h1:B212FVl6EFqNmlgdOZYWNi77yBv+ed3QgQsMR8YQCw4=+k8s.io/code-generator v0.33.0/go.mod h1:KnJRokGxjvbBQkSJkbVuBbu6z4B0rC7ynkpY5Aw6m9o=+k8s.io/gengo/v2 v2.0.0-20250207200755-1244d31929d7 h1:2OX19X59HxDprNCVrWi6jb7LW1PoqTlYqEq5H2oetog=+k8s.io/gengo/v2 v2.0.0-20250207200755-1244d31929d7/go.mod h1:EJykeLsmFC60UQbYJezXkEsG2FLrt0GPNkU5iK5GWxU=k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk=k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE=k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff h1:/usPimJzUKKu+m+TE36gUyGcf03XZEP0ZIKgKj35LS4=k8s.io/kube-openapi v0.0.0-20250318190949-c8a335a9a2ff/go.mod h1:5jIi+8yX4RIb8wk3XwBo5Pq2ccx4FP10ohkbSKCZoK8=k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738 h1:M3sRQVHv7vB20Xc2ybTt7ODCeFj6JSWYFzOFnYeS6Ro=k8s.io/utils v0.0.0-20241104100929-3ea5e8cea738/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=-sigs.k8s.io/controller-runtime v0.21.0 h1:CYfjpEuicjUecRk+KAeyYh+ouUBn4llGyDYytIGcJS8=-sigs.k8s.io/controller-runtime v0.21.0/go.mod h1:OSg14+F65eWqIu4DceX7k/+QRAbTTvxeQSNSOQpukWM=+sigs.k8s.io/controller-runtime v0.19.7 h1:DLABZfMr20A+AwCZOHhcbcu+TqBXnJZaVBri9K3EO48=+sigs.k8s.io/controller-runtime v0.19.7/go.mod h1:iRmWllt8IlaLjvTTDLhRBXIEtkCK6hwVBJJsYS9Ajf4=sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3 h1:/Rv+M11QRah1itp8VhT6HoVx1Ray9eB4DBr+K+/sCJ8=sigs.k8s.io/json v0.0.0-20241010143419-9aa6b5e7a4b3/go.mod h1:18nIHnGi6636UCz6m8i4DhaJ65T6EruyzmoQqI2BVDo=sigs.k8s.io/randfill v0.0.0-20250304075658-069ef1bbf016/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY=diff --git a/kubernetes/operator/hack/tools.go b/kubernetes/operator/hack/tools.gonew file mode 100644index 000000000..a251dcf42--- /dev/null+++ b/kubernetes/operator/hack/tools.go@@ -0,0 +1,9 @@+//go:build tools+// +build tools++// This package imports things required by build scripts, to force `go mod` to see them as dependencies+package tools++import (+ _ "k8s.io/code-generator"+)diff --git a/kubernetes/operator/hack/update-codegen.sh b/kubernetes/operator/hack/update-codegen.shnew file mode 100755index 000000000..ec4eec5f3--- /dev/null+++ b/kubernetes/operator/hack/update-codegen.sh@@ -0,0 +1,60 @@+#!/usr/bin/env bash++# Copyright 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.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.++set -o errexit+set -o nounset+set -o pipefail++SCRIPT_ROOT=$(dirname "${BASH_SOURCE[0]}")/..++# Find code-generator in go module cache+CODEGEN_PKG=$(go list -f '{{.Dir}}' -m k8s.io/code-generator)++if [ -z "${CODEGEN_PKG}" ] || [ ! -d "${CODEGEN_PKG}" ]; then+ echo "Error: k8s.io/code-generator not found in module cache"+ echo "Please run: go get k8s.io/[email protected]"+ exit 1+fi++echo "Using code-generator from: ${CODEGEN_PKG}"++# Ensure the output directory structure exists+mkdir -p "${SCRIPT_ROOT}/pkg/generated"++# Source the kube_codegen library+source "${CODEGEN_PKG}/kube_codegen.sh"++# Generate clientset for API types+# Run from the module root directory+# --with-watch enables generation of listers and informers+kube::codegen::gen_client \+ --with-watch \+ --one-input-api "api/v1alpha1" \+ --output-dir "${SCRIPT_ROOT}/pkg/generated" \+ --output-pkg "github.com/langflow-ai/openrag-operator/pkg/generated" \+ --boilerplate "${SCRIPT_ROOT}/hack/boilerplate.go.txt" \+ "${SCRIPT_ROOT}"++echo ""+echo "✅ Code generation complete!"+echo ""+echo "Generated files:"+echo " - pkg/generated/clientset/versioned/ (Typed clientset)"+echo " - pkg/generated/listers/api/v1alpha1/ (Listers)"+echo " - pkg/generated/informers/externalversions/ (Informers)"+echo ""+echo "Users can now import:"+echo " import clientset \"github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned\""diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/clientset.go b/kubernetes/operator/pkg/generated/clientset/versioned/clientset.gonew file mode 100644index 000000000..e8f79b3ce--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/clientset.go@@ -0,0 +1,120 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++package versioned++import (+ fmt "fmt"+ http "net/http"++ openrv1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/typed/api/v1alpha1"+ discovery "k8s.io/client-go/discovery"+ rest "k8s.io/client-go/rest"+ flowcontrol "k8s.io/client-go/util/flowcontrol"+)++type Interface interface {+ Discovery() discovery.DiscoveryInterface+ OpenrV1alpha1() openrv1alpha1.OpenrV1alpha1Interface+}++// Clientset contains the clients for groups.+type Clientset struct {+ *discovery.DiscoveryClient+ openrV1alpha1 *openrv1alpha1.OpenrV1alpha1Client+}++// OpenrV1alpha1 retrieves the OpenrV1alpha1Client+func (c *Clientset) OpenrV1alpha1() openrv1alpha1.OpenrV1alpha1Interface {+ return c.openrV1alpha1+}++// Discovery retrieves the DiscoveryClient+func (c *Clientset) Discovery() discovery.DiscoveryInterface {+ if c == nil {+ return nil+ }+ return c.DiscoveryClient+}++// NewForConfig creates a new Clientset for the given config.+// If config's RateLimiter is not set and QPS and Burst are acceptable,+// NewForConfig will generate a rate-limiter in configShallowCopy.+// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient),+// where httpClient was generated with rest.HTTPClientFor(c).+func NewForConfig(c *rest.Config) (*Clientset, error) {+ configShallowCopy := *c++ if configShallowCopy.UserAgent == "" {+ configShallowCopy.UserAgent = rest.DefaultKubernetesUserAgent()+ }++ // share the transport between all clients+ httpClient, err := rest.HTTPClientFor(&configShallowCopy)+ if err != nil {+ return nil, err+ }++ return NewForConfigAndClient(&configShallowCopy, httpClient)+}++// NewForConfigAndClient creates a new Clientset for the given config and http client.+// Note the http client provided takes precedence over the configured transport values.+// If config's RateLimiter is not set and QPS and Burst are acceptable,+// NewForConfigAndClient will generate a rate-limiter in configShallowCopy.+func NewForConfigAndClient(c *rest.Config, httpClient *http.Client) (*Clientset, error) {+ configShallowCopy := *c+ if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {+ if configShallowCopy.Burst <= 0 {+ return nil, fmt.Errorf("burst is required to be greater than 0 when RateLimiter is not set and QPS is set to greater than 0")+ }+ configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)+ }++ var cs Clientset+ var err error+ cs.openrV1alpha1, err = openrv1alpha1.NewForConfigAndClient(&configShallowCopy, httpClient)+ if err != nil {+ return nil, err+ }++ cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfigAndClient(&configShallowCopy, httpClient)+ if err != nil {+ return nil, err+ }+ return &cs, nil+}++// NewForConfigOrDie creates a new Clientset for the given config and+// panics if there is an error in the config.+func NewForConfigOrDie(c *rest.Config) *Clientset {+ cs, err := NewForConfig(c)+ if err != nil {+ panic(err)+ }+ return cs+}++// New creates a new Clientset for the given RESTClient.+func New(c rest.Interface) *Clientset {+ var cs Clientset+ cs.openrV1alpha1 = openrv1alpha1.New(c)++ cs.DiscoveryClient = discovery.NewDiscoveryClient(c)+ return &cs+}diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/fake/clientset_generated.go b/kubernetes/operator/pkg/generated/clientset/versioned/fake/clientset_generated.gonew file mode 100644index 000000000..1cbf72844--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/fake/clientset_generated.go@@ -0,0 +1,94 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++package fake++import (+ clientset "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"+ openrv1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/typed/api/v1alpha1"+ fakeopenrv1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake"+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ "k8s.io/apimachinery/pkg/runtime"+ "k8s.io/apimachinery/pkg/watch"+ "k8s.io/client-go/discovery"+ fakediscovery "k8s.io/client-go/discovery/fake"+ "k8s.io/client-go/testing"+)++// NewSimpleClientset returns a clientset that will respond with the provided objects.+// It's backed by a very simple object tracker that processes creates, updates and deletions as-is,+// without applying any field management, validations and/or defaults. It shouldn't be considered a replacement+// for a real clientset and is mostly useful in simple unit tests.+//+// DEPRECATED: NewClientset replaces this with support for field management, which significantly improves+// server side apply testing. NewClientset is only available when apply configurations are generated (e.g.+// via --with-applyconfig).+func NewSimpleClientset(objects ...runtime.Object) *Clientset {+ o := testing.NewObjectTracker(scheme, codecs.UniversalDecoder())+ for _, obj := range objects {+ if err := o.Add(obj); err != nil {+ panic(err)+ }+ }++ cs := &Clientset{tracker: o}+ cs.discovery = &fakediscovery.FakeDiscovery{Fake: &cs.Fake}+ cs.AddReactor("*", "*", testing.ObjectReaction(o))+ cs.AddWatchReactor("*", func(action testing.Action) (handled bool, ret watch.Interface, err error) {+ var opts metav1.ListOptions+ if watchActcion, ok := action.(testing.WatchActionImpl); ok {+ opts = watchActcion.ListOptions+ }+ gvr := action.GetResource()+ ns := action.GetNamespace()+ watch, err := o.Watch(gvr, ns, opts)+ if err != nil {+ return false, nil, err+ }+ return true, watch, nil+ })++ return cs+}++// Clientset implements clientset.Interface. Meant to be embedded into a+// struct to get a default implementation. This makes faking out just the method+// you want to test easier.+type Clientset struct {+ testing.Fake+ discovery *fakediscovery.FakeDiscovery+ tracker testing.ObjectTracker+}++func (c *Clientset) Discovery() discovery.DiscoveryInterface {+ return c.discovery+}++func (c *Clientset) Tracker() testing.ObjectTracker {+ return c.tracker+}++var (+ _ clientset.Interface = &Clientset{}+ _ testing.FakeClient = &Clientset{}+)++// OpenrV1alpha1 retrieves the OpenrV1alpha1Client+func (c *Clientset) OpenrV1alpha1() openrv1alpha1.OpenrV1alpha1Interface {+ return &fakeopenrv1alpha1.FakeOpenrV1alpha1{Fake: &c.Fake}+}diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/fake/doc.go b/kubernetes/operator/pkg/generated/clientset/versioned/fake/doc.gonew file mode 100644index 000000000..8aed70b3d--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/fake/doc.go@@ -0,0 +1,20 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++// This package has the automatically generated fake clientset.+package fakediff --git a/kubernetes/operator/pkg/generated/clientset/versioned/fake/register.go b/kubernetes/operator/pkg/generated/clientset/versioned/fake/register.gonew file mode 100644index 000000000..6b1d1c75e--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/fake/register.go@@ -0,0 +1,56 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++package fake++import (+ openrv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ runtime "k8s.io/apimachinery/pkg/runtime"+ schema "k8s.io/apimachinery/pkg/runtime/schema"+ serializer "k8s.io/apimachinery/pkg/runtime/serializer"+ utilruntime "k8s.io/apimachinery/pkg/util/runtime"+)++var scheme = runtime.NewScheme()+var codecs = serializer.NewCodecFactory(scheme)++var localSchemeBuilder = runtime.SchemeBuilder{+ openrv1alpha1.AddToScheme,+}++// AddToScheme adds all types of this clientset into the given scheme. This allows composition+// of clientsets, like in:+//+// import (+// "k8s.io/client-go/kubernetes"+// clientsetscheme "k8s.io/client-go/kubernetes/scheme"+// aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme"+// )+//+// kclientset, _ := kubernetes.NewForConfig(c)+// _ = aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme)+//+// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types+// correctly.+var AddToScheme = localSchemeBuilder.AddToScheme++func init() {+ v1.AddToGroupVersion(scheme, schema.GroupVersion{Version: "v1"})+ utilruntime.Must(AddToScheme(scheme))+}diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/scheme/doc.go b/kubernetes/operator/pkg/generated/clientset/versioned/scheme/doc.gonew file mode 100644index 000000000..31698488f--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/scheme/doc.go@@ -0,0 +1,20 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++// This package contains the scheme of the automatically generated clientset.+package schemediff --git a/kubernetes/operator/pkg/generated/clientset/versioned/scheme/register.go b/kubernetes/operator/pkg/generated/clientset/versioned/scheme/register.gonew file mode 100644index 000000000..b7c76391f--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/scheme/register.go@@ -0,0 +1,56 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++package scheme++import (+ openrv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ runtime "k8s.io/apimachinery/pkg/runtime"+ schema "k8s.io/apimachinery/pkg/runtime/schema"+ serializer "k8s.io/apimachinery/pkg/runtime/serializer"+ utilruntime "k8s.io/apimachinery/pkg/util/runtime"+)++var Scheme = runtime.NewScheme()+var Codecs = serializer.NewCodecFactory(Scheme)+var ParameterCodec = runtime.NewParameterCodec(Scheme)+var localSchemeBuilder = runtime.SchemeBuilder{+ openrv1alpha1.AddToScheme,+}++// AddToScheme adds all types of this clientset into the given scheme. This allows composition+// of clientsets, like in:+//+// import (+// "k8s.io/client-go/kubernetes"+// clientsetscheme "k8s.io/client-go/kubernetes/scheme"+// aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme"+// )+//+// kclientset, _ := kubernetes.NewForConfig(c)+// _ = aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme)+//+// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types+// correctly.+var AddToScheme = localSchemeBuilder.AddToScheme++func init() {+ v1.AddToGroupVersion(Scheme, schema.GroupVersion{Version: "v1"})+ utilruntime.Must(AddToScheme(Scheme))+}diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/api_client.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/api_client.gonew file mode 100644index 000000000..dfe94a579--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/api_client.go@@ -0,0 +1,101 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++package v1alpha1++import (+ http "net/http"++ apiv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ scheme "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/scheme"+ rest "k8s.io/client-go/rest"+)++type OpenrV1alpha1Interface interface {+ RESTClient() rest.Interface+ OpenRAGsGetter+}++// OpenrV1alpha1Client is used to interact with features provided by the openr.ag group.+type OpenrV1alpha1Client struct {+ restClient rest.Interface+}++func (c *OpenrV1alpha1Client) OpenRAGs(namespace string) OpenRAGInterface {+ return newOpenRAGs(c, namespace)+}++// NewForConfig creates a new OpenrV1alpha1Client for the given config.+// NewForConfig is equivalent to NewForConfigAndClient(c, httpClient),+// where httpClient was generated with rest.HTTPClientFor(c).+func NewForConfig(c *rest.Config) (*OpenrV1alpha1Client, error) {+ config := *c+ setConfigDefaults(&config)+ httpClient, err := rest.HTTPClientFor(&config)+ if err != nil {+ return nil, err+ }+ return NewForConfigAndClient(&config, httpClient)+}++// NewForConfigAndClient creates a new OpenrV1alpha1Client for the given config and http client.+// Note the http client provided takes precedence over the configured transport values.+func NewForConfigAndClient(c *rest.Config, h *http.Client) (*OpenrV1alpha1Client, error) {+ config := *c+ setConfigDefaults(&config)+ client, err := rest.RESTClientForConfigAndClient(&config, h)+ if err != nil {+ return nil, err+ }+ return &OpenrV1alpha1Client{client}, nil+}++// NewForConfigOrDie creates a new OpenrV1alpha1Client for the given config and+// panics if there is an error in the config.+func NewForConfigOrDie(c *rest.Config) *OpenrV1alpha1Client {+ client, err := NewForConfig(c)+ if err != nil {+ panic(err)+ }+ return client+}++// New creates a new OpenrV1alpha1Client for the given RESTClient.+func New(c rest.Interface) *OpenrV1alpha1Client {+ return &OpenrV1alpha1Client{c}+}++func setConfigDefaults(config *rest.Config) {+ gv := apiv1alpha1.SchemeGroupVersion+ config.GroupVersion = &gv+ config.APIPath = "/apis"+ config.NegotiatedSerializer = rest.CodecFactoryForGeneratedClient(scheme.Scheme, scheme.Codecs).WithoutConversion()++ if config.UserAgent == "" {+ config.UserAgent = rest.DefaultKubernetesUserAgent()+ }+}++// RESTClient returns a RESTClient that is used to communicate+// with API server by this client implementation.+func (c *OpenrV1alpha1Client) RESTClient() rest.Interface {+ if c == nil {+ return nil+ }+ return c.restClient+}diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/doc.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/doc.gonew file mode 100644index 000000000..bd9b51cf5--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/doc.go@@ -0,0 +1,20 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++// This package has the automatically generated typed clients.+package v1alpha1diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/doc.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/doc.gonew file mode 100644index 000000000..e9452deb6--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/doc.go@@ -0,0 +1,20 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++// Package fake has the automatically generated clients.+package fakediff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_api_client.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_api_client.gonew file mode 100644index 000000000..6ed62da4d--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_api_client.go@@ -0,0 +1,40 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++package fake++import (+ v1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/typed/api/v1alpha1"+ rest "k8s.io/client-go/rest"+ testing "k8s.io/client-go/testing"+)++type FakeOpenrV1alpha1 struct {+ *testing.Fake+}++func (c *FakeOpenrV1alpha1) OpenRAGs(namespace string) v1alpha1.OpenRAGInterface {+ return newFakeOpenRAGs(c, namespace)+}++// RESTClient returns a RESTClient that is used to communicate+// with API server by this client implementation.+func (c *FakeOpenrV1alpha1) RESTClient() rest.Interface {+ var ret *rest.RESTClient+ return ret+}diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_openrag.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_openrag.gonew file mode 100644index 000000000..b9c84167f--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/fake/fake_openrag.go@@ -0,0 +1,50 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++package fake++import (+ v1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ apiv1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/typed/api/v1alpha1"+ gentype "k8s.io/client-go/gentype"+)++// fakeOpenRAGs implements OpenRAGInterface+type fakeOpenRAGs struct {+ *gentype.FakeClientWithList[*v1alpha1.OpenRAG, *v1alpha1.OpenRAGList]+ Fake *FakeOpenrV1alpha1+}++func newFakeOpenRAGs(fake *FakeOpenrV1alpha1, namespace string) apiv1alpha1.OpenRAGInterface {+ return &fakeOpenRAGs{+ gentype.NewFakeClientWithList[*v1alpha1.OpenRAG, *v1alpha1.OpenRAGList](+ fake.Fake,+ namespace,+ v1alpha1.SchemeGroupVersion.WithResource("openrags"),+ v1alpha1.SchemeGroupVersion.WithKind("OpenRAG"),+ func() *v1alpha1.OpenRAG { return &v1alpha1.OpenRAG{} },+ func() *v1alpha1.OpenRAGList { return &v1alpha1.OpenRAGList{} },+ func(dst, src *v1alpha1.OpenRAGList) { dst.ListMeta = src.ListMeta },+ func(list *v1alpha1.OpenRAGList) []*v1alpha1.OpenRAG { return gentype.ToPointerSlice(list.Items) },+ func(list *v1alpha1.OpenRAGList, items []*v1alpha1.OpenRAG) {+ list.Items = gentype.FromPointerSlice(items)+ },+ ),+ fake,+ }+}diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/generated_expansion.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/generated_expansion.gonew file mode 100644index 000000000..198f5ffd1--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/generated_expansion.go@@ -0,0 +1,21 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++package v1alpha1++type OpenRAGExpansion interface{}diff --git a/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/openrag.go b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/openrag.gonew file mode 100644index 000000000..f1fa8dfc9--- /dev/null+++ b/kubernetes/operator/pkg/generated/clientset/versioned/typed/api/v1alpha1/openrag.go@@ -0,0 +1,70 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by client-gen. DO NOT EDIT.++package v1alpha1++import (+ context "context"++ apiv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ scheme "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned/scheme"+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ types "k8s.io/apimachinery/pkg/types"+ watch "k8s.io/apimachinery/pkg/watch"+ gentype "k8s.io/client-go/gentype"+)++// OpenRAGsGetter has a method to return a OpenRAGInterface.+// A group's client should implement this interface.+type OpenRAGsGetter interface {+ OpenRAGs(namespace string) OpenRAGInterface+}++// OpenRAGInterface has methods to work with OpenRAG resources.+type OpenRAGInterface interface {+ Create(ctx context.Context, openRAG *apiv1alpha1.OpenRAG, opts v1.CreateOptions) (*apiv1alpha1.OpenRAG, error)+ Update(ctx context.Context, openRAG *apiv1alpha1.OpenRAG, opts v1.UpdateOptions) (*apiv1alpha1.OpenRAG, error)+ // Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().+ UpdateStatus(ctx context.Context, openRAG *apiv1alpha1.OpenRAG, opts v1.UpdateOptions) (*apiv1alpha1.OpenRAG, error)+ Delete(ctx context.Context, name string, opts v1.DeleteOptions) error+ DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error+ Get(ctx context.Context, name string, opts v1.GetOptions) (*apiv1alpha1.OpenRAG, error)+ List(ctx context.Context, opts v1.ListOptions) (*apiv1alpha1.OpenRAGList, error)+ Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error)+ Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *apiv1alpha1.OpenRAG, err error)+ OpenRAGExpansion+}++// openRAGs implements OpenRAGInterface+type openRAGs struct {+ *gentype.ClientWithList[*apiv1alpha1.OpenRAG, *apiv1alpha1.OpenRAGList]+}++// newOpenRAGs returns a OpenRAGs+func newOpenRAGs(c *OpenrV1alpha1Client, namespace string) *openRAGs {+ return &openRAGs{+ gentype.NewClientWithList[*apiv1alpha1.OpenRAG, *apiv1alpha1.OpenRAGList](+ "openrags",+ c.RESTClient(),+ scheme.ParameterCodec,+ namespace,+ func() *apiv1alpha1.OpenRAG { return &apiv1alpha1.OpenRAG{} },+ func() *apiv1alpha1.OpenRAGList { return &apiv1alpha1.OpenRAGList{} },+ ),+ }+}diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/api/interface.go b/kubernetes/operator/pkg/generated/informers/externalversions/api/interface.gonew file mode 100644index 000000000..4d7ec382c--- /dev/null+++ b/kubernetes/operator/pkg/generated/informers/externalversions/api/interface.go@@ -0,0 +1,46 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by informer-gen. DO NOT EDIT.++package api++import (+ v1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/api/v1alpha1"+ internalinterfaces "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/internalinterfaces"+)++// Interface provides access to each of this group's versions.+type Interface interface {+ // V1alpha1 provides access to shared informers for resources in V1alpha1.+ V1alpha1() v1alpha1.Interface+}++type group struct {+ factory internalinterfaces.SharedInformerFactory+ namespace string+ tweakListOptions internalinterfaces.TweakListOptionsFunc+}++// New returns a new Interface.+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {+ return &group{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}+}++// V1alpha1 returns a new v1alpha1.Interface.+func (g *group) V1alpha1() v1alpha1.Interface {+ return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)+}diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/interface.go b/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/interface.gonew file mode 100644index 000000000..d5b5228bd--- /dev/null+++ b/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/interface.go@@ -0,0 +1,45 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by informer-gen. DO NOT EDIT.++package v1alpha1++import (+ internalinterfaces "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/internalinterfaces"+)++// Interface provides access to all the informers in this group version.+type Interface interface {+ // OpenRAGs returns a OpenRAGInformer.+ OpenRAGs() OpenRAGInformer+}++type version struct {+ factory internalinterfaces.SharedInformerFactory+ namespace string+ tweakListOptions internalinterfaces.TweakListOptionsFunc+}++// New returns a new Interface.+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {+ return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}+}++// OpenRAGs returns a OpenRAGInformer.+func (v *version) OpenRAGs() OpenRAGInformer {+ return &openRAGInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}+}diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/openrag.go b/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/openrag.gonew file mode 100644index 000000000..c952d7aa3--- /dev/null+++ b/kubernetes/operator/pkg/generated/informers/externalversions/api/v1alpha1/openrag.go@@ -0,0 +1,102 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by informer-gen. DO NOT EDIT.++package v1alpha1++import (+ context "context"+ time "time"++ openragoperatorapiv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ versioned "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"+ internalinterfaces "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/internalinterfaces"+ apiv1alpha1 "github.com/langflow-ai/openrag-operator/pkg/generated/listers/api/v1alpha1"+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ runtime "k8s.io/apimachinery/pkg/runtime"+ watch "k8s.io/apimachinery/pkg/watch"+ cache "k8s.io/client-go/tools/cache"+)++// OpenRAGInformer provides access to a shared informer and lister for+// OpenRAGs.+type OpenRAGInformer interface {+ Informer() cache.SharedIndexInformer+ Lister() apiv1alpha1.OpenRAGLister+}++type openRAGInformer struct {+ factory internalinterfaces.SharedInformerFactory+ tweakListOptions internalinterfaces.TweakListOptionsFunc+ namespace string+}++// NewOpenRAGInformer constructs a new informer for OpenRAG type.+// Always prefer using an informer factory to get a shared informer instead of getting an independent+// one. This reduces memory footprint and number of connections to the server.+func NewOpenRAGInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {+ return NewFilteredOpenRAGInformer(client, namespace, resyncPeriod, indexers, nil)+}++// NewFilteredOpenRAGInformer constructs a new informer for OpenRAG type.+// Always prefer using an informer factory to get a shared informer instead of getting an independent+// one. This reduces memory footprint and number of connections to the server.+func NewFilteredOpenRAGInformer(client versioned.Interface, namespace string, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {+ return cache.NewSharedIndexInformer(+ &cache.ListWatch{+ ListFunc: func(options v1.ListOptions) (runtime.Object, error) {+ if tweakListOptions != nil {+ tweakListOptions(&options)+ }+ return client.OpenrV1alpha1().OpenRAGs(namespace).List(context.Background(), options)+ },+ WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {+ if tweakListOptions != nil {+ tweakListOptions(&options)+ }+ return client.OpenrV1alpha1().OpenRAGs(namespace).Watch(context.Background(), options)+ },+ ListWithContextFunc: func(ctx context.Context, options v1.ListOptions) (runtime.Object, error) {+ if tweakListOptions != nil {+ tweakListOptions(&options)+ }+ return client.OpenrV1alpha1().OpenRAGs(namespace).List(ctx, options)+ },+ WatchFuncWithContext: func(ctx context.Context, options v1.ListOptions) (watch.Interface, error) {+ if tweakListOptions != nil {+ tweakListOptions(&options)+ }+ return client.OpenrV1alpha1().OpenRAGs(namespace).Watch(ctx, options)+ },+ },+ &openragoperatorapiv1alpha1.OpenRAG{},+ resyncPeriod,+ indexers,+ )+}++func (f *openRAGInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {+ return NewFilteredOpenRAGInformer(client, f.namespace, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)+}++func (f *openRAGInformer) Informer() cache.SharedIndexInformer {+ return f.factory.InformerFor(&openragoperatorapiv1alpha1.OpenRAG{}, f.defaultInformer)+}++func (f *openRAGInformer) Lister() apiv1alpha1.OpenRAGLister {+ return apiv1alpha1.NewOpenRAGLister(f.Informer().GetIndexer())+}diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/factory.go b/kubernetes/operator/pkg/generated/informers/externalversions/factory.gonew file mode 100644index 000000000..6896c0e60--- /dev/null+++ b/kubernetes/operator/pkg/generated/informers/externalversions/factory.go@@ -0,0 +1,262 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by informer-gen. DO NOT EDIT.++package externalversions++import (+ reflect "reflect"+ sync "sync"+ time "time"++ versioned "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"+ api "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/api"+ internalinterfaces "github.com/langflow-ai/openrag-operator/pkg/generated/informers/externalversions/internalinterfaces"+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ runtime "k8s.io/apimachinery/pkg/runtime"+ schema "k8s.io/apimachinery/pkg/runtime/schema"+ cache "k8s.io/client-go/tools/cache"+)++// SharedInformerOption defines the functional option type for SharedInformerFactory.+type SharedInformerOption func(*sharedInformerFactory) *sharedInformerFactory++type sharedInformerFactory struct {+ client versioned.Interface+ namespace string+ tweakListOptions internalinterfaces.TweakListOptionsFunc+ lock sync.Mutex+ defaultResync time.Duration+ customResync map[reflect.Type]time.Duration+ transform cache.TransformFunc++ informers map[reflect.Type]cache.SharedIndexInformer+ // startedInformers is used for tracking which informers have been started.+ // This allows Start() to be called multiple times safely.+ startedInformers map[reflect.Type]bool+ // wg tracks how many goroutines were started.+ wg sync.WaitGroup+ // shuttingDown is true when Shutdown has been called. It may still be running+ // because it needs to wait for goroutines.+ shuttingDown bool+}++// WithCustomResyncConfig sets a custom resync period for the specified informer types.+func WithCustomResyncConfig(resyncConfig map[v1.Object]time.Duration) SharedInformerOption {+ return func(factory *sharedInformerFactory) *sharedInformerFactory {+ for k, v := range resyncConfig {+ factory.customResync[reflect.TypeOf(k)] = v+ }+ return factory+ }+}++// WithTweakListOptions sets a custom filter on all listers of the configured SharedInformerFactory.+func WithTweakListOptions(tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerOption {+ return func(factory *sharedInformerFactory) *sharedInformerFactory {+ factory.tweakListOptions = tweakListOptions+ return factory+ }+}++// WithNamespace limits the SharedInformerFactory to the specified namespace.+func WithNamespace(namespace string) SharedInformerOption {+ return func(factory *sharedInformerFactory) *sharedInformerFactory {+ factory.namespace = namespace+ return factory+ }+}++// WithTransform sets a transform on all informers.+func WithTransform(transform cache.TransformFunc) SharedInformerOption {+ return func(factory *sharedInformerFactory) *sharedInformerFactory {+ factory.transform = transform+ return factory+ }+}++// NewSharedInformerFactory constructs a new instance of sharedInformerFactory for all namespaces.+func NewSharedInformerFactory(client versioned.Interface, defaultResync time.Duration) SharedInformerFactory {+ return NewSharedInformerFactoryWithOptions(client, defaultResync)+}++// NewFilteredSharedInformerFactory constructs a new instance of sharedInformerFactory.+// Listers obtained via this SharedInformerFactory will be subject to the same filters+// as specified here.+// Deprecated: Please use NewSharedInformerFactoryWithOptions instead+func NewFilteredSharedInformerFactory(client versioned.Interface, defaultResync time.Duration, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) SharedInformerFactory {+ return NewSharedInformerFactoryWithOptions(client, defaultResync, WithNamespace(namespace), WithTweakListOptions(tweakListOptions))+}++// NewSharedInformerFactoryWithOptions constructs a new instance of a SharedInformerFactory with additional options.+func NewSharedInformerFactoryWithOptions(client versioned.Interface, defaultResync time.Duration, options ...SharedInformerOption) SharedInformerFactory {+ factory := &sharedInformerFactory{+ client: client,+ namespace: v1.NamespaceAll,+ defaultResync: defaultResync,+ informers: make(map[reflect.Type]cache.SharedIndexInformer),+ startedInformers: make(map[reflect.Type]bool),+ customResync: make(map[reflect.Type]time.Duration),+ }++ // Apply all options+ for _, opt := range options {+ factory = opt(factory)+ }++ return factory+}++func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {+ f.lock.Lock()+ defer f.lock.Unlock()++ if f.shuttingDown {+ return+ }++ for informerType, informer := range f.informers {+ if !f.startedInformers[informerType] {+ f.wg.Add(1)+ // We need a new variable in each loop iteration,+ // otherwise the goroutine would use the loop variable+ // and that keeps changing.+ informer := informer+ go func() {+ defer f.wg.Done()+ informer.Run(stopCh)+ }()+ f.startedInformers[informerType] = true+ }+ }+}++func (f *sharedInformerFactory) Shutdown() {+ f.lock.Lock()+ f.shuttingDown = true+ f.lock.Unlock()++ // Will return immediately if there is nothing to wait for.+ f.wg.Wait()+}++func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool {+ informers := func() map[reflect.Type]cache.SharedIndexInformer {+ f.lock.Lock()+ defer f.lock.Unlock()++ informers := map[reflect.Type]cache.SharedIndexInformer{}+ for informerType, informer := range f.informers {+ if f.startedInformers[informerType] {+ informers[informerType] = informer+ }+ }+ return informers+ }()++ res := map[reflect.Type]bool{}+ for informType, informer := range informers {+ res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced)+ }+ return res+}++// InformerFor returns the SharedIndexInformer for obj using an internal+// client.+func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer {+ f.lock.Lock()+ defer f.lock.Unlock()++ informerType := reflect.TypeOf(obj)+ informer, exists := f.informers[informerType]+ if exists {+ return informer+ }++ resyncPeriod, exists := f.customResync[informerType]+ if !exists {+ resyncPeriod = f.defaultResync+ }++ informer = newFunc(f.client, resyncPeriod)+ informer.SetTransform(f.transform)+ f.informers[informerType] = informer++ return informer+}++// SharedInformerFactory provides shared informers for resources in all known+// API group versions.+//+// It is typically used like this:+//+// ctx, cancel := context.Background()+// defer cancel()+// factory := NewSharedInformerFactory(client, resyncPeriod)+// defer factory.WaitForStop() // Returns immediately if nothing was started.+// genericInformer := factory.ForResource(resource)+// typedInformer := factory.SomeAPIGroup().V1().SomeType()+// factory.Start(ctx.Done()) // Start processing these informers.+// synced := factory.WaitForCacheSync(ctx.Done())+// for v, ok := range synced {+// if !ok {+// fmt.Fprintf(os.Stderr, "caches failed to sync: %v", v)+// return+// }+// }+//+// // Creating informers can also be created after Start, but then+// // Start must be called again:+// anotherGenericInformer := factory.ForResource(resource)+// factory.Start(ctx.Done())+type SharedInformerFactory interface {+ internalinterfaces.SharedInformerFactory++ // Start initializes all requested informers. They are handled in goroutines+ // which run until the stop channel gets closed.+ // Warning: Start does not block. When run in a go-routine, it will race with a later WaitForCacheSync.+ Start(stopCh <-chan struct{})++ // Shutdown marks a factory as shutting down. At that point no new+ // informers can be started anymore and Start will return without+ // doing anything.+ //+ // In addition, Shutdown blocks until all goroutines have terminated. For that+ // to happen, the close channel(s) that they were started with must be closed,+ // either before Shutdown gets called or while it is waiting.+ //+ // Shutdown may be called multiple times, even concurrently. All such calls will+ // block until all goroutines have terminated.+ Shutdown()++ // WaitForCacheSync blocks until all started informers' caches were synced+ // or the stop channel gets closed.+ WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool++ // ForResource gives generic access to a shared informer of the matching type.+ ForResource(resource schema.GroupVersionResource) (GenericInformer, error)++ // InformerFor returns the SharedIndexInformer for obj using an internal+ // client.+ InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer++ Openr() api.Interface+}++func (f *sharedInformerFactory) Openr() api.Interface {+ return api.New(f, f.namespace, f.tweakListOptions)+}diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/generic.go b/kubernetes/operator/pkg/generated/informers/externalversions/generic.gonew file mode 100644index 000000000..6c5038a8a--- /dev/null+++ b/kubernetes/operator/pkg/generated/informers/externalversions/generic.go@@ -0,0 +1,62 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by informer-gen. DO NOT EDIT.++package externalversions++import (+ fmt "fmt"++ v1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ schema "k8s.io/apimachinery/pkg/runtime/schema"+ cache "k8s.io/client-go/tools/cache"+)++// GenericInformer is type of SharedIndexInformer which will locate and delegate to other+// sharedInformers based on type+type GenericInformer interface {+ Informer() cache.SharedIndexInformer+ Lister() cache.GenericLister+}++type genericInformer struct {+ informer cache.SharedIndexInformer+ resource schema.GroupResource+}++// Informer returns the SharedIndexInformer.+func (f *genericInformer) Informer() cache.SharedIndexInformer {+ return f.informer+}++// Lister returns the GenericLister.+func (f *genericInformer) Lister() cache.GenericLister {+ return cache.NewGenericLister(f.Informer().GetIndexer(), f.resource)+}++// ForResource gives generic access to a shared informer of the matching type+// TODO extend this to unknown resources with a client pool+func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {+ switch resource {+ // Group=openr.ag, Version=v1alpha1+ case v1alpha1.SchemeGroupVersion.WithResource("openrags"):+ return &genericInformer{resource: resource.GroupResource(), informer: f.Openr().V1alpha1().OpenRAGs().Informer()}, nil++ }++ return nil, fmt.Errorf("no informer found for %v", resource)+}diff --git a/kubernetes/operator/pkg/generated/informers/externalversions/internalinterfaces/factory_interfaces.go b/kubernetes/operator/pkg/generated/informers/externalversions/internalinterfaces/factory_interfaces.gonew file mode 100644index 000000000..2ecd8bd32--- /dev/null+++ b/kubernetes/operator/pkg/generated/informers/externalversions/internalinterfaces/factory_interfaces.go@@ -0,0 +1,40 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by informer-gen. DO NOT EDIT.++package internalinterfaces++import (+ time "time"++ versioned "github.com/langflow-ai/openrag-operator/pkg/generated/clientset/versioned"+ v1 "k8s.io/apimachinery/pkg/apis/meta/v1"+ runtime "k8s.io/apimachinery/pkg/runtime"+ cache "k8s.io/client-go/tools/cache"+)++// NewInformerFunc takes versioned.Interface and time.Duration to return a SharedIndexInformer.+type NewInformerFunc func(versioned.Interface, time.Duration) cache.SharedIndexInformer++// SharedInformerFactory a small interface to allow for adding an informer without an import cycle+type SharedInformerFactory interface {+ Start(stopCh <-chan struct{})+ InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer+}++// TweakListOptionsFunc is a function that transforms a v1.ListOptions.+type TweakListOptionsFunc func(*v1.ListOptions)diff --git a/kubernetes/operator/pkg/generated/listers/api/v1alpha1/expansion_generated.go b/kubernetes/operator/pkg/generated/listers/api/v1alpha1/expansion_generated.gonew file mode 100644index 000000000..cb9549d46--- /dev/null+++ b/kubernetes/operator/pkg/generated/listers/api/v1alpha1/expansion_generated.go@@ -0,0 +1,27 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by lister-gen. DO NOT EDIT.++package v1alpha1++// OpenRAGListerExpansion allows custom methods to be added to+// OpenRAGLister.+type OpenRAGListerExpansion interface{}++// OpenRAGNamespaceListerExpansion allows custom methods to be added to+// OpenRAGNamespaceLister.+type OpenRAGNamespaceListerExpansion interface{}diff --git a/kubernetes/operator/pkg/generated/listers/api/v1alpha1/openrag.go b/kubernetes/operator/pkg/generated/listers/api/v1alpha1/openrag.gonew file mode 100644index 000000000..d71dc685a--- /dev/null+++ b/kubernetes/operator/pkg/generated/listers/api/v1alpha1/openrag.go@@ -0,0 +1,70 @@+/*+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.+You may obtain a copy of the License at++ http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Code generated by lister-gen. DO NOT EDIT.++package v1alpha1++import (+ apiv1alpha1 "github.com/langflow-ai/openrag-operator/api/v1alpha1"+ labels "k8s.io/apimachinery/pkg/labels"+ listers "k8s.io/client-go/listers"+ cache "k8s.io/client-go/tools/cache"+)++// OpenRAGLister helps list OpenRAGs.+// All objects returned here must be treated as read-only.+type OpenRAGLister interface {+ // List lists all OpenRAGs in the indexer.+ // Objects returned here must be treated as read-only.+ List(selector labels.Selector) (ret []*apiv1alpha1.OpenRAG, err error)+ // OpenRAGs returns an object that can list and get OpenRAGs.+ OpenRAGs(namespace string) OpenRAGNamespaceLister+ OpenRAGListerExpansion+}++// openRAGLister implements the OpenRAGLister interface.+type openRAGLister struct {+ listers.ResourceIndexer[*apiv1alpha1.OpenRAG]+}++// NewOpenRAGLister returns a new OpenRAGLister.+func NewOpenRAGLister(indexer cache.Indexer) OpenRAGLister {+ return &openRAGLister{listers.New[*apiv1alpha1.OpenRAG](indexer, apiv1alpha1.Resource("openrag"))}+}++// OpenRAGs returns an object that can list and get OpenRAGs.+func (s *openRAGLister) OpenRAGs(namespace string) OpenRAGNamespaceLister {+ return openRAGNamespaceLister{listers.NewNamespaced[*apiv1alpha1.OpenRAG](s.ResourceIndexer, namespace)}+}++// OpenRAGNamespaceLister helps list and get OpenRAGs.+// All objects returned here must be treated as read-only.+type OpenRAGNamespaceLister interface {+ // List lists all OpenRAGs in the indexer for a given namespace.+ // Objects returned here must be treated as read-only.+ List(selector labels.Selector) (ret []*apiv1alpha1.OpenRAG, err error)+ // Get retrieves the OpenRAG from the indexer for a given namespace and name.+ // Objects returned here must be treated as read-only.+ Get(name string) (*apiv1alpha1.OpenRAG, error)+ OpenRAGNamespaceListerExpansion+}++// openRAGNamespaceLister implements the OpenRAGNamespaceLister+// interface.+type openRAGNamespaceLister struct {+ listers.ResourceIndexer[*apiv1alpha1.OpenRAG]+}