From 469687e19a232e913a6c9010a76e8d72311b5d39 Mon Sep 17 00:00:00 2001 From: Karol Szwaj Date: Wed, 4 Feb 2026 17:46:25 +0100 Subject: [PATCH 1/5] Add owner references to BoundSchema Signed-off-by: Karol Szwaj On-behalf-of: @SAP karol.szwaj@sap.com --- .../serviceexportrequest_reconcile.go | 46 +++++++++++- test/e2e/bind/happy-case_test.go | 74 +++++++++++++++++++ 2 files changed, 117 insertions(+), 3 deletions(-) diff --git a/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go b/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go index 617c09930..4b125f34d 100644 --- a/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go +++ b/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go @@ -31,6 +31,7 @@ import ( "k8s.io/klog/v2" "sigs.k8s.io/controller-runtime/pkg/cache" "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "github.com/kube-bind/kube-bind/backend/kubernetes/resources" kubebindv1alpha2 "github.com/kube-bind/kube-bind/sdk/apis/kubebind/v1alpha2" @@ -75,15 +76,54 @@ func (r *reconciler) reconcile(ctx context.Context, cl client.Client, cache cach return fmt.Errorf("failed to ensure APIServiceNamespaces: %w", err) } - // TODO(mjudeikis): we could potentially add finallizer to APIServiceExport above or "adopt" boundschemas - // with owner references once export is created. - // https://github.com/kube-bind/kube-bind/issues/297 + if err := r.setBoundSchemaOwnerRefs(ctx, cl, cache, req); err != nil { + conditions.SetSummary(req) + return fmt.Errorf("failed to adopt BoundSchemas: %w", err) + } conditions.SetSummary(req) return nil } +func (r *reconciler) setBoundSchemaOwnerRefs(ctx context.Context, cl client.Client, cache cache.Cache, req *kubebindv1alpha2.APIServiceExportRequest) error { + logger := klog.FromContext(ctx) + + export, err := r.getServiceExport(ctx, cache, req.Namespace, req.Name) + if err != nil { + if apierrors.IsNotFound(err) { + return nil + } + return fmt.Errorf("failed to get APIServiceExport: %w", err) + } + + for _, res := range req.Spec.Resources { + name := res.ResourceGroupName() + boundSchema, err := r.getBoundSchema(ctx, cl, req.Namespace, name) + if err != nil { + if apierrors.IsNotFound(err) { + continue + } + return fmt.Errorf("failed to get BoundSchema %s: %w", name, err) + } + + if err := controllerutil.SetControllerReference(export, boundSchema, cl.Scheme()); err != nil { + return fmt.Errorf("failed to set owner reference on BoundSchema %s: %w", name, err) + } + + if err := cl.Update(ctx, boundSchema); err != nil { + return fmt.Errorf("failed to update BoundSchema %s with owner reference: %w", name, err) + } + + logger.V(6).Info("Set owner reference on BoundSchema", + "boundSchema", name, + "export", export.Name, + "namespace", req.Namespace) + } + + return nil +} + // getExportedSchemas will list all schemas, exported by current backend. // Important: getExportedSchemas is using client.Client to list resources, not cache. // This is due to fact we use dynamic client and unstructured.Unstructured to get schemas and it diff --git a/test/e2e/bind/happy-case_test.go b/test/e2e/bind/happy-case_test.go index 64106f3a2..3e055abb9 100644 --- a/test/e2e/bind/happy-case_test.go +++ b/test/e2e/bind/happy-case_test.go @@ -448,6 +448,41 @@ func testHappyCase( require.NotEqual(t, consumer.providerContractNamespace, "unknown") }, }, + { + name: "verify BoundSchemas have owner references to APIServiceExport", + step: func(t *testing.T) { + t.Logf("Verifying BoundSchemas have owner references to APIServiceExport") + export, err := providerBindClient.KubeBindV1alpha2().APIServiceExports(consumer.providerContractNamespace).Get(ctx, "test-binding", metav1.GetOptions{}) + require.NoError(t, err, "APIServiceExport should exist") + + boundSchemas, err := providerBindClient.KubeBindV1alpha2().BoundSchemas(consumer.providerContractNamespace).List(ctx, metav1.ListOptions{}) + require.NoError(t, err, "should be able to list BoundSchemas") + require.NotEmpty(t, boundSchemas.Items, "should have at least one BoundSchema") + + // Verify each BoundSchema has an owner reference to the APIServiceExport + for _, boundSchema := range boundSchemas.Items { + t.Logf("Checking owner reference for BoundSchema %s", boundSchema.Name) + + var hasOwnerRef bool + for _, ownerRef := range boundSchema.OwnerReferences { + if ownerRef.Kind == "APIServiceExport" && + ownerRef.Name == export.Name && + ownerRef.UID == export.UID && + ownerRef.Controller != nil && + *ownerRef.Controller { + hasOwnerRef = true + break + } + } + + require.True(t, hasOwnerRef, + "BoundSchema %s should have controller owner reference to APIServiceExport %s", + boundSchema.Name, export.Name) + } + + t.Logf("All BoundSchemas have proper owner references") + }, + }, // Request included namespace, so we check it first { name: "verify provider side namespace pre-seeding and RBAC management", @@ -759,6 +794,45 @@ func testHappyCase( }, wait.ForeverTestTimeout, time.Millisecond*100, "waiting for the %s instance to be deleted on provider side for %s", serviceGVR.Resource, consumer.name) }, }, + { + name: "verify BoundSchemas are cleaned up when APIServiceExport is deleted", + step: func(t *testing.T) { + t.Logf("Verifying BoundSchema cleanup via owner reference for %s", consumer.name) + + boundSchemasBefore, err := providerBindClient.KubeBindV1alpha2().BoundSchemas(consumer.providerContractNamespace).List(ctx, metav1.ListOptions{}) + require.NoError(t, err) + require.NotEmpty(t, boundSchemasBefore.Items, "should have BoundSchemas before deletion") + + boundSchemaNames := make([]string, 0, len(boundSchemasBefore.Items)) + for _, bs := range boundSchemasBefore.Items { + boundSchemaNames = append(boundSchemaNames, bs.Name) + } + t.Logf("Found %d BoundSchemas before deletion: %v", len(boundSchemaNames), boundSchemaNames) + + t.Logf("Deleting APIServiceExport for %s", consumer.name) + err = providerBindClient.KubeBindV1alpha2().APIServiceExports(consumer.providerContractNamespace).Delete(ctx, "test-binding", metav1.DeleteOptions{}) + require.NoError(t, err) + + require.Eventually(t, func() bool { + _, err := providerBindClient.KubeBindV1alpha2().APIServiceExports(consumer.providerContractNamespace).Get(ctx, "test-binding", metav1.GetOptions{}) + return errors.IsNotFound(err) + }, wait.ForeverTestTimeout, time.Millisecond*100, "waiting for APIServiceExport to be deleted") + + t.Logf("Verifying all BoundSchemas are automatically deleted") + require.Eventually(t, func() bool { + for _, boundSchemaName := range boundSchemaNames { + _, err := providerBindClient.KubeBindV1alpha2().BoundSchemas(consumer.providerContractNamespace).Get(ctx, boundSchemaName, metav1.GetOptions{}) + if !errors.IsNotFound(err) { + t.Logf("BoundSchema %s still exists or error: %v", boundSchemaName, err) + return false + } + } + return true + }, wait.ForeverTestTimeout, time.Millisecond*100, "waiting for all BoundSchemas to be garbage collected") + + t.Logf("Successfully verified BoundSchema cleanup for %s", consumer.name) + }, + }, } { t.Run(tc.name, tc.step) } From c44732d7370aef6744afdb40b5738918d1700d53 Mon Sep 17 00:00:00 2001 From: Karol Szwaj Date: Thu, 5 Feb 2026 10:53:18 +0100 Subject: [PATCH 2/5] check for deletion in e2e test Signed-off-by: Karol Szwaj --- test/e2e/bind/happy-case_test.go | 32 ++++++++++++++++++++++++++++---- 1 file changed, 28 insertions(+), 4 deletions(-) diff --git a/test/e2e/bind/happy-case_test.go b/test/e2e/bind/happy-case_test.go index 3e055abb9..266440ec2 100644 --- a/test/e2e/bind/happy-case_test.go +++ b/test/e2e/bind/happy-case_test.go @@ -453,6 +453,9 @@ func testHappyCase( step: func(t *testing.T) { t.Logf("Verifying BoundSchemas have owner references to APIServiceExport") export, err := providerBindClient.KubeBindV1alpha2().APIServiceExports(consumer.providerContractNamespace).Get(ctx, "test-binding", metav1.GetOptions{}) + if errors.IsNotFound(err) && consumer.name != "consumer1" { + t.Skip("APIServiceExport already deleted by another consumer") + } require.NoError(t, err, "APIServiceExport should exist") boundSchemas, err := providerBindClient.KubeBindV1alpha2().BoundSchemas(consumer.providerContractNamespace).List(ctx, metav1.ListOptions{}) @@ -797,8 +800,20 @@ func testHappyCase( { name: "verify BoundSchemas are cleaned up when APIServiceExport is deleted", step: func(t *testing.T) { + // Skip for consumer2 since consumer1 will have already deleted the shared APIServiceExport + if consumer.name != "consumer1" { + t.Skip("Skipping cleanup test for non-first consumer to avoid shared resource conflict") + } + t.Logf("Verifying BoundSchema cleanup via owner reference for %s", consumer.name) + // Get the APIServiceExport first to check it exists + export, err := providerBindClient.KubeBindV1alpha2().APIServiceExports(consumer.providerContractNamespace).Get(ctx, "test-binding", metav1.GetOptions{}) + if errors.IsNotFound(err) { + t.Skip("APIServiceExport already deleted by another consumer") + } + require.NoError(t, err, "APIServiceExport should exist") + boundSchemasBefore, err := providerBindClient.KubeBindV1alpha2().BoundSchemas(consumer.providerContractNamespace).List(ctx, metav1.ListOptions{}) require.NoError(t, err) require.NotEmpty(t, boundSchemasBefore.Items, "should have BoundSchemas before deletion") @@ -806,10 +821,12 @@ func testHappyCase( boundSchemaNames := make([]string, 0, len(boundSchemasBefore.Items)) for _, bs := range boundSchemasBefore.Items { boundSchemaNames = append(boundSchemaNames, bs.Name) + t.Logf("BoundSchema %s has %d finalizers: %v, ownerRefs: %d", + bs.Name, len(bs.Finalizers), bs.Finalizers, len(bs.OwnerReferences)) } t.Logf("Found %d BoundSchemas before deletion: %v", len(boundSchemaNames), boundSchemaNames) - t.Logf("Deleting APIServiceExport for %s", consumer.name) + t.Logf("Deleting APIServiceExport %s (UID: %s) for %s", export.Name, export.UID, consumer.name) err = providerBindClient.KubeBindV1alpha2().APIServiceExports(consumer.providerContractNamespace).Delete(ctx, "test-binding", metav1.DeleteOptions{}) require.NoError(t, err) @@ -821,11 +838,18 @@ func testHappyCase( t.Logf("Verifying all BoundSchemas are automatically deleted") require.Eventually(t, func() bool { for _, boundSchemaName := range boundSchemaNames { - _, err := providerBindClient.KubeBindV1alpha2().BoundSchemas(consumer.providerContractNamespace).Get(ctx, boundSchemaName, metav1.GetOptions{}) - if !errors.IsNotFound(err) { - t.Logf("BoundSchema %s still exists or error: %v", boundSchemaName, err) + bs, err := providerBindClient.KubeBindV1alpha2().BoundSchemas(consumer.providerContractNamespace).Get(ctx, boundSchemaName, metav1.GetOptions{}) + if err != nil { + if errors.IsNotFound(err) { + continue + } + t.Logf("Error getting BoundSchema %s: %v", boundSchemaName, err) return false } + // Still exists - log details + t.Logf("BoundSchema %s still exists: finalizers=%v, deletionTimestamp=%v, ownerRefs=%d", + boundSchemaName, bs.Finalizers, bs.DeletionTimestamp, len(bs.OwnerReferences)) + return false } return true }, wait.ForeverTestTimeout, time.Millisecond*100, "waiting for all BoundSchemas to be garbage collected") From a99179c8051c819043c23a8d92841ba35fc0a86c Mon Sep 17 00:00:00 2001 From: Karol Szwaj Date: Thu, 5 Feb 2026 11:34:51 +0100 Subject: [PATCH 3/5] Revert e2e deletion test Signed-off-by: Karol Szwaj On-behalf-of: @SAP karol.szwaj@sap.com --- test/e2e/bind/happy-case_test.go | 60 -------------------------------- 1 file changed, 60 deletions(-) diff --git a/test/e2e/bind/happy-case_test.go b/test/e2e/bind/happy-case_test.go index 266440ec2..fcb87739d 100644 --- a/test/e2e/bind/happy-case_test.go +++ b/test/e2e/bind/happy-case_test.go @@ -797,66 +797,6 @@ func testHappyCase( }, wait.ForeverTestTimeout, time.Millisecond*100, "waiting for the %s instance to be deleted on provider side for %s", serviceGVR.Resource, consumer.name) }, }, - { - name: "verify BoundSchemas are cleaned up when APIServiceExport is deleted", - step: func(t *testing.T) { - // Skip for consumer2 since consumer1 will have already deleted the shared APIServiceExport - if consumer.name != "consumer1" { - t.Skip("Skipping cleanup test for non-first consumer to avoid shared resource conflict") - } - - t.Logf("Verifying BoundSchema cleanup via owner reference for %s", consumer.name) - - // Get the APIServiceExport first to check it exists - export, err := providerBindClient.KubeBindV1alpha2().APIServiceExports(consumer.providerContractNamespace).Get(ctx, "test-binding", metav1.GetOptions{}) - if errors.IsNotFound(err) { - t.Skip("APIServiceExport already deleted by another consumer") - } - require.NoError(t, err, "APIServiceExport should exist") - - boundSchemasBefore, err := providerBindClient.KubeBindV1alpha2().BoundSchemas(consumer.providerContractNamespace).List(ctx, metav1.ListOptions{}) - require.NoError(t, err) - require.NotEmpty(t, boundSchemasBefore.Items, "should have BoundSchemas before deletion") - - boundSchemaNames := make([]string, 0, len(boundSchemasBefore.Items)) - for _, bs := range boundSchemasBefore.Items { - boundSchemaNames = append(boundSchemaNames, bs.Name) - t.Logf("BoundSchema %s has %d finalizers: %v, ownerRefs: %d", - bs.Name, len(bs.Finalizers), bs.Finalizers, len(bs.OwnerReferences)) - } - t.Logf("Found %d BoundSchemas before deletion: %v", len(boundSchemaNames), boundSchemaNames) - - t.Logf("Deleting APIServiceExport %s (UID: %s) for %s", export.Name, export.UID, consumer.name) - err = providerBindClient.KubeBindV1alpha2().APIServiceExports(consumer.providerContractNamespace).Delete(ctx, "test-binding", metav1.DeleteOptions{}) - require.NoError(t, err) - - require.Eventually(t, func() bool { - _, err := providerBindClient.KubeBindV1alpha2().APIServiceExports(consumer.providerContractNamespace).Get(ctx, "test-binding", metav1.GetOptions{}) - return errors.IsNotFound(err) - }, wait.ForeverTestTimeout, time.Millisecond*100, "waiting for APIServiceExport to be deleted") - - t.Logf("Verifying all BoundSchemas are automatically deleted") - require.Eventually(t, func() bool { - for _, boundSchemaName := range boundSchemaNames { - bs, err := providerBindClient.KubeBindV1alpha2().BoundSchemas(consumer.providerContractNamespace).Get(ctx, boundSchemaName, metav1.GetOptions{}) - if err != nil { - if errors.IsNotFound(err) { - continue - } - t.Logf("Error getting BoundSchema %s: %v", boundSchemaName, err) - return false - } - // Still exists - log details - t.Logf("BoundSchema %s still exists: finalizers=%v, deletionTimestamp=%v, ownerRefs=%d", - boundSchemaName, bs.Finalizers, bs.DeletionTimestamp, len(bs.OwnerReferences)) - return false - } - return true - }, wait.ForeverTestTimeout, time.Millisecond*100, "waiting for all BoundSchemas to be garbage collected") - - t.Logf("Successfully verified BoundSchema cleanup for %s", consumer.name) - }, - }, } { t.Run(tc.name, tc.step) } From b0d84b8b83425dcce85b48f880e3a77c0cccc409 Mon Sep 17 00:00:00 2001 From: Karol Szwaj Date: Wed, 18 Feb 2026 16:36:55 +0100 Subject: [PATCH 4/5] refactor reconcile code, add update func for bound schemas Signed-off-by: Karol Szwaj On-behalf-of: @SAP karol.szwaj@sap.com --- .../serviceexportrequest_controller.go | 3 + .../serviceexportrequest_reconcile.go | 114 +++++++----------- 2 files changed, 45 insertions(+), 72 deletions(-) diff --git a/backend/controllers/serviceexportrequest/serviceexportrequest_controller.go b/backend/controllers/serviceexportrequest/serviceexportrequest_controller.go index 212aa49f8..318584c0f 100644 --- a/backend/controllers/serviceexportrequest/serviceexportrequest_controller.go +++ b/backend/controllers/serviceexportrequest/serviceexportrequest_controller.go @@ -105,6 +105,9 @@ func NewAPIServiceExportRequestReconciler( createBoundSchema: func(ctx context.Context, cl client.Client, schema *kubebindv1alpha2.BoundSchema) error { return cl.Create(ctx, schema) }, + updateBoundSchema: func(ctx context.Context, cl client.Client, schema *kubebindv1alpha2.BoundSchema) error { + return cl.Update(ctx, schema) + }, deleteServiceExportRequest: func(ctx context.Context, cl client.Client, ns, name string) error { return cl.Delete(ctx, &kubebindv1alpha2.APIServiceExportRequest{ ObjectMeta: metav1.ObjectMeta{ diff --git a/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go b/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go index 4b125f34d..fd9e1ca81 100644 --- a/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go +++ b/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go @@ -47,6 +47,7 @@ type reconciler struct { getBoundSchema func(ctx context.Context, cl client.Client, namespace, name string) (*kubebindv1alpha2.BoundSchema, error) createBoundSchema func(ctx context.Context, cl client.Client, schema *kubebindv1alpha2.BoundSchema) error + updateBoundSchema func(ctx context.Context, cl client.Client, schema *kubebindv1alpha2.BoundSchema) error getServiceExport func(ctx context.Context, cache cache.Cache, ns, name string) (*kubebindv1alpha2.APIServiceExport, error) createServiceExport func(ctx context.Context, cl client.Client, resource *kubebindv1alpha2.APIServiceExport) error @@ -54,9 +55,13 @@ type reconciler struct { } func (r *reconciler) reconcile(ctx context.Context, cl client.Client, cache cache.Cache, req *kubebindv1alpha2.APIServiceExportRequest) error { + export, err := r.getServiceExport(ctx, cache, req.Namespace, req.Name) + if err != nil && !apierrors.IsNotFound(err) { + return fmt.Errorf("failed to get APIServiceExport: %w", err) + } // We must ensure schemas are created in form of boundSchemas first for the validation. // Worst case scenario if validation fails, we will reuse schemas for same consumer once issues are fixed. - if err := r.ensureBoundSchemas(ctx, cl, cache, req); err != nil { + if err := r.ensureBoundSchemas(ctx, cl, export, req); err != nil { conditions.SetSummary(req) return fmt.Errorf("failed to ensure bound schemas: %w", err) } @@ -66,7 +71,7 @@ func (r *reconciler) reconcile(ctx context.Context, cl client.Client, cache cach return fmt.Errorf("failed to validate APIServiceExportRequest: %w", err) } - if err := r.ensureExports(ctx, cl, cache, req); err != nil { + if err := r.ensureExports(ctx, cl, export, req); err != nil { conditions.SetSummary(req) return fmt.Errorf("failed to ensure exports: %w", err) } @@ -76,54 +81,11 @@ func (r *reconciler) reconcile(ctx context.Context, cl client.Client, cache cach return fmt.Errorf("failed to ensure APIServiceNamespaces: %w", err) } - if err := r.setBoundSchemaOwnerRefs(ctx, cl, cache, req); err != nil { - conditions.SetSummary(req) - return fmt.Errorf("failed to adopt BoundSchemas: %w", err) - } - conditions.SetSummary(req) return nil } -func (r *reconciler) setBoundSchemaOwnerRefs(ctx context.Context, cl client.Client, cache cache.Cache, req *kubebindv1alpha2.APIServiceExportRequest) error { - logger := klog.FromContext(ctx) - - export, err := r.getServiceExport(ctx, cache, req.Namespace, req.Name) - if err != nil { - if apierrors.IsNotFound(err) { - return nil - } - return fmt.Errorf("failed to get APIServiceExport: %w", err) - } - - for _, res := range req.Spec.Resources { - name := res.ResourceGroupName() - boundSchema, err := r.getBoundSchema(ctx, cl, req.Namespace, name) - if err != nil { - if apierrors.IsNotFound(err) { - continue - } - return fmt.Errorf("failed to get BoundSchema %s: %w", name, err) - } - - if err := controllerutil.SetControllerReference(export, boundSchema, cl.Scheme()); err != nil { - return fmt.Errorf("failed to set owner reference on BoundSchema %s: %w", name, err) - } - - if err := cl.Update(ctx, boundSchema); err != nil { - return fmt.Errorf("failed to update BoundSchema %s with owner reference: %w", name, err) - } - - logger.V(6).Info("Set owner reference on BoundSchema", - "boundSchema", name, - "export", export.Name, - "namespace", req.Namespace) - } - - return nil -} - // getExportedSchemas will list all schemas, exported by current backend. // Important: getExportedSchemas is using client.Client to list resources, not cache. // This is due to fact we use dynamic client and unstructured.Unstructured to get schemas and it @@ -174,13 +136,12 @@ func (r *reconciler) getExportedSchemas(ctx context.Context, cl client.Client) ( return boundSchemas, nil } -func (r *reconciler) ensureBoundSchemas(ctx context.Context, cl client.Client, _ cache.Cache, req *kubebindv1alpha2.APIServiceExportRequest) error { +func (r *reconciler) ensureBoundSchemas(ctx context.Context, cl client.Client, export *kubebindv1alpha2.APIServiceExport, req *kubebindv1alpha2.APIServiceExportRequest) error { exportedSchemas, err := r.getExportedSchemas(ctx, cl) if err != nil { return err } - // Ensure all bound schemas exist for _, res := range req.Spec.Resources { if len(res.Versions) == 0 { continue @@ -193,35 +154,49 @@ func (r *reconciler) ensureBoundSchemas(ctx context.Context, cl client.Client, _ boundSchema.Spec.InformerScope = r.informerScope boundSchema.ResourceVersion = "" - obj, err := r.getBoundSchema(ctx, cl, boundSchema.Namespace, boundSchema.Name) - if err != nil && !apierrors.IsNotFound(err) && !strings.Contains(err.Error(), "no matches for kind") { + if err := r.createOrUpdateBoundSchema(ctx, cl, export, boundSchema); err != nil { return err } + } + } + } - // TODO(mjudeikis): https://github.com/kube-bind/kube-bind/issues/297 - if obj != nil { - continue - } + return nil +} - // If namespaced isolation is configured for cluster-scoped objects, - // we need to rewrite the BoundSchema's scope accordingly. For all - // other isolation strategies, as well as for namespaced schemas, - // no changes are necessary. - if boundSchema.Spec.Scope == apiextensionsv1.NamespaceScoped && r.isolation == kubebindv1alpha2.IsolationNamespaced { - boundSchema.Spec.Scope = apiextensionsv1.ClusterScoped - } +func (r *reconciler) createOrUpdateBoundSchema(ctx context.Context, cl client.Client, export *kubebindv1alpha2.APIServiceExport, desired *kubebindv1alpha2.BoundSchema) error { + logger := klog.FromContext(ctx) - if err := r.createBoundSchema(ctx, cl, boundSchema); err != nil { - return err - } - } + existing, err := r.getBoundSchema(ctx, cl, desired.Namespace, desired.Name) + if err != nil && !apierrors.IsNotFound(err) && !strings.Contains(err.Error(), "no matches for kind") { + return err + } + + if existing != nil { + if export == nil { + return nil + } + if err := controllerutil.SetControllerReference(export, existing, cl.Scheme()); err != nil { + return fmt.Errorf("failed to set owner reference on BoundSchema %s: %w", desired.Name, err) + } + if err := r.updateBoundSchema(ctx, cl, existing); err != nil { + return fmt.Errorf("failed to update BoundSchema %s with owner reference: %w", desired.Name, err) } + logger.V(6).Info("Updated owner reference on existing BoundSchema", + "boundSchema", desired.Name, + "export", export.Name, + "namespace", desired.Namespace) + return nil } - return nil + if desired.Spec.Scope == apiextensionsv1.NamespaceScoped && r.isolation == kubebindv1alpha2.IsolationNamespaced { + desired.Spec.Scope = apiextensionsv1.ClusterScoped + } + + return r.createBoundSchema(ctx, cl, desired) } -func (r *reconciler) ensureExports(ctx context.Context, cl client.Client, cache cache.Cache, req *kubebindv1alpha2.APIServiceExportRequest) error { +func (r *reconciler) ensureExports(ctx context.Context, cl client.Client, existingExport *kubebindv1alpha2.APIServiceExport, req *kubebindv1alpha2.APIServiceExportRequest) error { logger := klog.FromContext(ctx) var schemas []*kubebindv1alpha2.BoundSchema @@ -249,12 +224,7 @@ func (r *reconciler) ensureExports(ctx context.Context, cl client.Client, cache schemas = append(schemas, boundSchema) } - if _, err := r.getServiceExport(ctx, cache, req.Namespace, req.Name); err != nil { - if !apierrors.IsNotFound(err) { - return err - } - } else { - // already exists; nothing to do + if existingExport != nil { conditions.MarkTrue(req, kubebindv1alpha2.APIServiceExportRequestConditionExportsReady) return nil } From 9ea0ae3f1563896b66a9078b8f69fba9a14e424f Mon Sep 17 00:00:00 2001 From: Karol Szwaj Date: Wed, 18 Feb 2026 21:01:00 +0100 Subject: [PATCH 5/5] readd comments Signed-off-by: Karol Szwaj On-behalf-of: @SAP karol.szwaj@sap.com --- .../serviceexportrequest/serviceexportrequest_reconcile.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go b/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go index fd9e1ca81..9cd71cb7e 100644 --- a/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go +++ b/backend/controllers/serviceexportrequest/serviceexportrequest_reconcile.go @@ -189,6 +189,10 @@ func (r *reconciler) createOrUpdateBoundSchema(ctx context.Context, cl client.Cl return nil } + // If namespaced isolation is configured for cluster-scoped objects, + // we need to rewrite the BoundSchema's scope accordingly. For all + // other isolation strategies, as well as for namespaced schemas, + // no changes are necessary. if desired.Spec.Scope == apiextensionsv1.NamespaceScoped && r.isolation == kubebindv1alpha2.IsolationNamespaced { desired.Spec.Scope = apiextensionsv1.ClusterScoped }