restore topologicalOrder in status

Author: bschaatsbergen

pkg/controller/resourcegraphdefinition/controller.go

@@ -169,9 +169,9 @@ func (r *ResourceGraphDefinitionReconciler) Reconcile(
 		return ctrl.Result{}, err
 	}
 
-	resourcesInformation, reconcileErr := r.reconcileResourceGraphDefinition(ctx, o)
+	topologicalOrder, resourcesInformation, reconcileErr := r.reconcileResourceGraphDefinition(ctx, o)
 
-	if err := r.updateStatus(ctx, o, resourcesInformation); err != nil {
+	if err := r.updateStatus(ctx, o, topologicalOrder, resourcesInformation); err != nil {
 		reconcileErr = errors.Join(reconcileErr, err)
 	}
 

pkg/controller/resourcegraphdefinition/controller_reconcile.go

@@ -38,7 +38,7 @@ import (
 func (r *ResourceGraphDefinitionReconciler) reconcileResourceGraphDefinition(
 	ctx context.Context,
 	rgd *v1alpha1.ResourceGraphDefinition,
-) ([]v1alpha1.ResourceInformation, error) {
+) ([]string, []v1alpha1.ResourceInformation, error) {
 	log := ctrl.LoggerFrom(ctx)
 	mark := NewConditionsMarkerFor(rgd)
 
@@ -47,15 +47,15 @@ func (r *ResourceGraphDefinitionReconciler) reconcileResourceGraphDefinition(
 	processedRGD, resourcesInfo, err := r.reconcileResourceGraphDefinitionGraph(ctx, rgd)
 	if err != nil {
 		mark.ResourceGraphInvalid(err.Error())
-		return nil, err
+		return nil, nil, err
 	}
 	mark.ResourceGraphValid()
 
 	// Setup metadata labeling
 	graphExecLabeler, err := r.setupLabeler(rgd)
 	if err != nil {
 		mark.FailedLabelerSetup(err.Error())
-		return nil, fmt.Errorf("failed to setup labeler: %w", err)
+		return nil, nil, fmt.Errorf("failed to setup labeler: %w", err)
 	}
 
 	crd := processedRGD.Instance.GetCRD()
@@ -65,7 +65,7 @@ func (r *ResourceGraphDefinitionReconciler) reconcileResourceGraphDefinition(
 	log.V(1).Info("reconciling resource graph definition CRD")
 	if err := r.reconcileResourceGraphDefinitionCRD(ctx, crd); err != nil {
 		mark.KindUnready(err.Error())
-		return resourcesInfo, err
+		return processedRGD.TopologicalOrder, resourcesInfo, err
 	}
 	if crd, err = r.crdManager.Get(ctx, crd.Name); err != nil {
 		mark.KindUnready(err.Error())
@@ -78,11 +78,11 @@ func (r *ResourceGraphDefinitionReconciler) reconcileResourceGraphDefinition(
 	// rather than have it ignore this context and use the background context.
 	if err := r.reconcileResourceGraphDefinitionMicroController(ctx, processedRGD, graphExecLabeler); err != nil {
 		mark.ControllerFailedToStart(err.Error())
-		return resourcesInfo, err
+		return processedRGD.TopologicalOrder, resourcesInfo, err
 	}
 	mark.ControllerRunning()
 
-	return resourcesInfo, nil
+	return processedRGD.TopologicalOrder, resourcesInfo, nil
 }
 
 func (r *ResourceGraphDefinitionReconciler) getResourceGVRsToWatchForRGD(processedRGD *graph.Graph) []schema.GroupVersionResource {

pkg/controller/resourcegraphdefinition/controller_status.go

@@ -34,6 +34,7 @@ import (
 func (r *ResourceGraphDefinitionReconciler) updateStatus(
 	ctx context.Context,
 	o *v1alpha1.ResourceGraphDefinition,
+	topologicalOrder []string,
 	resources []v1alpha1.ResourceInformation,
 ) error {
 	log, _ := logr.FromContext(ctx)
@@ -58,6 +59,7 @@ func (r *ResourceGraphDefinitionReconciler) updateStatus(
 		dc.Status.Conditions = o.Status.Conditions
 		dc.Status.State = o.Status.State
 		dc.Status.Resources = resources
+		dc.Status.TopologicalOrder = topologicalOrder
 
 		log.V(1).Info("updating resource graph definition status",
 			"state", dc.Status.State,

pkg/graph/builder.go

@@ -224,6 +224,20 @@ func (b *Builder) NewResourceGraphDefinition(originalCR *v1alpha1.ResourceGraphD
 		return nil, fmt.Errorf("failed to build dependency graph: %w", err)
 	}
 
+	// Compute the topological levels of the graph and ensure it is acyclic.
+	levels, err := dag.TopologicalSortLevels()
+	if err != nil {
+		return nil, fmt.Errorf("failed to compute topological levels: %w", err)
+	}
+
+	// Flatten the levels into a single topological order slice.
+	// Within each level, sort resources stably to maintain deterministic ordering.
+	var topologicalOrder []string
+	for _, level := range levels {
+		slices.Sort(level)
+		topologicalOrder = append(topologicalOrder, level...)
+	}
+
 	// Now that we know all resources are properly declared and dependencies are valid,
 	// we can perform type checking on the CEL expressions.
 
@@ -250,9 +264,10 @@ func (b *Builder) NewResourceGraphDefinition(originalCR *v1alpha1.ResourceGraphD
 	}
 
 	resourceGraphDefinition := &Graph{
-		DAG:       dag,
-		Instance:  instance,
-		Resources: resources,
+		DAG:              dag,
+		TopologicalOrder: topologicalOrder,
+		Instance:         instance,
+		Resources:        resources,
 	}
 	return resourceGraphDefinition, nil
 }

pkg/graph/graph.go

@@ -31,6 +31,8 @@ type Graph struct {
 	Instance *Resource
 	// Resources is a map of the processed resources in the resource graph definition.
 	Resources map[string]*Resource
+	// TopologicalOrder is the topological order of the resources in the resource graph definition.
+	TopologicalOrder []string
 }
 
 // NewGraphRuntime creates a new runtime resource graph definition from the resource graph definition instance.

test/integration/suites/core/dependency_readiness_test.go

@@ -154,6 +154,8 @@ var _ = Describe("Dependency Readiness", func() {
 
 		// Verify ResourceGraphDefinition is created and becomes ready
 		createdRGD := &krov1alpha1.ResourceGraphDefinition{}
+
+		//nolint:dupl
 		Eventually(func(g Gomega, ctx SpecContext) {
 			err := env.Client.Get(ctx, types.NamespacedName{
 				Name: rgd.Name,

test/integration/suites/core/include_when_test.go

@@ -211,6 +211,8 @@ var _ = Describe("Conditions", func() {
 
 		// Verify ResourceGraphDefinition is created and becomes ready
 		createdRGD := &krov1alpha1.ResourceGraphDefinition{}
+
+		//nolint:dupl
 		Eventually(func(g Gomega, ctx SpecContext) {
 			err := env.Client.Get(ctx, types.NamespacedName{
 				Name: rgd.Name,

test/integration/suites/core/readiness_test.go

@@ -141,6 +141,8 @@ var _ = Describe("Readiness", func() {
 
 		// Verify ResourceGraphDefinition is created and becomes ready
 		createdRGD := &krov1alpha1.ResourceGraphDefinition{}
+
+		//nolint:dupl
 		Eventually(func(g Gomega, ctx SpecContext) {
 			err := env.Client.Get(ctx, types.NamespacedName{
 				Name: rgd.Name,

test/integration/suites/core/unknown_fields_test.go

@@ -1,3 +1,17 @@
+// Copyright 2025 The Kube Resource Orchestrator 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.
+
 package core_test
 
 import (

test/integration/suites/core/validation_test.go

@@ -167,6 +167,7 @@ var _ = Describe("Validation", func() {
 	})
 
 	Context("Kubernetes Object Structure", func() {
+		//nolint:dupl
 		It("should validate correct kubernetes object structure", func(ctx SpecContext) {
 			rgd := generator.NewResourceGraphDefinition("test-k8s-valid",
 				generator.WithSchema(
@@ -318,6 +319,7 @@ var _ = Describe("Validation", func() {
 	})
 
 	Context("Proper Cleanup", func() {
+		//nolint:dupl
 		It("should not panic when deleting an inactive ResourceGraphDefinition", func(ctx SpecContext) {
 			rgd := generator.NewResourceGraphDefinition("test-cleanup",
 				generator.WithSchema(