modify apinetlet and metalnetlet network controllers for peering status

api/core/v1alpha1/network_types.go

@@ -10,8 +10,16 @@ import (
 type NetworkSpec struct {
 	// ID is the ID of the network.
 	ID string `json:"id,omitempty"`
-	// PeeredIDs are the IDs of networks to peer with.
-	PeeredIDs []string `json:"peeredIDs,omitempty"`
+	// Peerings are the network peerings with this network
+	Peerings []NetworkPeering `json:"peerings,omitempty"`
+}
+
+// NetworkPeering defines a network peering with another network.
+type NetworkPeering struct {
+	// Name is the semantical name of the network peering.
+	Name string `json:"name"`
+	// ID is the ID of the network to peer with.
+	ID string `json:"id"`
 }
 
 type NetworkStatus struct {
@@ -29,14 +37,16 @@ type NetworkPeeringState string
 const (
 	// NetworkPeeringStatePending signals that the network peering is not applied.
 	NetworkPeeringStatePending NetworkPeeringState = "Pending"
-	// NetworkPeeringStateApplied signals that the network peering is applied.
-	NetworkPeeringStateApplied NetworkPeeringState = "Applied"
+	// NetworkPeeringStateReady signals that the network peering is ready.
+	NetworkPeeringStateReady NetworkPeeringState = "Ready"
+	// NetworkPeeringStateError signals that the network peering is in error state.
+	NetworkPeeringStateError NetworkPeeringState = "Error"
 )
 
 // NetworkPeeringStatus is the status of a network peering.
 type NetworkPeeringStatus struct {
-	// Name is the name of the network peering.
-	Name string `json:"name"`
+	// ID is the ID of network
+	ID int32 `json:"id"`
 	// State represents the network peering state
 	State NetworkPeeringState `json:"state,omitempty"`
 }

apinetlet/controllers/conversion.go

@@ -5,6 +5,8 @@ package controllers
 
 import (
 	"fmt"
+	"slices"
+	"strconv"
 
 	apinetv1alpha1 "github.com/ironcore-dev/ironcore-net/api/core/v1alpha1"
 	"github.com/ironcore-dev/ironcore-net/apimachinery/api/net"
@@ -69,3 +71,19 @@ func apiNetNetworkInterfaceStateToNetworkInterfaceState(state apinetv1alpha1.Net
 		return networkingv1alpha1.NetworkInterfaceStatePending
 	}
 }
+
+func apiNetNetworkPeeringsStatusToNetworkPeeringsStatus(peerings []apinetv1alpha1.NetworkPeeringStatus, specPeerings []apinetv1alpha1.NetworkPeering) []networkingv1alpha1.NetworkPeeringStatus {
+	networkPeeringsStatus := []networkingv1alpha1.NetworkPeeringStatus{}
+	for _, peering := range peerings {
+		idx := slices.IndexFunc(specPeerings, func(specPeering apinetv1alpha1.NetworkPeering) bool {
+			return specPeering.ID == strconv.Itoa(int(peering.ID))
+		})
+		if idx != -1 {
+			networkPeeringsStatus = append(networkPeeringsStatus, networkingv1alpha1.NetworkPeeringStatus{
+				Name:  specPeerings[idx].Name,
+				State: networkingv1alpha1.NetworkPeeringState(peering.State),
+			})
+		}
+	}
+	return networkPeeringsStatus
+}

apinetlet/controllers/network_controller.go

@@ -6,6 +6,7 @@ package controllers
 import (
 	"context"
 	"fmt"
+	"slices"
 
 	"github.com/go-logr/logr"
 	"github.com/ironcore-dev/controller-utils/clientutils"
@@ -114,9 +115,10 @@ func (r *NetworkReconciler) delete(ctx context.Context, log logr.Logger, network
 	return ctrl.Result{Requeue: true}, nil
 }
 
-func (r *NetworkReconciler) updateNetworkStatus(ctx context.Context, network *networkingv1alpha1.Network, state networkingv1alpha1.NetworkState) error {
+func (r *NetworkReconciler) updateNetworkStatus(ctx context.Context, network *networkingv1alpha1.Network, apiNetNetwork *apinetv1alpha1.Network, state networkingv1alpha1.NetworkState) error {
 	networkBase := network.DeepCopy()
 	network.Status.State = state
+	network.Status.Peerings = apiNetNetworkPeeringsStatusToNetworkPeeringsStatus(apiNetNetwork.Status.Peerings, apiNetNetwork.Spec.Peerings)
 	if err := r.Status().Patch(ctx, network, client.MergeFrom(networkBase)); err != nil {
 		return fmt.Errorf("unable to patch network: %w", err)
 	}
@@ -139,7 +141,7 @@ func (r *NetworkReconciler) reconcile(ctx context.Context, log logr.Logger, netw
 	apiNetNetwork, err := r.applyAPINetNetwork(ctx, log, network)
 	if err != nil {
 		if network.Status.State != networkingv1alpha1.NetworkStateAvailable {
-			if err := r.updateNetworkStatus(ctx, network, networkingv1alpha1.NetworkStatePending); err != nil {
+			if err := r.updateNetworkStatus(ctx, network, apiNetNetwork, networkingv1alpha1.NetworkStatePending); err != nil {
 				log.Error(err, "Error updating network state")
 			}
 		}
@@ -159,9 +161,10 @@ func (r *NetworkReconciler) reconcile(ctx context.Context, log logr.Logger, netw
 	}
 
 	log.V(1).Info("Updating network status")
-	if err := r.updateNetworkStatus(ctx, network, networkingv1alpha1.NetworkStateAvailable); err != nil {
+	if err := r.updateNetworkStatus(ctx, network, apiNetNetwork, networkingv1alpha1.NetworkStateAvailable); err != nil {
 		return ctrl.Result{}, fmt.Errorf("error updating network status: %w", err)
 	}
+	log.V(1).Info("Updated network status")
 
 	log.V(1).Info("Reconciled")
 	return ctrl.Result{}, nil
@@ -193,26 +196,26 @@ func (r *NetworkReconciler) applyAPINetNetwork(ctx context.Context, log logr.Log
 		},
 	}
 
-	var peeredIDs []string
+	var peerings []apinetv1alpha1.NetworkPeering
 	for _, peeringClaimRef := range network.Spec.PeeringClaimRefs {
 		log.V(1).Info("Get apinet network for target network")
 		targetApinetNetwork := &apinetv1alpha1.Network{}
 		if err := r.APINetClient.Get(ctx, client.ObjectKey{Namespace: r.APINetNamespace, Name: string(peeringClaimRef.UID)}, targetApinetNetwork); err != nil {
 			log.V(1).Info("target apinet network is not created yet")
 			break
 		}
-		peeredIDs = append(peeredIDs, targetApinetNetwork.Spec.ID)
-	}
-	apiNetNetwork.Spec.PeeredIDs = peeredIDs
 
-	var peerings []apinetv1alpha1.NetworkPeeringStatus
-	for _, peering := range network.Status.Peerings {
-		peerings = append(peerings, apinetv1alpha1.NetworkPeeringStatus{
-			Name:  peering.Name,
-			State: apinetv1alpha1.NetworkPeeringStatePending,
+		idx := slices.IndexFunc(network.Spec.Peerings, func(peering networkingv1alpha1.NetworkPeering) bool {
+			return peering.NetworkRef.Name == peeringClaimRef.Name
 		})
+		if idx != -1 {
+			peerings = append(peerings, apinetv1alpha1.NetworkPeering{
+				Name: network.Spec.Peerings[idx].Name,
+				ID:   targetApinetNetwork.Spec.ID,
+			})
+		}
 	}
-	apiNetNetwork.Status.Peerings = peerings
+	apiNetNetwork.Spec.Peerings = peerings
 
 	log.V(1).Info("Applying APINet network")
 	if err := r.APINetClient.Patch(ctx, apiNetNetwork, client.Apply, fieldOwner, client.ForceOwnership); err != nil {

apinetlet/controllers/network_controller_test.go

@@ -4,6 +4,8 @@
 package controllers
 
 import (
+	"strconv"
+
 	apinetv1alpha1 "github.com/ironcore-dev/ironcore-net/api/core/v1alpha1"
 	apinetletclient "github.com/ironcore-dev/ironcore-net/apinetlet/client"
 	"github.com/ironcore-dev/ironcore-net/apinetlet/provider"
@@ -184,13 +186,51 @@ var _ = Describe("NetworkController", func() {
 		}}
 		Expect(k8sClient.Patch(ctx, network2, client.MergeFrom(baseNetwork2))).To(Succeed())
 
-		By("ensuring apinet network peeredIDs are updated")
+		By("ensuring apinet network spec peerings are updated")
 		Eventually(Object(apiNetNetwork1)).Should(SatisfyAll(
-			HaveField("Spec.PeeredIDs", ConsistOf(apiNetNetwork2.Spec.ID)),
+			HaveField("Spec.Peerings", ConsistOf(apinetv1alpha1.NetworkPeering{
+				Name: network1.Spec.Peerings[0].Name,
+				ID:   apiNetNetwork2.Spec.ID,
+			})),
 		))
 
 		Eventually(Object(apiNetNetwork2)).Should(SatisfyAll(
-			HaveField("Spec.PeeredIDs", ConsistOf(apiNetNetwork1.Spec.ID)),
+			HaveField("Spec.Peerings", ConsistOf(apinetv1alpha1.NetworkPeering{
+				Name: network2.Spec.Peerings[0].Name,
+				ID:   apiNetNetwork1.Spec.ID,
+			})),
+		))
+
+		By("patching apinet network peering status")
+		apiNetNetwork2ID, _ := strconv.Atoi(apiNetNetwork2.Spec.ID)
+		Eventually(UpdateStatus(apiNetNetwork1, func() {
+			apiNetNetwork1.Status.Peerings = []apinetv1alpha1.NetworkPeeringStatus{{
+				ID:    int32(apiNetNetwork2ID),
+				State: apinetv1alpha1.NetworkPeeringStateReady,
+			}}
+		})).Should(Succeed())
+
+		apiNetNetwork1ID, _ := strconv.Atoi(apiNetNetwork1.Spec.ID)
+		Eventually(UpdateStatus(apiNetNetwork2, func() {
+			apiNetNetwork2.Status.Peerings = []apinetv1alpha1.NetworkPeeringStatus{{
+				ID:    int32(apiNetNetwork1ID),
+				State: apinetv1alpha1.NetworkPeeringStateReady,
+			}}
+		})).Should(Succeed())
+
+		By("ensuring ironcore networks peering status is updated")
+		Eventually(Object(network1)).Should(SatisfyAll(
+			HaveField("Status.Peerings", ConsistOf(networkingv1alpha1.NetworkPeeringStatus{
+				Name:  network1.Spec.Peerings[0].Name,
+				State: networkingv1alpha1.NetworkPeeringStateReady,
+			})),
+		))
+
+		Eventually(Object(network2)).Should(SatisfyAll(
+			HaveField("Status.Peerings", ConsistOf(networkingv1alpha1.NetworkPeeringStatus{
+				Name:  network2.Spec.Peerings[0].Name,
+				State: networkingv1alpha1.NetworkPeeringStateReady,
+			})),
 		))
 
 		By("deleting the networks")

client-go/openapi/api_violations.report

@@ -16,7 +16,7 @@ API rule violation: list_type_missing,github.com/ironcore-dev/ironcore-net/api/c
 API rule violation: list_type_missing,github.com/ironcore-dev/ironcore-net/api/core/v1alpha1,NetworkInterfaceStatus,NATIPs
 API rule violation: list_type_missing,github.com/ironcore-dev/ironcore-net/api/core/v1alpha1,NetworkInterfaceStatus,Prefixes
 API rule violation: list_type_missing,github.com/ironcore-dev/ironcore-net/api/core/v1alpha1,NetworkInterfaceStatus,PublicIPs
-API rule violation: list_type_missing,github.com/ironcore-dev/ironcore-net/api/core/v1alpha1,NetworkSpec,PeeredIDs
+API rule violation: list_type_missing,github.com/ironcore-dev/ironcore-net/api/core/v1alpha1,NetworkSpec,Peerings
 API rule violation: list_type_missing,github.com/ironcore-dev/ironcore-net/api/core/v1alpha1,NetworkStatus,Peerings
 API rule violation: list_type_missing,github.com/ironcore-dev/ironcore-net/api/core/v1alpha1,NodeSelector,NodeSelectorTerms
 API rule violation: list_type_missing,github.com/ironcore-dev/ironcore-net/api/core/v1alpha1,NodeSelectorRequirement,Values