From 93d9b986694df1b1e7b2db6e47da3906388cca1c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felix=20K=C3=A4stner?= Date: Wed, 14 Oct 2026 11:17:59 +0200 Subject: [PATCH 1/3] Require Fabric VNI pool MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Felix Kästner --- api/evpn/v1alpha1/fabric_types.go | 8 +++----- .../crd/fabrics.evpn.networking.metal.ironcore.dev.yaml | 6 ++++-- .../bases/evpn.networking.metal.ironcore.dev_fabrics.yaml | 6 ++++-- docs/api-reference/index.md | 2 +- 4 files changed, 12 insertions(+), 10 deletions(-) diff --git a/api/evpn/v1alpha1/fabric_types.go b/api/evpn/v1alpha1/fabric_types.go index d0b3236b5..725373563 100644 --- a/api/evpn/v1alpha1/fabric_types.go +++ b/api/evpn/v1alpha1/fabric_types.go @@ -44,11 +44,9 @@ type FabricSpec struct { // vniPool references an IndexPool from which VNIs are allocated for Networks // realized by this Fabric. - // This field is introduced as optional until the NetworkAttachment - // controller is implemented. The field currently has no effect. - // TODO: Make this field required once the NetworkAttachment controller is implemented. - // +optional - VNIPool corev1alpha1.TypedLocalObjectReference `json:"vniPool,omitempty"` + // +required + // +kubebuilder:validation:XValidation:rule="self == oldSelf",message="vniPool is immutable" + VNIPool corev1alpha1.TypedLocalObjectReference `json:"vniPool"` } // FabricLoopbacksSpec configures IP address allocation for loopback interfaces. diff --git a/charts/network-operator/templates/crd/fabrics.evpn.networking.metal.ironcore.dev.yaml b/charts/network-operator/templates/crd/fabrics.evpn.networking.metal.ironcore.dev.yaml index d6b87136a..9bd327b66 100644 --- a/charts/network-operator/templates/crd/fabrics.evpn.networking.metal.ironcore.dev.yaml +++ b/charts/network-operator/templates/crd/fabrics.evpn.networking.metal.ironcore.dev.yaml @@ -563,8 +563,6 @@ spec: description: |- vniPool references an IndexPool from which VNIs are allocated for Networks realized by this Fabric. - This field is introduced as optional until the NetworkAttachment - controller is implemented. The field currently has no effect. properties: apiVersion: description: APIVersion is the api group version of the resource @@ -595,6 +593,9 @@ spec: - name type: object x-kubernetes-map-type: atomic + x-kubernetes-validations: + - message: vniPool is immutable + rule: self == oldSelf vtep: description: vtep identifies the VTEP devices and configures their anycast gateway. @@ -677,6 +678,7 @@ spec: - loopbacks - overlay - underlay + - vniPool - vtep type: object status: diff --git a/config/crd/bases/evpn.networking.metal.ironcore.dev_fabrics.yaml b/config/crd/bases/evpn.networking.metal.ironcore.dev_fabrics.yaml index 4458bc2ae..56584c74e 100644 --- a/config/crd/bases/evpn.networking.metal.ironcore.dev_fabrics.yaml +++ b/config/crd/bases/evpn.networking.metal.ironcore.dev_fabrics.yaml @@ -560,8 +560,6 @@ spec: description: |- vniPool references an IndexPool from which VNIs are allocated for Networks realized by this Fabric. - This field is introduced as optional until the NetworkAttachment - controller is implemented. The field currently has no effect. properties: apiVersion: description: APIVersion is the api group version of the resource @@ -592,6 +590,9 @@ spec: - name type: object x-kubernetes-map-type: atomic + x-kubernetes-validations: + - message: vniPool is immutable + rule: self == oldSelf vtep: description: vtep identifies the VTEP devices and configures their anycast gateway. @@ -674,6 +675,7 @@ spec: - loopbacks - overlay - underlay + - vniPool - vtep type: object status: diff --git a/docs/api-reference/index.md b/docs/api-reference/index.md index 2fd5e6b19..ebc4a21b0 100644 --- a/docs/api-reference/index.md +++ b/docs/api-reference/index.md @@ -196,7 +196,7 @@ _Appears in:_ | `overlay` _[FabricOverlaySpec](#fabricoverlayspec)_ | overlay defines the overlay control-plane configuration for the fabric. | | Required: \{\}
| | `bum` _[FabricBUMSpec](#fabricbumspec)_ | bum defines how BUM traffic is forwarded across the fabric. | | Required: \{\}
| | `vtep` _[FabricVTEPSpec](#fabricvtepspec)_ | vtep identifies the VTEP devices and configures their anycast gateway. | | Required: \{\}
| -| `vniPool` _[TypedLocalObjectReference](#typedlocalobjectreference)_ | vniPool references an IndexPool from which VNIs are allocated for Networks
realized by this Fabric.
This field is introduced as optional until the NetworkAttachment
controller is implemented. The field currently has no effect. | | Optional: \{\}
| +| `vniPool` _[TypedLocalObjectReference](#typedlocalobjectreference)_ | vniPool references an IndexPool from which VNIs are allocated for Networks
realized by this Fabric. | | Required: \{\}
| #### FabricStatus From f1428a5801ca876632bf3d69ba2bb0e2192fe8eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felix=20K=C3=A4stner?= Date: Sun, 1 Nov 2026 16:18:48 +0100 Subject: [PATCH 2/3] Realize NetworkAttachments through EVPN Fabrics MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Resolve selected Physical and Aggregate Exact trunk Interfaces through Devices to a single Fabric and record the typed forwarding context. Reject competing attachments requesting the same Device-local VLAN, including attachments belonging to different Networks. Allocate a shared Network-scoped VNI Claim owned by the Fabric and validate its allocation before creating attachment-owned VLANs and bridged EVPNInstances. Set RD to Auto and explicitly derive import and export route targets per RFC 8365 using two-octet iBGP AS numbers. Retain VNI Claims across attachment and Network deletion until their Fabric is removed. Persist Interface/VLAN ownership in status before device realization. Preserve unrelated allowed VLANs, clean stale memberships and owned resources on selector changes, and remove Interface memberships during finalization. Garbage collection handles attachment-owned children. Add indexed dependency watches, switchport VLAN mutation methods, generated API artifacts, and resource-driven controller tests. Signed-off-by: Felix Kästner --- api/core/v1alpha1/interface_types.go | 82 + api/core/v1alpha1/interface_types_test.go | 193 ++ api/evpn/v1alpha1/groupversion_info.go | 36 + .../v1alpha1/networkattachment_types.go | 29 + api/overlay/v1alpha1/zz_generated.deepcopy.go | 28 + ...overlay.networking.metal.ironcore.dev.yaml | 78 + cmd/main.go | 20 + ...metal.ironcore.dev_networkattachments.yaml | 78 + docs/api-reference/index.md | 21 + internal/controller/evpn/doc.go | 8 + .../controller/evpn/network_controller.go | 394 ++++ .../evpn/network_controller_test.go | 332 ++++ .../evpn/networkattachment_controller.go | 1248 +++++++++++++ .../evpn/networkattachment_controller_test.go | 1602 +++++++++++++++++ internal/controller/evpn/suite_test.go | 48 +- internal/controller/overlay/doc.go | 8 + .../controller/overlay/network_controller.go | 3 +- .../overlay/network_controller_test.go | 10 - .../overlay/networkattachment_controller.go | 3 +- .../networkattachment_controller_test.go | 9 - 20 files changed, 4205 insertions(+), 25 deletions(-) create mode 100644 api/core/v1alpha1/interface_types_test.go create mode 100644 internal/controller/evpn/doc.go create mode 100644 internal/controller/evpn/network_controller.go create mode 100644 internal/controller/evpn/network_controller_test.go create mode 100644 internal/controller/evpn/networkattachment_controller.go create mode 100644 internal/controller/evpn/networkattachment_controller_test.go create mode 100644 internal/controller/overlay/doc.go diff --git a/api/core/v1alpha1/interface_types.go b/api/core/v1alpha1/interface_types.go index a529fadc7..7be18082f 100644 --- a/api/core/v1alpha1/interface_types.go +++ b/api/core/v1alpha1/interface_types.go @@ -4,6 +4,8 @@ package v1alpha1 import ( + "fmt" + "sort" "sync" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -236,6 +238,86 @@ type Encapsulation struct { OuterTag int32 `json:"outerTag,omitempty"` } +// AddAllowedVLAN adds a VLAN to the explicit allowed VLAN list. +// It reports whether the list changed. +func (s *Switchport) AddAllowedVLAN(vlan int32) (bool, error) { + if err := s.ValidateAllowedVLAN(vlan); err != nil { + return false, err + } + value := int64(vlan) + // An existing range already allows the VLAN, so no mutation is needed. + for _, vlanRange := range s.AllowedVlans { + if vlanRange.Start <= value && value <= vlanRange.End { + return false, nil + } + } + // Appending a singleton makes an implicit all-VLAN list explicit and takes ownership of it. + s.AllowedVlans = append(s.AllowedVlans, IndexRange{Start: value, End: value}) + s.SortAllowedVLANs() + return true, nil +} + +// RemoveAllowedVLAN removes a VLAN from the explicit allowed VLAN list. +// It reports whether the list changed. +func (s *Switchport) RemoveAllowedVLAN(vlan int32) (bool, error) { + if err := s.ValidateAllowedVLAN(vlan); err != nil { + return false, err + } + value := int64(vlan) + // Find the single range containing the VLAN and remove only that value from it. + for i, vlanRange := range s.AllowedVlans { + if value < vlanRange.Start || value > vlanRange.End { + continue + } + switch { + // Remove the whole singleton range. + case vlanRange.Start == value && vlanRange.End == value: + s.AllowedVlans = append(s.AllowedVlans[:i], s.AllowedVlans[i+1:]...) + // Shrink the range past its first VLAN. + case vlanRange.Start == value: + s.AllowedVlans[i].Start++ + // Shrink the range before its last VLAN. + case vlanRange.End == value: + s.AllowedVlans[i].End-- + // Split the range around an interior VLAN. + default: + s.AllowedVlans[i].End = value - 1 + s.AllowedVlans = append(s.AllowedVlans, IndexRange{Start: value + 1, End: vlanRange.End}) + s.SortAllowedVLANs() + } + if len(s.AllowedVlans) == 0 { + // nil restores the API default after the final explicit VLAN is removed. + s.AllowedVlans = nil + } + return true, nil + } + return false, nil +} + +// SortAllowedVLANs orders the explicit allowed VLAN ranges by start and then end in-place. +func (s *Switchport) SortAllowedVLANs() { + sort.Slice(s.AllowedVlans, func(i, j int) bool { + if s.AllowedVlans[i].Start != s.AllowedVlans[j].Start { + return s.AllowedVlans[i].Start < s.AllowedVlans[j].Start + } + return s.AllowedVlans[i].End < s.AllowedVlans[j].End + }) +} + +// ValidateAllowedVLAN validates that the switchport permits changing the given VLAN. +func (s *Switchport) ValidateAllowedVLAN(vlan int32) error { + if s.Mode != SwitchportModeTrunk { + return fmt.Errorf("switchport mode %q does not support allowed VLANs", s.Mode) + } + if s.AllowedVlansMode == AllowedVlansModeUnmanaged { + return fmt.Errorf("allowed VLAN mode %q does not permit changes", s.AllowedVlansMode) + } + if vlan < 1 || vlan > 4094 { + return fmt.Errorf("VLAN %d is outside the valid range 1..4094", vlan) + } + return nil +} + // AllowedVlansMode defines how trunk allowed VLANs are managed. // +kubebuilder:validation:Enum=Exact;Unmanaged type AllowedVlansMode string diff --git a/api/core/v1alpha1/interface_types_test.go b/api/core/v1alpha1/interface_types_test.go new file mode 100644 index 000000000..d03acc8ef --- /dev/null +++ b/api/core/v1alpha1/interface_types_test.go @@ -0,0 +1,193 @@ +// SPDX-FileCopyrightText: SAP SE or an SAP affiliate company and IronCore contributors +// SPDX-License-Identifier: Apache-2.0 + +package v1alpha1 + +import ( + "reflect" + "testing" +) + +func TestSwitchportAddAllowedVLAN(t *testing.T) { + tests := []struct { + name string + switchport Switchport + vlan int32 + want []IndexRange + changed bool + wantErr bool + }{ + { + name: "takes ownership of nil list", + switchport: Switchport{Mode: SwitchportModeTrunk}, + vlan: 100, + want: []IndexRange{{Start: 100, End: 100}}, + changed: true, + }, + { + name: "keeps containing range", + switchport: Switchport{ + Mode: SwitchportModeTrunk, + AllowedVlans: []IndexRange{{Start: 90, End: 110}}, + }, + vlan: 100, + want: []IndexRange{{Start: 90, End: 110}}, + }, + { + name: "adds sorted singleton", + switchport: Switchport{ + Mode: SwitchportModeTrunk, + AllowedVlans: []IndexRange{{Start: 200, End: 210}}, + }, + vlan: 100, + want: []IndexRange{{Start: 100, End: 100}, {Start: 200, End: 210}}, + changed: true, + }, + { + name: "rejects access mode", + switchport: Switchport{Mode: SwitchportModeAccess}, + vlan: 100, + wantErr: true, + }, + { + name: "rejects unmanaged mode", + switchport: Switchport{ + Mode: SwitchportModeTrunk, + AllowedVlansMode: AllowedVlansModeUnmanaged, + }, + vlan: 100, + wantErr: true, + }, + { + name: "rejects invalid VLAN", + switchport: Switchport{Mode: SwitchportModeTrunk}, + vlan: 4095, + wantErr: true, + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + switchport := test.switchport + changed, err := switchport.AddAllowedVLAN(test.vlan) + if test.wantErr { + if err == nil { + t.Fatalf("AddAllowedVLAN(%d) returned no error", test.vlan) + } + return + } + if err != nil { + t.Fatalf("AddAllowedVLAN(%d): %v", test.vlan, err) + } + if changed != test.changed { + t.Fatalf("AddAllowedVLAN(%d) changed = %t, want %t", test.vlan, changed, test.changed) + } + if !reflect.DeepEqual(switchport.AllowedVlans, test.want) { + t.Fatalf("AddAllowedVLAN(%d) ranges = %#v, want %#v", test.vlan, switchport.AllowedVlans, test.want) + } + }) + } +} + +func TestSwitchportRemoveAllowedVLAN(t *testing.T) { + tests := []struct { + name string + switchport Switchport + vlan int32 + want []IndexRange + changed bool + wantErr bool + }{ + { + name: "keeps absent VLAN", + switchport: Switchport{ + Mode: SwitchportModeTrunk, + AllowedVlans: []IndexRange{{Start: 10, End: 20}}, + }, + vlan: 100, + want: []IndexRange{{Start: 10, End: 20}}, + }, + { + name: "removes final VLAN", + switchport: Switchport{ + Mode: SwitchportModeTrunk, + AllowedVlans: []IndexRange{{Start: 100, End: 100}}, + }, + vlan: 100, + changed: true, + }, + { + name: "shrinks range start", + switchport: Switchport{ + Mode: SwitchportModeTrunk, + AllowedVlans: []IndexRange{{Start: 100, End: 110}}, + }, + vlan: 100, + want: []IndexRange{{Start: 101, End: 110}}, + changed: true, + }, + { + name: "shrinks range end", + switchport: Switchport{ + Mode: SwitchportModeTrunk, + AllowedVlans: []IndexRange{{Start: 100, End: 110}}, + }, + vlan: 110, + want: []IndexRange{{Start: 100, End: 109}}, + changed: true, + }, + { + name: "splits range", + switchport: Switchport{ + Mode: SwitchportModeTrunk, + AllowedVlans: []IndexRange{{Start: 100, End: 110}}, + }, + vlan: 105, + want: []IndexRange{{Start: 100, End: 104}, {Start: 106, End: 110}}, + changed: true, + }, + { + name: "rejects access mode", + switchport: Switchport{Mode: SwitchportModeAccess}, + vlan: 100, + wantErr: true, + }, + { + name: "rejects unmanaged mode", + switchport: Switchport{ + Mode: SwitchportModeTrunk, + AllowedVlansMode: AllowedVlansModeUnmanaged, + }, + vlan: 100, + wantErr: true, + }, + { + name: "rejects invalid VLAN", + switchport: Switchport{Mode: SwitchportModeTrunk}, + vlan: 0, + wantErr: true, + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + switchport := test.switchport + changed, err := switchport.RemoveAllowedVLAN(test.vlan) + if test.wantErr { + if err == nil { + t.Fatalf("RemoveAllowedVLAN(%d) returned no error", test.vlan) + } + return + } + if err != nil { + t.Fatalf("RemoveAllowedVLAN(%d): %v", test.vlan, err) + } + if changed != test.changed { + t.Fatalf("RemoveAllowedVLAN(%d) changed = %t, want %t", test.vlan, changed, test.changed) + } + if !reflect.DeepEqual(switchport.AllowedVlans, test.want) { + t.Fatalf("RemoveAllowedVLAN(%d) ranges = %#v, want %#v", test.vlan, switchport.AllowedVlans, test.want) + } + }) + } +} diff --git a/api/evpn/v1alpha1/groupversion_info.go b/api/evpn/v1alpha1/groupversion_info.go index 2a81c1180..f8cf26cac 100644 --- a/api/evpn/v1alpha1/groupversion_info.go +++ b/api/evpn/v1alpha1/groupversion_info.go @@ -30,6 +30,12 @@ const ( // FabricLabel is applied to all sub-resources created by a Fabric controller, // with the value set to the owning Fabric's name. FabricLabel = "evpn.networking.metal.ironcore.dev/fabric" + + // NetworkLabel identifies the Network associated with an EVPN resource. + NetworkLabel = "evpn.networking.metal.ironcore.dev/network" + + // NetworkAttachmentLabel identifies the NetworkAttachment that realizes an EVPN resource. + NetworkAttachmentLabel = "evpn.networking.metal.ironcore.dev/network-attachment" ) // Fabric condition types. @@ -51,4 +57,34 @@ const ( // NoResourcesReason indicates no child resources exist yet for this condition. NoResourcesReason = "NoResources" + + // NoMatchingInterfacesReason indicates that an Interface selector matched no Interfaces. + NoMatchingInterfacesReason = "NoMatchingInterfaces" + + // InvalidInterfaceReason indicates that a selected Interface cannot realize the attachment. + InvalidInterfaceReason = "InvalidInterface" + + // DeviceResolutionFailedReason indicates that selected Interfaces reference unresolved Devices. + DeviceResolutionFailedReason = "DeviceResolutionFailed" + + // FabricResolutionFailedReason indicates that selected Devices do not resolve to exactly one Fabric. + FabricResolutionFailedReason = "FabricResolutionFailed" + + // EncapsulationConflictReason indicates that attachments request the same encapsulation on a Device. + EncapsulationConflictReason = "EncapsulationConflict" + + // NetworkNotFoundReason indicates that the referenced Network does not exist. + NetworkNotFoundReason = "NetworkNotFound" + + // InvalidVNIReason indicates that an allocated VNI is invalid. + InvalidVNIReason = "InvalidVNI" + + // UnsupportedASNumberReason indicates that the Fabric AS number cannot be used for route-target derivation. + UnsupportedASNumberReason = "UnsupportedASNumber" + + // ResourceConflictReason indicates that an existing resource prevents attachment realization. + ResourceConflictReason = "ResourceConflict" + + // StretchedNetworkNotSupportedReason indicates that a Network resolves to multiple Fabrics. + StretchedNetworkNotSupportedReason = "StretchedNetworkNotSupported" ) diff --git a/api/overlay/v1alpha1/networkattachment_types.go b/api/overlay/v1alpha1/networkattachment_types.go index 2a57d1bc0..a90cdfec1 100644 --- a/api/overlay/v1alpha1/networkattachment_types.go +++ b/api/overlay/v1alpha1/networkattachment_types.go @@ -4,6 +4,8 @@ package v1alpha1 import ( + "fmt" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" @@ -26,6 +28,7 @@ type NetworkAttachmentSpec struct { // Encapsulation defines the encapsulation parameters for this attachment. // +required + // +kubebuilder:validation:XValidation:rule="self == oldSelf",message="encapsulation is immutable" Encapsulation Encapsulation `json:"encapsulation"` } @@ -51,6 +54,11 @@ type Encapsulation struct { ID int32 `json:"id"` } +// Key returns the stable identity of the encapsulation. +func (e Encapsulation) Key() string { + return fmt.Sprintf("%s/%d", e.Type, e.ID) +} + // NetworkAttachmentStatus defines the observed state of NetworkAttachment. type NetworkAttachmentStatus struct { // For Kubernetes API conventions, see: @@ -65,6 +73,27 @@ type NetworkAttachmentStatus struct { // +patchMergeKey=type // +optional Conditions []metav1.Condition `json:"conditions,omitempty"` + + // forwardingContextRef references the forwarding context realizing this attachment. + // +optional + ForwardingContextRef *corev1alpha1.TypedLocalObjectReference `json:"forwardingContextRef,omitempty"` + + // interfaces records Interface/VLAN memberships owned by this attachment. + // Entries may represent memberships being provisioned or cleaned up. + // +optional + // +listType=atomic + Interfaces []NetworkAttachmentInterfaceStatus `json:"interfaces,omitempty"` +} + +// NetworkAttachmentInterfaceStatus records realized VLAN membership on an Interface. +type NetworkAttachmentInterfaceStatus struct { + // deviceRef references the Device that owns the Interface. + // +required + DeviceRef corev1alpha1.LocalObjectReference `json:"deviceRef"` + + // interfaceRef references the realized Interface. + // +required + InterfaceRef corev1alpha1.LocalObjectReference `json:"interfaceRef"` } // +kubebuilder:object:root=true diff --git a/api/overlay/v1alpha1/zz_generated.deepcopy.go b/api/overlay/v1alpha1/zz_generated.deepcopy.go index 58b88a3fa..838d0812b 100644 --- a/api/overlay/v1alpha1/zz_generated.deepcopy.go +++ b/api/overlay/v1alpha1/zz_generated.deepcopy.go @@ -8,6 +8,7 @@ package v1alpha1 import ( + corev1alpha1 "github.com/ironcore-dev/network-operator/api/core/v1alpha1" "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" ) @@ -81,6 +82,23 @@ func (in *NetworkAttachment) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *NetworkAttachmentInterfaceStatus) DeepCopyInto(out *NetworkAttachmentInterfaceStatus) { + *out = *in + out.DeviceRef = in.DeviceRef + out.InterfaceRef = in.InterfaceRef +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkAttachmentInterfaceStatus. +func (in *NetworkAttachmentInterfaceStatus) DeepCopy() *NetworkAttachmentInterfaceStatus { + if in == nil { + return nil + } + out := new(NetworkAttachmentInterfaceStatus) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *NetworkAttachmentList) DeepCopyInto(out *NetworkAttachmentList) { *out = *in @@ -141,6 +159,16 @@ func (in *NetworkAttachmentStatus) DeepCopyInto(out *NetworkAttachmentStatus) { (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.ForwardingContextRef != nil { + in, out := &in.ForwardingContextRef, &out.ForwardingContextRef + *out = new(corev1alpha1.TypedLocalObjectReference) + **out = **in + } + if in.Interfaces != nil { + in, out := &in.Interfaces, &out.Interfaces + *out = make([]NetworkAttachmentInterfaceStatus, len(*in)) + copy(*out, *in) + } } // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkAttachmentStatus. diff --git a/charts/network-operator/templates/crd/networkattachments.overlay.networking.metal.ironcore.dev.yaml b/charts/network-operator/templates/crd/networkattachments.overlay.networking.metal.ironcore.dev.yaml index 487a27f63..423bbcdf9 100644 --- a/charts/network-operator/templates/crd/networkattachments.overlay.networking.metal.ironcore.dev.yaml +++ b/charts/network-operator/templates/crd/networkattachments.overlay.networking.metal.ironcore.dev.yaml @@ -80,6 +80,9 @@ spec: - id - type type: object + x-kubernetes-validations: + - message: encapsulation is immutable + rule: self == oldSelf interfaceSelector: description: |- InterfaceSelector selects Interface resources to attach to the network. @@ -222,6 +225,81 @@ spec: x-kubernetes-list-map-keys: - type x-kubernetes-list-type: map + forwardingContextRef: + description: forwardingContextRef references the forwarding context + realizing this attachment. + properties: + apiVersion: + description: APIVersion is the api group version of the resource + being referenced. + maxLength: 253 + minLength: 1 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/)?([a-z0-9]([-a-z0-9]*[a-z0-9])?)$ + type: string + kind: + description: |- + Kind of the resource being referenced. + Kind must consist of alphanumeric characters or '-', start with an alphabetic character, and end with an alphanumeric character. + maxLength: 63 + minLength: 1 + pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$ + type: string + name: + description: |- + Name of the resource being referenced. + Name must consist of lower case alphanumeric characters, '-' or '.', and must start and end with an alphanumeric character. + maxLength: 253 + minLength: 1 + pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$ + type: string + required: + - apiVersion + - kind + - name + type: object + x-kubernetes-map-type: atomic + interfaces: + description: |- + interfaces records Interface/VLAN memberships owned by this attachment. + Entries may represent memberships being provisioned or cleaned up. + items: + description: NetworkAttachmentInterfaceStatus records realized VLAN + membership on an Interface. + properties: + deviceRef: + description: deviceRef references the Device that owns the Interface. + properties: + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + maxLength: 63 + minLength: 1 + type: string + required: + - name + type: object + x-kubernetes-map-type: atomic + interfaceRef: + description: interfaceRef references the realized Interface. + properties: + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + maxLength: 63 + minLength: 1 + type: string + required: + - name + type: object + x-kubernetes-map-type: atomic + required: + - deviceRef + - interfaceRef + type: object + type: array + x-kubernetes-list-type: atomic type: object required: - spec diff --git a/cmd/main.go b/cmd/main.go index d8c09bcf1..8f87957be 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -847,6 +847,26 @@ func main() { //nolint:gocyclo os.Exit(1) } + if err := (&evpncontroller.NetworkReconciler{ + Client: mgr.GetClient(), + Scheme: mgr.GetScheme(), + Recorder: mgr.GetEventRecorder("evpn-network-controller"), + WatchFilterValue: watchFilterValue, + }).SetupWithManager(ctx, mgr); err != nil { + setupLog.Error(err, "Failed to create controller", "controller", "EVPNNetwork") + os.Exit(1) + } + + if err := (&evpncontroller.NetworkAttachmentReconciler{ + Client: mgr.GetClient(), + Scheme: mgr.GetScheme(), + Recorder: mgr.GetEventRecorder("evpn-networkattachment-controller"), + WatchFilterValue: watchFilterValue, + }).SetupWithManager(ctx, mgr); err != nil { + setupLog.Error(err, "Failed to create controller", "controller", "EVPNNetworkAttachment") + os.Exit(1) + } + if err := (&corecontroller.ProbeReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), diff --git a/config/crd/bases/overlay.networking.metal.ironcore.dev_networkattachments.yaml b/config/crd/bases/overlay.networking.metal.ironcore.dev_networkattachments.yaml index 903e3b4db..48d650fa3 100644 --- a/config/crd/bases/overlay.networking.metal.ironcore.dev_networkattachments.yaml +++ b/config/crd/bases/overlay.networking.metal.ironcore.dev_networkattachments.yaml @@ -77,6 +77,9 @@ spec: - id - type type: object + x-kubernetes-validations: + - message: encapsulation is immutable + rule: self == oldSelf interfaceSelector: description: |- InterfaceSelector selects Interface resources to attach to the network. @@ -219,6 +222,81 @@ spec: x-kubernetes-list-map-keys: - type x-kubernetes-list-type: map + forwardingContextRef: + description: forwardingContextRef references the forwarding context + realizing this attachment. + properties: + apiVersion: + description: APIVersion is the api group version of the resource + being referenced. + maxLength: 253 + minLength: 1 + pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/)?([a-z0-9]([-a-z0-9]*[a-z0-9])?)$ + type: string + kind: + description: |- + Kind of the resource being referenced. + Kind must consist of alphanumeric characters or '-', start with an alphabetic character, and end with an alphanumeric character. + maxLength: 63 + minLength: 1 + pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$ + type: string + name: + description: |- + Name of the resource being referenced. + Name must consist of lower case alphanumeric characters, '-' or '.', and must start and end with an alphanumeric character. + maxLength: 253 + minLength: 1 + pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$ + type: string + required: + - apiVersion + - kind + - name + type: object + x-kubernetes-map-type: atomic + interfaces: + description: |- + interfaces records Interface/VLAN memberships owned by this attachment. + Entries may represent memberships being provisioned or cleaned up. + items: + description: NetworkAttachmentInterfaceStatus records realized VLAN + membership on an Interface. + properties: + deviceRef: + description: deviceRef references the Device that owns the Interface. + properties: + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + maxLength: 63 + minLength: 1 + type: string + required: + - name + type: object + x-kubernetes-map-type: atomic + interfaceRef: + description: interfaceRef references the realized Interface. + properties: + name: + description: |- + Name of the referent. + More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names + maxLength: 63 + minLength: 1 + type: string + required: + - name + type: object + x-kubernetes-map-type: atomic + required: + - deviceRef + - interfaceRef + type: object + type: array + x-kubernetes-list-type: atomic type: object required: - spec diff --git a/docs/api-reference/index.md b/docs/api-reference/index.md index ebc4a21b0..7a2f47cf3 100644 --- a/docs/api-reference/index.md +++ b/docs/api-reference/index.md @@ -3079,6 +3079,7 @@ _Appears in:_ - [MacSecSpec](#macsecspec) - [ManagementAccessSpec](#managementaccessspec) - [NTPSpec](#ntpspec) +- [NetworkAttachmentInterfaceStatus](#networkattachmentinterfacestatus) - [NetworkAttachmentSpec](#networkattachmentspec) - [NetworkVirtualizationEdgeSpec](#networkvirtualizationedgespec) - [NextHop](#nexthop) @@ -4913,6 +4914,7 @@ _Appears in:_ - [MacSecSpec](#macsecspec) - [ManagementAccessSpec](#managementaccessspec) - [NTPSpec](#ntpspec) +- [NetworkAttachmentStatus](#networkattachmentstatus) - [NetworkVirtualizationEdgeSpec](#networkvirtualizationedgespec) - [OSPFSpec](#ospfspec) - [PIMSpec](#pimspec) @@ -6348,6 +6350,23 @@ NetworkAttachment is the Schema for the networkattachments API | `status` _[NetworkAttachmentStatus](#networkattachmentstatus)_ | Status of the resource. This is set and updated automatically.
Read-only.
More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status | | Optional: \{\}
| +#### NetworkAttachmentInterfaceStatus + + + +NetworkAttachmentInterfaceStatus records realized VLAN membership on an Interface. + + + +_Appears in:_ +- [NetworkAttachmentStatus](#networkattachmentstatus) + +| Field | Description | Default | Validation | +| --- | --- | --- | --- | +| `deviceRef` _[LocalObjectReference](#localobjectreference)_ | deviceRef references the Device that owns the Interface. | | Required: \{\}
| +| `interfaceRef` _[LocalObjectReference](#localobjectreference)_ | interfaceRef references the realized Interface. | | Required: \{\}
| + + #### NetworkAttachmentSpec @@ -6380,6 +6399,8 @@ _Appears in:_ | Field | Description | Default | Validation | | --- | --- | --- | --- | | `conditions` _[Condition](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.35/#condition-v1-meta) array_ | conditions represent the current state of the NetworkAttachment resource.
Each condition has a unique type and reflects the status of a specific aspect of the resource.
The status of each condition is one of True, False, or Unknown. | | Optional: \{\}
| +| `forwardingContextRef` _[TypedLocalObjectReference](#typedlocalobjectreference)_ | forwardingContextRef references the forwarding context realizing this attachment. | | Optional: \{\}
| +| `interfaces` _[NetworkAttachmentInterfaceStatus](#networkattachmentinterfacestatus) array_ | interfaces records Interface/VLAN memberships owned by this attachment.
Entries may represent memberships being provisioned or cleaned up. | | Optional: \{\}
| #### NetworkSpec diff --git a/internal/controller/evpn/doc.go b/internal/controller/evpn/doc.go new file mode 100644 index 000000000..47fc3e894 --- /dev/null +++ b/internal/controller/evpn/doc.go @@ -0,0 +1,8 @@ +// SPDX-FileCopyrightText: SAP SE or an SAP affiliate company and IronCore contributors +// SPDX-License-Identifier: Apache-2.0 + +// Package evpn contains controllers for the evpn.networking.metal.ironcore.dev API group +// and the EVPN realization of overlay Networks and NetworkAttachments. +// It reconciles Fabric underlay and overlay configuration, allocates Network VNIs, +// and realizes attachments as VLANs, EVPNInstances, and Interface VLAN memberships. +package evpn diff --git a/internal/controller/evpn/network_controller.go b/internal/controller/evpn/network_controller.go new file mode 100644 index 000000000..d418f041a --- /dev/null +++ b/internal/controller/evpn/network_controller.go @@ -0,0 +1,394 @@ +// SPDX-FileCopyrightText: SAP SE or an SAP affiliate company and IronCore contributors +// SPDX-License-Identifier: Apache-2.0 + +package evpn + +import ( + "context" + "fmt" + + "k8s.io/apimachinery/pkg/api/equality" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + kerrors "k8s.io/apimachinery/pkg/util/errors" + "k8s.io/client-go/tools/events" + "k8s.io/klog/v2" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/builder" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" + "sigs.k8s.io/controller-runtime/pkg/event" + "sigs.k8s.io/controller-runtime/pkg/handler" + "sigs.k8s.io/controller-runtime/pkg/predicate" + + "github.com/ironcore-dev/network-operator/api/core/v1alpha1" + evpnv1alpha1 "github.com/ironcore-dev/network-operator/api/evpn/v1alpha1" + overlayv1alpha1 "github.com/ironcore-dev/network-operator/api/overlay/v1alpha1" + poolv1alpha1 "github.com/ironcore-dev/network-operator/api/pool/v1alpha1" + "github.com/ironcore-dev/network-operator/internal/conditions" +) + +// NetworkReconciler reconciles a Network object. +type NetworkReconciler struct { + client.Client + Scheme *runtime.Scheme + + // WatchFilterValue is the label value used to filter events prior to reconciliation. + WatchFilterValue string + + // Recorder is used to record events for the controller. + // More info: https://book.kubebuilder.io/reference/raising-events + Recorder events.EventRecorder +} + +// +kubebuilder:rbac:groups=overlay.networking.metal.ironcore.dev,resources=networks,verbs=get;list;watch;create;update;patch;delete +// +kubebuilder:rbac:groups=overlay.networking.metal.ironcore.dev,resources=networks/status,verbs=get;update;patch +// +kubebuilder:rbac:groups=overlay.networking.metal.ironcore.dev,resources=networks/finalizers,verbs=update +// +kubebuilder:rbac:groups=overlay.networking.metal.ironcore.dev,resources=networkattachments,verbs=get;list;watch +// +kubebuilder:rbac:groups=evpn.networking.metal.ironcore.dev,resources=fabrics,verbs=get;list;watch +// +kubebuilder:rbac:groups=pool.networking.metal.ironcore.dev,resources=claims,verbs=get;list;watch;create;update;patch;delete +// +kubebuilder:rbac:groups=networking.metal.ironcore.dev,resources=evpninstances,verbs=get;list;watch +// +kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=create;patch + +// Reconcile is part of the main kubernetes reconciliation loop which aims to +// move the current state of the cluster closer to the desired state. +// +// For more details, check Reconcile and its Result here: +// - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.24.1/pkg/reconcile +func (r *NetworkReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, reterr error) { + log := ctrl.LoggerFrom(ctx) + log.Info("Reconciling resource") + + net := new(overlayv1alpha1.Network) + if err := r.Get(ctx, req.NamespacedName, net); err != nil { + if apierrors.IsNotFound(err) { + log.Info("Resource not found. Ignoring since object must be deleted") + return ctrl.Result{}, nil + } + log.Error(err, "Failed to get resource") + return ctrl.Result{}, err + } + + if !net.DeletionTimestamp.IsZero() { + if controllerutil.ContainsFinalizer(net, evpnv1alpha1.FinalizerName) { + complete, err := r.finalize(ctx, net) + if err != nil { + log.Error(err, "Failed to finalize resource") + return ctrl.Result{}, err + } + if !complete { + return ctrl.Result{}, nil + } + controllerutil.RemoveFinalizer(net, evpnv1alpha1.FinalizerName) + if err := r.Update(ctx, net); err != nil { + log.Error(err, "Failed to remove finalizer from resource") + return ctrl.Result{}, err + } + } + log.Info("Resource is being deleted, skipping reconciliation") + return ctrl.Result{}, nil + } + + // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/finalizers + if !controllerutil.ContainsFinalizer(net, evpnv1alpha1.FinalizerName) { + controllerutil.AddFinalizer(net, evpnv1alpha1.FinalizerName) + if err := r.Update(ctx, net); err != nil { + return ctrl.Result{}, fmt.Errorf("add Network finalizer: %w", err) + } + log.Info("Added finalizer to resource") + return ctrl.Result{}, nil + } + + orig := net.DeepCopy() + if conditions.InitializeConditions(net, v1alpha1.ReadyCondition) { + log.V(1).Info("Initializing status conditions") + return ctrl.Result{}, r.Status().Update(ctx, net) + } + + defer func() { + if !equality.Semantic.DeepEqual(orig.Status, net.Status) { + // Pass obj.DeepCopy() to avoid Patch() modifying obj and interfering with metadata update below + if err := r.Status().Patch(ctx, net.DeepCopy(), client.MergeFrom(orig)); err != nil { + log.Error(err, "Failed to update status") + reterr = kerrors.NewAggregate([]error{reterr, err}) + } + } + if !equality.Semantic.DeepEqual(orig.ObjectMeta, net.ObjectMeta) { + if err := r.Patch(ctx, net, client.MergeFrom(orig)); err != nil { + log.Error(err, "Failed to update resource metadata") + reterr = kerrors.NewAggregate([]error{reterr, err}) + } + } + }() + + if err := r.reconcile(ctx, net); err != nil { + log.Error(err, "Failed to reconcile resource") + return ctrl.Result{}, err + } + + return ctrl.Result{}, nil +} + +// SetupWithManager sets up the controller with the Manager. +func (r *NetworkReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager) error { + labelSelector := metav1.LabelSelector{} + if r.WatchFilterValue != "" { + labelSelector.MatchLabels = map[string]string{v1alpha1.WatchLabel: r.WatchFilterValue} + } + + filter, err := predicate.LabelSelectorPredicate(labelSelector) + if err != nil { + return fmt.Errorf("create label selector predicate: %w", err) + } + + return ctrl.NewControllerManagedBy(mgr). + For(&overlayv1alpha1.Network{}). + Named("evpn-network"). + WithEventFilter(filter). + // Watches enqueues Networks when attachments resolve their forwarding context or start deletion. + Watches( + &overlayv1alpha1.NetworkAttachment{}, + handler.EnqueueRequestsFromMapFunc(r.networkAttachmentToNetworks), + builder.WithPredicates(predicate.Funcs{ + UpdateFunc: func(e event.UpdateEvent) bool { + oldNA := e.ObjectOld.(*overlayv1alpha1.NetworkAttachment) + newNA := e.ObjectNew.(*overlayv1alpha1.NetworkAttachment) + return !equality.Semantic.DeepEqual(oldNA.Status.ForwardingContextRef, newNA.Status.ForwardingContextRef) || + !equality.Semantic.DeepEqual(oldNA.DeletionTimestamp, newNA.DeletionTimestamp) || + !equality.Semantic.DeepEqual(oldNA.Status.Interfaces, newNA.Status.Interfaces) + }, + GenericFunc: func(event.GenericEvent) bool { + return false + }, + }), + ). + // Claims are Fabric-owned, so map their allocation and deletion changes to the Network explicitly. + Watches( + &poolv1alpha1.Claim{}, + handler.EnqueueRequestsFromMapFunc(r.claimToNetworks), + builder.WithPredicates(predicate.Funcs{ + UpdateFunc: func(e event.UpdateEvent) bool { + oldClaim := e.ObjectOld.(*poolv1alpha1.Claim) + newClaim := e.ObjectNew.(*poolv1alpha1.Claim) + return !equality.Semantic.DeepEqual(oldClaim.Status, newClaim.Status) || + !equality.Semantic.DeepEqual(oldClaim.DeletionTimestamp, newClaim.DeletionTimestamp) + }, + GenericFunc: func(event.GenericEvent) bool { + return false + }, + }), + ). + // Watches enqueues Networks as their EVPNInstances finish cleanup. + Watches( + &v1alpha1.EVPNInstance{}, + handler.EnqueueRequestsFromMapFunc(r.evpnInstanceToNetworks), + builder.WithPredicates(predicate.Funcs{ + UpdateFunc: func(e event.UpdateEvent) bool { + return !equality.Semantic.DeepEqual(e.ObjectOld.GetDeletionTimestamp(), e.ObjectNew.GetDeletionTimestamp()) + }, + GenericFunc: func(event.GenericEvent) bool { return false }, + }), + ). + Complete(r) +} + +func (r *NetworkReconciler) reconcile(ctx context.Context, net *overlayv1alpha1.Network) error { + // Network realization currently supports only EVPN; revisit dispatch when another forwarding mechanism is added. + attachments := &overlayv1alpha1.NetworkAttachmentList{} + if err := r.List(ctx, attachments, client.InNamespace(net.Namespace), client.MatchingFields{networkAttachmentNetworkRefKey: net.Name}); err != nil { + return fmt.Errorf("list network attachments for network %q: %w", net.Name, err) + } + + var forwardingContextRef *v1alpha1.TypedLocalObjectReference + for i := range attachments.Items { + na := &attachments.Items[i] + if !na.DeletionTimestamp.IsZero() { + continue + } + ref := na.Status.ForwardingContextRef + if ref == nil { + continue + } + if forwardingContextRef != nil && *forwardingContextRef != *ref { + conditions.Set(net, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.StretchedNetworkNotSupportedReason, + Message: "NetworkAttachments resolve to different forwarding contexts", + }) + return nil + } + forwardingContextRef = ref + } + + claim := &poolv1alpha1.Claim{ + Name: "vni-" + hash(net), + Namespace: net.Namespace, + } + err := r.Get(ctx, client.ObjectKeyFromObject(claim), claim) + if err != nil && !apierrors.IsNotFound(err) { + return fmt.Errorf("get VNI claim %q: %w", claim.Name, err) + } + if err == nil && forwardingContextRef == nil { + owner := metav1.GetControllerOf(claim) + if owner == nil { + conditions.Set(net, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.FabricResolutionFailedReason, + Message: fmt.Sprintf("VNI claim %q has no Fabric controller owner", claim.Name), + }) + return nil + } + forwardingContextRef = &v1alpha1.TypedLocalObjectReference{ + APIVersion: owner.APIVersion, + Kind: owner.Kind, + Name: owner.Name, + } + } + + if forwardingContextRef == nil { + conditions.Set(net, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: v1alpha1.WaitingForDependenciesReason, + Message: "Waiting for NetworkAttachments to resolve a forwarding context", + }) + return nil + } + + fabric := &evpnv1alpha1.Fabric{} + if err := r.Get(ctx, client.ObjectKey{Namespace: net.Namespace, Name: forwardingContextRef.Name}, fabric); err != nil { + if apierrors.IsNotFound(err) { + conditions.Set(net, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.FabricResolutionFailedReason, + Message: fmt.Sprintf("Fabric %q not found", forwardingContextRef.Name), + }) + return nil + } + return fmt.Errorf("get fabric %q: %w", forwardingContextRef.Name, err) + } + + bindingConflict := false + _, err = controllerutil.CreateOrPatch(ctx, r.Client, claim, func() error { + if owner := metav1.GetControllerOf(claim); owner != nil && (owner.APIVersion != evpnv1alpha1.GroupVersion.String() || owner.Kind != "Fabric" || owner.UID != fabric.UID) { + bindingConflict = true + return fmt.Errorf("VNI claim %q is already bound to fabric %q", claim.Name, owner.Name) + } + if claim.Labels == nil { + claim.Labels = make(map[string]string) + } + claim.Labels[evpnv1alpha1.FabricLabel] = fabric.Name + claim.Labels[evpnv1alpha1.NetworkLabel] = net.Name + claim.Spec.PoolRef = fabric.Spec.VNIPool + return controllerutil.SetControllerReference(fabric, claim, r.Scheme) + }) + if err != nil { + if bindingConflict { + conditions.Set(net, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.StretchedNetworkNotSupportedReason, + Message: err.Error(), + }) + return nil + } + return fmt.Errorf("reconcile VNI claim %q: %w", claim.Name, err) + } + + allocated := conditions.Get(claim, poolv1alpha1.AllocatedCondition) + if allocated == nil || allocated.Status != metav1.ConditionTrue || claim.Status.Value == "" || !claim.DeletionTimestamp.IsZero() { + conditions.Set(net, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: v1alpha1.WaitingForDependenciesReason, + Message: fmt.Sprintf("Waiting for VNI claim %q to be allocated", claim.Name), + }) + return nil + } + + conditions.Set(net, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionTrue, + Reason: v1alpha1.ReadyReason, + Message: "Network is ready", + }) + + return nil +} + +func (r *NetworkReconciler) finalize(ctx context.Context, net *overlayv1alpha1.Network) (complete bool, err error) { + log := ctrl.LoggerFrom(ctx) + attachments := &overlayv1alpha1.NetworkAttachmentList{} + if err := r.List(ctx, attachments, client.InNamespace(net.Namespace), client.MatchingFields{networkAttachmentNetworkRefKey: net.Name}); err != nil { + return false, fmt.Errorf("list network attachments for network %q: %w", net.Name, err) + } + for i := range attachments.Items { + if len(attachments.Items[i].Status.Interfaces) > 0 { + log.Info("Waiting for NetworkAttachment Interface membership cleanup", "attachment", attachments.Items[i].Name) + return false, nil + } + } + evis := &v1alpha1.EVPNInstanceList{} + if err := r.List(ctx, evis, client.InNamespace(net.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkLabel: net.Name}); err != nil { + return false, fmt.Errorf("list EVPN instances for network %q: %w", net.Name, err) + } + if len(evis.Items) > 0 { + log.Info("Waiting for Network EVPNInstances to be deleted", "count", len(evis.Items)) + return false, nil + } + claim := &poolv1alpha1.Claim{Name: "vni-" + hash(net), Namespace: net.Namespace} + // Claim finalization releases the allocation asynchronously after deletion is requested. + if err := client.IgnoreNotFound(r.Delete(ctx, claim)); err != nil { + return false, fmt.Errorf("delete VNI claim %q: %w", claim.Name, err) + } + return true, nil +} + +// evpnInstanceToNetworks enqueues the Network associated with an EVPNInstance. +func (r *NetworkReconciler) evpnInstanceToNetworks(ctx context.Context, obj client.Object) []ctrl.Request { + evi, ok := obj.(*v1alpha1.EVPNInstance) + if !ok { + panic(fmt.Sprintf("Expected an EVPNInstance but got a %T", obj)) + } + name := evi.Labels[evpnv1alpha1.NetworkLabel] + if name == "" { + return nil + } + ctrl.LoggerFrom(ctx, "EVPNInstance", klog.KObj(evi)).V(2).Info("Enqueuing Network for reconciliation", "name", name, "namespace", evi.Namespace) + return []ctrl.Request{{Namespace: evi.Namespace, Name: name}} +} + +// networkAttachmentToNetworks is a [handler.MapFunc] that enqueues +// the Network referenced by the changed NetworkAttachment. +func (r *NetworkReconciler) networkAttachmentToNetworks(ctx context.Context, obj client.Object) []ctrl.Request { + na, ok := obj.(*overlayv1alpha1.NetworkAttachment) + if !ok { + panic(fmt.Sprintf("Expected a NetworkAttachment but got a %T", obj)) + } + + log := ctrl.LoggerFrom(ctx, "NetworkAttachment", klog.KObj(na)) + log.V(2).Info("Enqueuing Network for reconciliation", "name", na.Spec.NetworkRef.Name, "namespace", na.Namespace) + return []ctrl.Request{{Namespace: na.Namespace, Name: na.Spec.NetworkRef.Name}} +} + +// claimToNetworks is a [handler.MapFunc] that enqueues +// the Network associated with a VNI Claim. +func (r *NetworkReconciler) claimToNetworks(ctx context.Context, obj client.Object) []ctrl.Request { + claim, ok := obj.(*poolv1alpha1.Claim) + if !ok { + panic(fmt.Sprintf("Expected a Claim but got a %T", obj)) + } + + name := claim.Labels[evpnv1alpha1.NetworkLabel] + if name == "" { + return nil + } + + log := ctrl.LoggerFrom(ctx, "Claim", klog.KObj(claim)) + log.V(2).Info("Enqueuing Network for reconciliation", "name", name, "namespace", claim.Namespace) + return []ctrl.Request{{Namespace: claim.Namespace, Name: name}} +} diff --git a/internal/controller/evpn/network_controller_test.go b/internal/controller/evpn/network_controller_test.go new file mode 100644 index 000000000..93817669f --- /dev/null +++ b/internal/controller/evpn/network_controller_test.go @@ -0,0 +1,332 @@ +// SPDX-FileCopyrightText: SAP SE or an SAP affiliate company and IronCore contributors +// SPDX-License-Identifier: Apache-2.0 + +package evpn + +import ( + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/intstr" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" + + "github.com/ironcore-dev/network-operator/api/core/v1alpha1" + evpnv1alpha1 "github.com/ironcore-dev/network-operator/api/evpn/v1alpha1" + overlayv1alpha1 "github.com/ironcore-dev/network-operator/api/overlay/v1alpha1" + poolv1alpha1 "github.com/ironcore-dev/network-operator/api/pool/v1alpha1" +) + +var _ = Describe("Network Controller", func() { + Context("When reconciling a resource", func() { + var ( + key client.ObjectKey + deviceKey client.ObjectKey + fabricKey client.ObjectKey + vniPoolKey client.ObjectKey + interfaceKey client.ObjectKey + ) + BeforeEach(func() { + net := &overlayv1alpha1.Network{ + GenerateName: "test-network-", + Namespace: metav1.NamespaceDefault, + } + Expect(k8sClient.Create(ctx, net)).To(Succeed()) + key = client.ObjectKeyFromObject(net) + + na := &overlayv1alpha1.NetworkAttachment{ + Name: net.Name, + Namespace: metav1.NamespaceDefault, + Spec: overlayv1alpha1.NetworkAttachmentSpec{ + NetworkRef: v1alpha1.LocalObjectReference{Name: net.Name}, + InterfaceSelector: metav1.LabelSelector{ + MatchLabels: map[string]string{"pod": "ap101"}, + }, + Encapsulation: overlayv1alpha1.Encapsulation{ + Type: overlayv1alpha1.EncapsulationTypeVLAN, + ID: 100, + }, + }, + } + Expect(k8sClient.Create(ctx, na)).To(Succeed()) + + vniPool := &poolv1alpha1.IndexPool{ + GenerateName: "vni-pool-", + Namespace: metav1.NamespaceDefault, + Spec: poolv1alpha1.IndexPoolSpec{ + Ranges: []v1alpha1.IndexRange{v1alpha1.MustParseIndexRange("10000..10010")}, + }, + } + Expect(k8sClient.Create(ctx, vniPool)).To(Succeed()) + vniPoolKey = client.ObjectKeyFromObject(vniPool) + + device := &v1alpha1.Device{ + GenerateName: "test-device-", + Namespace: metav1.NamespaceDefault, + Labels: map[string]string{"fabric-one": "true"}, + Spec: v1alpha1.DeviceSpec{ + Provider: "test-provider", + Endpoint: v1alpha1.Endpoint{Address: "192.0.2.1:9339"}, + }, + } + Expect(k8sClient.Create(ctx, device)).To(Succeed()) + deviceKey = client.ObjectKeyFromObject(device) + + fabric := &evpnv1alpha1.Fabric{ + GenerateName: "fabric-one-", + Namespace: metav1.NamespaceDefault, + Spec: evpnv1alpha1.FabricSpec{ + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"fabric-one": "true"}}, + Loopbacks: evpnv1alpha1.FabricLoopbacksSpec{ + IPAddressPoolRef: v1alpha1.LocalObjectReference{Name: "unused-loopback-pool"}, + }, + Underlay: evpnv1alpha1.FabricUnderlaySpec{ + Protocol: evpnv1alpha1.UnderlayProtocolOSPF, + InterfaceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + Addressing: evpnv1alpha1.FabricUnderlayAddressingSpec{Unnumbered: true}, + }, + Overlay: evpnv1alpha1.FabricOverlaySpec{ + Protocol: evpnv1alpha1.OverlayProtocolIBGP, + IBGP: &evpnv1alpha1.FabricIBGPSpec{ + ASNumber: intstr.FromInt(65000), + RouteReflectors: []evpnv1alpha1.RouteReflectorGroup{{ + Name: "unused", + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + ClientDeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + }}, + }, + }, + BUM: evpnv1alpha1.FabricBUMSpec{ + Type: evpnv1alpha1.BUMTypeMulticast, + PIM: &evpnv1alpha1.FabricPIMSpec{ + AnycastRendezvousPoints: []evpnv1alpha1.AnycastRendezvousPoint{{ + Name: "unused", + MulticastGroups: []v1alpha1.IPPrefix{v1alpha1.MustParsePrefix("224.0.0.0/4")}, + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + ClientDeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + }}, + }, + }, + VTEP: evpnv1alpha1.FabricVTEPSpec{ + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + }, + VNIPool: v1alpha1.TypedLocalObjectReference{ + APIVersion: poolv1alpha1.GroupVersion.String(), + Kind: "IndexPool", + Name: vniPool.Name, + }, + }, + } + Expect(k8sClient.Create(ctx, fabric)).To(Succeed()) + fabricKey = client.ObjectKeyFromObject(fabric) + }) + + AfterEach(func() { + // Finish Interface cleanup while the attachment's dependencies still exist. + na := &overlayv1alpha1.NetworkAttachment{Name: key.Name, Namespace: key.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, na))).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, key, &overlayv1alpha1.NetworkAttachment{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + }).Should(Succeed()) + + // Envtest does not garbage-collect attachment-owned resources. + Expect(k8sClient.DeleteAllOf(ctx, &v1alpha1.EVPNInstance{}, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + Expect(k8sClient.DeleteAllOf(ctx, &v1alpha1.VLAN{}, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + + net := &overlayv1alpha1.Network{Name: key.Name, Namespace: key.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, net))).To(Succeed()) + + Eventually(func(g Gomega) { + g.Expect(apierrors.IsNotFound(k8sClient.Get(ctx, key, &overlayv1alpha1.Network{}))).To(BeTrue()) + }).Should(Succeed()) + + // Stop Fabric reconciliation before removing Claims so they cannot be recreated. + fabric := &evpnv1alpha1.Fabric{Name: fabricKey.Name, Namespace: fabricKey.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, fabric))).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, fabricKey, &evpnv1alpha1.Fabric{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + }).Should(Succeed()) + + // Envtest has no garbage collector; Claims must finalize before their pools disappear. + Expect(k8sClient.DeleteAllOf(ctx, &poolv1alpha1.Claim{}, client.InNamespace(fabricKey.Namespace), client.MatchingLabels{evpnv1alpha1.FabricLabel: fabricKey.Name})).To(Succeed()) + Eventually(func(g Gomega) { + claims := &poolv1alpha1.ClaimList{} + g.Expect(k8sClient.List(ctx, claims, client.InNamespace(fabricKey.Namespace), client.MatchingLabels{evpnv1alpha1.FabricLabel: fabricKey.Name})).To(Succeed()) + g.Expect(claims.Items).To(BeEmpty()) + }).Should(Succeed()) + + // Claim finalization recycles its Index allocation without relying on garbage collection. + Eventually(func(g Gomega) { + indices := &poolv1alpha1.IndexList{} + g.Expect(k8sClient.List(ctx, indices, client.InNamespace(vniPoolKey.Namespace))).To(Succeed()) + g.Expect(indices.Items).NotTo(ContainElement(HaveField("Spec.PoolRef.Name", vniPoolKey.Name))) + }).Should(Succeed()) + vniPool := &poolv1alpha1.IndexPool{Name: vniPoolKey.Name, Namespace: vniPoolKey.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, vniPool))).To(Succeed()) + + device := &v1alpha1.Device{Name: deviceKey.Name, Namespace: deviceKey.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, device))).To(Succeed()) + }) + + BeforeEach(func() { + intf := &v1alpha1.Interface{ + GenerateName: "network-interface-", + Namespace: key.Namespace, + Labels: map[string]string{}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{Mode: v1alpha1.SwitchportModeTrunk}, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + interfaceKey = client.ObjectKeyFromObject(intf) + }) + AfterEach(func() { + intf := &v1alpha1.Interface{Name: interfaceKey.Name, Namespace: interfaceKey.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + It("successfully allocates and retains a Network VNI", func() { + By("Resolving the Fabric through the attachment and reporting Network Ready") + intf := &v1alpha1.Interface{} + Expect(k8sClient.Get(ctx, interfaceKey, intf)).To(Succeed()) + intf.Labels = map[string]string{"pod": "ap101"} + Expect(k8sClient.Update(ctx, intf)).To(Succeed()) + net := &overlayv1alpha1.Network{} + Eventually(func(g Gomega) { + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + g.Expect(controllerutil.ContainsFinalizer(net, evpnv1alpha1.FinalizerName)).To(BeTrue()) + g.Expect(net.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + HaveField("ObservedGeneration", net.Generation), + ))) + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.ForwardingContextRef).To(Equal(&v1alpha1.TypedLocalObjectReference{ + APIVersion: evpnv1alpha1.GroupVersion.String(), Kind: "Fabric", Name: fabricKey.Name, + })) + }).Should(Succeed()) + + By("Allocating one deterministic Fabric-owned Claim from its VNI pool") + claims := &poolv1alpha1.ClaimList{} + Expect(k8sClient.List(ctx, claims, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkLabel: key.Name})).To(Succeed()) + Expect(claims.Items).To(HaveLen(1)) + claim := claims.Items[0] + Expect(claim.Name).To(Equal("vni-" + hash(net))) + fabric := &evpnv1alpha1.Fabric{} + Expect(k8sClient.Get(ctx, fabricKey, fabric)).To(Succeed()) + Expect(metav1.IsControlledBy(&claim, fabric)).To(BeTrue()) + Expect(claim.Labels).To(HaveKeyWithValue(evpnv1alpha1.FabricLabel, fabric.Name)) + Expect(claim.Spec.PoolRef).To(Equal(fabric.Spec.VNIPool)) + Expect(claim.Status.Value).To(Equal("10000")) + Expect(claim.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", poolv1alpha1.AllocatedCondition), HaveField("Status", metav1.ConditionTrue), + ))) + Expect(claim.Status.AllocationRef).NotTo(BeNil()) + index := &poolv1alpha1.Index{} + Expect(k8sClient.Get(ctx, client.ObjectKey{Namespace: key.Namespace, Name: claim.Status.AllocationRef.Name}, index)).To(Succeed()) + Expect(index.Spec.PoolRef.Name).To(Equal(vniPoolKey.Name)) + + By("Retaining the allocation after the last attachment disappears") + na := &overlayv1alpha1.NetworkAttachment{Name: key.Name, Namespace: key.Namespace} + Expect(k8sClient.Delete(ctx, na)).To(Succeed()) + Eventually(func(g Gomega) { + g.Expect(apierrors.IsNotFound(k8sClient.Get(ctx, key, &overlayv1alpha1.NetworkAttachment{}))).To(BeTrue()) + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + g.Expect(net.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), HaveField("Status", metav1.ConditionTrue), HaveField("Reason", v1alpha1.ReadyReason), + ))) + current := &poolv1alpha1.Claim{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(&claim), current)).To(Succeed()) + g.Expect(current.UID).To(Equal(claim.UID)) + g.Expect(current.Status.Value).To(Equal(claim.Status.Value)) + g.Expect(current.DeletionTimestamp.IsZero()).To(BeTrue()) + }).Should(Succeed()) + }) + + It("waits for attachment resolution and recovers when an Interface matches", func() { + By("Waiting without allocating while no Interface matches the attachment") + Eventually(func(g Gomega) { + net := &overlayv1alpha1.Network{} + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + g.Expect(net.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), HaveField("Status", metav1.ConditionFalse), HaveField("Reason", v1alpha1.WaitingForDependenciesReason), + ))) + claims := &poolv1alpha1.ClaimList{} + g.Expect(k8sClient.List(ctx, claims, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkLabel: key.Name})).To(Succeed()) + g.Expect(claims.Items).To(BeEmpty()) + }).Should(Succeed()) + By("Resolving through the attachment status watch after its selector matches") + intf := &v1alpha1.Interface{} + Expect(k8sClient.Get(ctx, interfaceKey, intf)).To(Succeed()) + intf.Labels = map[string]string{"pod": "ap101"} + Expect(k8sClient.Update(ctx, intf)).To(Succeed()) + Eventually(func(g Gomega) { + net := &overlayv1alpha1.Network{} + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + g.Expect(net.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), HaveField("Status", metav1.ConditionTrue), HaveField("Reason", v1alpha1.ReadyReason), + ))) + }).Should(Succeed()) + }) + + It("preserves the allocation when the attachment resolves to another Fabric", func() { + intf := &v1alpha1.Interface{} + Expect(k8sClient.Get(ctx, interfaceKey, intf)).To(Succeed()) + intf.Labels = map[string]string{"pod": "ap101"} + Expect(k8sClient.Update(ctx, intf)).To(Succeed()) + Eventually(func(g Gomega) { + net := &overlayv1alpha1.Network{} + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + g.Expect(net.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), HaveField("Status", metav1.ConditionTrue), HaveField("Reason", v1alpha1.ReadyReason), + ))) + }).Should(Succeed()) + claims := &poolv1alpha1.ClaimList{} + Expect(k8sClient.List(ctx, claims, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkLabel: key.Name})).To(Succeed()) + Expect(claims.Items).To(HaveLen(1)) + claim := claims.Items[0] + + By("Creating another Fabric and moving the selected Device into it") + fabric := &evpnv1alpha1.Fabric{} + Expect(k8sClient.Get(ctx, fabricKey, fabric)).To(Succeed()) + other := &evpnv1alpha1.Fabric{ + GenerateName: "other-fabric-", Namespace: key.Namespace, Spec: fabric.Spec, + } + other.Spec.DeviceSelector = metav1.LabelSelector{MatchLabels: map[string]string{"other-fabric": key.Name}} + Expect(k8sClient.Create(ctx, other)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, other))).To(Succeed()) + Eventually(func(g Gomega) { + g.Expect(apierrors.IsNotFound(k8sClient.Get(ctx, client.ObjectKeyFromObject(other), &evpnv1alpha1.Fabric{}))).To(BeTrue()) + }).Should(Succeed()) + Expect(k8sClient.DeleteAllOf(ctx, &poolv1alpha1.Claim{}, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.FabricLabel: other.Name})).To(Succeed()) + }) + device := &v1alpha1.Device{} + Expect(k8sClient.Get(ctx, deviceKey, device)).To(Succeed()) + device.Labels = map[string]string{"other-fabric": key.Name} + Expect(k8sClient.Update(ctx, device)).To(Succeed()) + Eventually(func(g Gomega) { + net := &overlayv1alpha1.Network{} + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + g.Expect(net.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), HaveField("Status", metav1.ConditionFalse), HaveField("Reason", evpnv1alpha1.StretchedNetworkNotSupportedReason), + ))) + current := &poolv1alpha1.Claim{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(&claim), current)).To(Succeed()) + g.Expect(current.UID).To(Equal(claim.UID)) + g.Expect(current.OwnerReferences).To(Equal(claim.OwnerReferences)) + g.Expect(current.Spec.PoolRef).To(Equal(claim.Spec.PoolRef)) + g.Expect(current.Status.Value).To(Equal(claim.Status.Value)) + }).Should(Succeed()) + }) + }) +}) diff --git a/internal/controller/evpn/networkattachment_controller.go b/internal/controller/evpn/networkattachment_controller.go new file mode 100644 index 000000000..31f551e0f --- /dev/null +++ b/internal/controller/evpn/networkattachment_controller.go @@ -0,0 +1,1248 @@ +// SPDX-FileCopyrightText: SAP SE or an SAP affiliate company and IronCore contributors +// SPDX-License-Identifier: Apache-2.0 + +package evpn + +import ( + "cmp" + "context" + "crypto/sha256" + "encoding/hex" + "fmt" + "maps" + "slices" + "strconv" + "strings" + + "k8s.io/apimachinery/pkg/api/equality" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/runtime" + kerrors "k8s.io/apimachinery/pkg/util/errors" + "k8s.io/apimachinery/pkg/util/sets" + "k8s.io/client-go/tools/events" + "k8s.io/klog/v2" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/builder" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" + "sigs.k8s.io/controller-runtime/pkg/event" + "sigs.k8s.io/controller-runtime/pkg/handler" + "sigs.k8s.io/controller-runtime/pkg/predicate" + "sigs.k8s.io/controller-runtime/pkg/reconcile" + + "github.com/ironcore-dev/network-operator/api/core/v1alpha1" + evpnv1alpha1 "github.com/ironcore-dev/network-operator/api/evpn/v1alpha1" + overlayv1alpha1 "github.com/ironcore-dev/network-operator/api/overlay/v1alpha1" + poolv1alpha1 "github.com/ironcore-dev/network-operator/api/pool/v1alpha1" + "github.com/ironcore-dev/network-operator/internal/conditions" +) + +// NetworkAttachmentReconciler reconciles a NetworkAttachment object. +type NetworkAttachmentReconciler struct { + client.Client + Scheme *runtime.Scheme + + // WatchFilterValue is the label value used to filter events prior to reconciliation. + WatchFilterValue string + + // Recorder is used to record events for the controller. + // More info: https://book.kubebuilder.io/reference/raising-events + Recorder events.EventRecorder +} + +// +kubebuilder:rbac:groups=overlay.networking.metal.ironcore.dev,resources=networkattachments,verbs=get;list;watch;create;update;patch;delete +// +kubebuilder:rbac:groups=overlay.networking.metal.ironcore.dev,resources=networkattachments/status,verbs=get;update;patch +// +kubebuilder:rbac:groups=overlay.networking.metal.ironcore.dev,resources=networkattachments/finalizers,verbs=update +// +kubebuilder:rbac:groups=overlay.networking.metal.ironcore.dev,resources=networks,verbs=get;list;watch +// +kubebuilder:rbac:groups=evpn.networking.metal.ironcore.dev,resources=fabrics,verbs=get;list;watch +// +kubebuilder:rbac:groups=pool.networking.metal.ironcore.dev,resources=claims,verbs=get;list;watch;create;update;patch +// +kubebuilder:rbac:groups=networking.metal.ironcore.dev,resources=devices,verbs=get;list;watch +// +kubebuilder:rbac:groups=networking.metal.ironcore.dev,resources=interfaces,verbs=get;list;watch;update;patch +// +kubebuilder:rbac:groups=networking.metal.ironcore.dev,resources=vlans,verbs=get;list;watch;create;update;patch;delete +// +kubebuilder:rbac:groups=networking.metal.ironcore.dev,resources=evpninstances,verbs=get;list;watch;create;update;patch;delete +// +kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=create;patch + +// Reconcile is part of the main kubernetes reconciliation loop which aims to +// move the current state of the cluster closer to the desired state. +// +// For more details, check Reconcile and its Result here: +// - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.24.1/pkg/reconcile +func (r *NetworkAttachmentReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, reterr error) { + log := ctrl.LoggerFrom(ctx) + log.Info("Reconciling resource") + + na := new(overlayv1alpha1.NetworkAttachment) + if err := r.Get(ctx, req.NamespacedName, na); err != nil { + if apierrors.IsNotFound(err) { + log.Info("Resource not found. Ignoring since object must be deleted") + return ctrl.Result{}, nil + } + log.Error(err, "Failed to get resource") + return ctrl.Result{}, err + } + + if !na.DeletionTimestamp.IsZero() { + if controllerutil.ContainsFinalizer(na, evpnv1alpha1.FinalizerName) { + if err := r.finalize(ctx, na); err != nil { + log.Error(err, "Failed to finalize resource") + return ctrl.Result{}, err + } + controllerutil.RemoveFinalizer(na, evpnv1alpha1.FinalizerName) + if err := r.Update(ctx, na); err != nil { + log.Error(err, "Failed to remove finalizer from resource") + return ctrl.Result{}, err + } + } + log.Info("Resource is being deleted, skipping reconciliation") + return ctrl.Result{}, nil + } + + // More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/finalizers + if !controllerutil.ContainsFinalizer(na, evpnv1alpha1.FinalizerName) { + controllerutil.AddFinalizer(na, evpnv1alpha1.FinalizerName) + if err := r.Update(ctx, na); err != nil { + log.Error(err, "Failed to add finalizer to resource") + return ctrl.Result{}, err + } + log.Info("Added finalizer to resource") + return ctrl.Result{}, nil + } + + orig := na.DeepCopy() + if conditions.InitializeConditions(na, v1alpha1.ReadyCondition) { + log.V(1).Info("Initializing status conditions") + return ctrl.Result{}, r.Status().Update(ctx, na) + } + + defer func() { + if !equality.Semantic.DeepEqual(orig.Status, na.Status) { + // Pass obj.DeepCopy() to avoid Patch() modifying obj and interfering with metadata update below + if err := r.Status().Patch(ctx, na.DeepCopy(), client.MergeFrom(orig)); err != nil { + log.Error(err, "Failed to update status") + reterr = kerrors.NewAggregate([]error{reterr, err}) + } + } + if !equality.Semantic.DeepEqual(orig.ObjectMeta, na.ObjectMeta) { + if err := r.Patch(ctx, na, client.MergeFrom(orig)); err != nil { + log.Error(err, "Failed to update resource metadata") + reterr = kerrors.NewAggregate([]error{reterr, err}) + } + } + }() + + if err := r.reconcile(ctx, na); err != nil { + log.Error(err, "Failed to reconcile resource") + return ctrl.Result{}, err + } + + return ctrl.Result{}, nil +} + +const ( + networkAttachmentEncapsulationKey = ".spec.encapsulation" + networkAttachmentNetworkRefKey = ".spec.networkRef.name" + networkAttachmentInterfaceRefKey = ".status.interfaces.interfaceRef.name" + controllerOwnerUIDKey = ".metadata.controller.uid" +) + +// SetupWithManager sets up the controller with the Manager. +func (r *NetworkAttachmentReconciler) SetupWithManager(ctx context.Context, mgr ctrl.Manager) error { + labelSelector := metav1.LabelSelector{} + if r.WatchFilterValue != "" { + labelSelector.MatchLabels = map[string]string{v1alpha1.WatchLabel: r.WatchFilterValue} + } + + filter, err := predicate.LabelSelectorPredicate(labelSelector) + if err != nil { + return fmt.Errorf("create label selector predicate: %w", err) + } + + if err := mgr.GetFieldIndexer().IndexField(ctx, &overlayv1alpha1.NetworkAttachment{}, networkAttachmentEncapsulationKey, func(obj client.Object) []string { + na := obj.(*overlayv1alpha1.NetworkAttachment) + return []string{na.Spec.Encapsulation.Key()} + }); err != nil { + return err + } + + if err := mgr.GetFieldIndexer().IndexField(ctx, &overlayv1alpha1.NetworkAttachment{}, networkAttachmentNetworkRefKey, func(obj client.Object) []string { + na := obj.(*overlayv1alpha1.NetworkAttachment) + return []string{na.Spec.NetworkRef.Name} + }); err != nil { + return err + } + + if err := mgr.GetFieldIndexer().IndexField(ctx, &overlayv1alpha1.NetworkAttachment{}, networkAttachmentInterfaceRefKey, func(obj client.Object) []string { + na := obj.(*overlayv1alpha1.NetworkAttachment) + names := make([]string, 0, len(na.Status.Interfaces)) + for _, status := range na.Status.Interfaces { + names = append(names, status.InterfaceRef.Name) + } + return names + }); err != nil { + return err + } + + for _, obj := range []client.Object{&v1alpha1.VLAN{}, &v1alpha1.EVPNInstance{}} { + if err := mgr.GetFieldIndexer().IndexField(ctx, obj, controllerOwnerUIDKey, func(obj client.Object) []string { + owner := metav1.GetControllerOf(obj) + if owner == nil { + return nil + } + return []string{string(owner.UID)} + }); err != nil { + return err + } + } + + return ctrl.NewControllerManagedBy(mgr). + For(&overlayv1alpha1.NetworkAttachment{}). + Named("evpn-networkattachment"). + WithEventFilter(filter). + Owns(&v1alpha1.VLAN{}). + Owns(&v1alpha1.EVPNInstance{}). + // Watches enqueues NetworkAttachments that request the same encapsulation. + Watches( + &overlayv1alpha1.NetworkAttachment{}, + handler.EnqueueRequestsFromMapFunc(r.networkAttachmentToNetworkAttachments), + builder.WithPredicates(predicate.Funcs{ + UpdateFunc: func(e event.UpdateEvent) bool { + oldNA := e.ObjectOld.(*overlayv1alpha1.NetworkAttachment) + newNA := e.ObjectNew.(*overlayv1alpha1.NetworkAttachment) + return !equality.Semantic.DeepEqual(oldNA.Spec.InterfaceSelector, newNA.Spec.InterfaceSelector) + }, + GenericFunc: func(event.GenericEvent) bool { + return false + }, + }), + ). + // Watches enqueues NetworkAttachments when their referenced Network is created, starts deletion, or is deleted. + Watches( + &overlayv1alpha1.Network{}, + handler.EnqueueRequestsFromMapFunc(r.networkToNetworkAttachments), + builder.WithPredicates(predicate.Funcs{ + UpdateFunc: func(e event.UpdateEvent) bool { + return !equality.Semantic.DeepEqual(e.ObjectOld.GetDeletionTimestamp(), e.ObjectNew.GetDeletionTimestamp()) + }, + GenericFunc: func(event.GenericEvent) bool { + return false + }, + }), + ). + // Watches enqueues NetworkAttachments when their shared VNI Claim changes. + Watches( + &poolv1alpha1.Claim{}, + handler.EnqueueRequestsFromMapFunc(r.claimToNetworkAttachments), + builder.WithPredicates(predicate.Funcs{ + UpdateFunc: func(e event.UpdateEvent) bool { + oldClaim := e.ObjectOld.(*poolv1alpha1.Claim) + newClaim := e.ObjectNew.(*poolv1alpha1.Claim) + return !equality.Semantic.DeepEqual(oldClaim.Status, newClaim.Status) + }, + GenericFunc: func(event.GenericEvent) bool { + return false + }, + }), + ). + // Watches enqueues NetworkAttachments when matching Interfaces change. + Watches( + &v1alpha1.Interface{}, + handler.EnqueueRequestsFromMapFunc(r.interfaceToNetworkAttachments), + builder.WithPredicates(predicate.Or( + predicate.LabelChangedPredicate{}, + predicate.Funcs{ + UpdateFunc: func(e event.UpdateEvent) bool { + oldInterface := e.ObjectOld.(*v1alpha1.Interface) + newInterface := e.ObjectNew.(*v1alpha1.Interface) + return oldInterface.Spec.Type != newInterface.Spec.Type || + !equality.Semantic.DeepEqual(oldInterface.Spec.Switchport, newInterface.Spec.Switchport) + }, + GenericFunc: func(event.GenericEvent) bool { + return false + }, + }, + )), + ). + // Watches enqueues NetworkAttachments when EVPN instances on selected Devices are created or deleted. + Watches( + &v1alpha1.EVPNInstance{}, + handler.EnqueueRequestsFromMapFunc(r.evpnInstanceToNetworkAttachments), + builder.WithPredicates(predicate.Funcs{ + UpdateFunc: func(event.UpdateEvent) bool { + return false + }, + GenericFunc: func(event.GenericEvent) bool { + return false + }, + }), + ). + // Watches enqueues NetworkAttachments when Device labels change. + Watches( + &v1alpha1.Device{}, + handler.EnqueueRequestsFromMapFunc(r.deviceToNetworkAttachments), + builder.WithPredicates(predicate.LabelChangedPredicate{}), + ). + // Watches enqueues NetworkAttachments when Fabric device selectors or iBGP configuration change. + Watches( + &evpnv1alpha1.Fabric{}, + handler.EnqueueRequestsFromMapFunc(r.fabricToNetworkAttachments), + builder.WithPredicates(predicate.Funcs{ + UpdateFunc: func(e event.UpdateEvent) bool { + oldFabric := e.ObjectOld.(*evpnv1alpha1.Fabric) + newFabric := e.ObjectNew.(*evpnv1alpha1.Fabric) + return !equality.Semantic.DeepEqual(oldFabric.Spec.DeviceSelector, newFabric.Spec.DeviceSelector) || + !equality.Semantic.DeepEqual(oldFabric.Spec.Overlay.IBGP, newFabric.Spec.Overlay.IBGP) + }, + GenericFunc: func(event.GenericEvent) bool { + return false + }, + }), + ). + Complete(r) +} + +func (r *NetworkAttachmentReconciler) reconcile(ctx context.Context, na *overlayv1alpha1.NetworkAttachment) error { + if na.Spec.Encapsulation.Type != overlayv1alpha1.EncapsulationTypeVLAN { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: v1alpha1.NotImplementedReason, + Message: fmt.Sprintf("Encapsulation type %q is not supported", na.Spec.Encapsulation.Type), + }) + return nil + } + + network := &overlayv1alpha1.Network{} + err := r.Get(ctx, client.ObjectKey{Namespace: na.Namespace, Name: na.Spec.NetworkRef.Name}, network) + if err != nil && !apierrors.IsNotFound(err) { + return fmt.Errorf("get network %q: %w", na.Spec.NetworkRef.Name, err) + } + if apierrors.IsNotFound(err) || !network.DeletionTimestamp.IsZero() { + if err := r.reconcileInterfaceMembership(ctx, na, nil); err != nil { + return err + } + if err := r.deleteStaleResources(ctx, na, nil); err != nil { + return err + } + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.NetworkNotFoundReason, + Message: fmt.Sprintf("Network %q is missing or being deleted", na.Spec.NetworkRef.Name), + }) + return nil + } + + interfaces, err := r.resolveInterfaces(ctx, na) + if err != nil { + return err + } + if len(interfaces.Items) == 0 { + if err := r.reconcileInterfaceMembership(ctx, na, nil); err != nil { + return err + } + if err := r.deleteStaleResources(ctx, na, nil); err != nil { + return err + } + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.NoMatchingInterfacesReason, + Message: "Interface selector matches no interfaces", + }) + return nil + } + + devices, err := r.resolveDevices(ctx, na, interfaces) + if err != nil { + return err + } + + fabric, err := r.resolveFabric(ctx, na, devices) + if err != nil { + return err + } + + forwardingContextRef := v1alpha1.TypedLocalObjectRefFromObject(fabric) + if !equality.Semantic.DeepEqual(na.Status.ForwardingContextRef, forwardingContextRef) { + // Persist the forwarding context reference before mutation; the status update retriggers reconciliation. + na.Status.ForwardingContextRef = forwardingContextRef + return nil + } + + claim, err := r.resolveVNIClaim(ctx, na, network, fabric) + if err != nil { + return err + } + + vni, routeTarget, err := r.computeVNIRouteTarget(na, fabric, claim) + if err != nil { + return err + } + + if err := r.validateEncapsulationConflicts(ctx, na, devices, vni); err != nil { + return err + } + + if err := r.validatePeerConflicts(ctx, na, devices); err != nil { + return err + } + + desiredInterfaces := make(map[string]overlayv1alpha1.NetworkAttachmentInterfaceStatus, len(interfaces.Items)) + for i := range interfaces.Items { + intf := &interfaces.Items[i] + desiredInterfaces[intf.Name] = overlayv1alpha1.NetworkAttachmentInterfaceStatus{ + DeviceRef: v1alpha1.LocalObjectReference{Name: intf.Spec.DeviceRef.Name}, + InterfaceRef: v1alpha1.LocalObjectReference{Name: intf.Name}, + } + } + + if r.persistInterfaceOwnership(na, desiredInterfaces) { + // Persist ownership before mutation; the status update retriggers reconciliation. + return nil + } + + if err := r.reconcileEncapsulation(ctx, na, devices, fabric, vni, routeTarget); err != nil { + return err + } + + if err := r.reconcileInterfaceMembership(ctx, na, desiredInterfaces); err != nil { + return err + } + + if err := r.deleteStaleResources(ctx, na, devices); err != nil { + return err + } + + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionTrue, + Reason: v1alpha1.ReadyReason, + Message: "EVPN attachment realized", + }) + + return nil +} + +func (r *NetworkAttachmentReconciler) resolveInterfaces(ctx context.Context, na *overlayv1alpha1.NetworkAttachment) (*v1alpha1.InterfaceList, error) { + selector, err := metav1.LabelSelectorAsSelector(&na.Spec.InterfaceSelector) + if err != nil { + return nil, reconcile.TerminalError(fmt.Errorf("parse interface selector: %w", err)) + } + + interfaces := &v1alpha1.InterfaceList{} + if err := r.List( + ctx, + interfaces, + client.InNamespace(na.Namespace), + client.MatchingLabelsSelector{Selector: selector}, + ); err != nil { + return nil, fmt.Errorf("list selected interfaces: %w", err) + } + + var errs []error + for i := range interfaces.Items { + intf := &interfaces.Items[i] + switch { + case intf.Spec.Type != v1alpha1.InterfaceTypePhysical && intf.Spec.Type != v1alpha1.InterfaceTypeAggregate: + errs = append(errs, fmt.Errorf("interface %q has type %q, want %q or %q", intf.Name, intf.Spec.Type, v1alpha1.InterfaceTypePhysical, v1alpha1.InterfaceTypeAggregate)) + case intf.Spec.Switchport == nil: + errs = append(errs, fmt.Errorf("interface %q has no switchport configuration", intf.Name)) + case intf.Spec.Switchport.Mode != v1alpha1.SwitchportModeTrunk: + errs = append(errs, fmt.Errorf("interface %q has switchport mode %q, want %q", intf.Name, intf.Spec.Switchport.Mode, v1alpha1.SwitchportModeTrunk)) + case intf.Spec.Switchport.AllowedVlansMode == v1alpha1.AllowedVlansModeUnmanaged: + errs = append(errs, fmt.Errorf("interface %q has allowed VLAN mode %q, want %q", intf.Name, intf.Spec.Switchport.AllowedVlansMode, v1alpha1.AllowedVlansModeExact)) + } + } + if len(errs) > 0 { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.InvalidInterfaceReason, + Message: kerrors.NewAggregate(errs).Error(), + }) + return nil, reconcile.TerminalError(kerrors.NewAggregate(errs)) + } + + return interfaces, nil +} + +func (r *NetworkAttachmentReconciler) resolveDevices(ctx context.Context, na *overlayv1alpha1.NetworkAttachment, interfaces *v1alpha1.InterfaceList) (map[string]*v1alpha1.Device, error) { + devices := make(map[string]*v1alpha1.Device) + + var errs []error + for i := range interfaces.Items { + name := interfaces.Items[i].Spec.DeviceRef.Name + if _, ok := devices[name]; ok { + continue + } + device := &v1alpha1.Device{} + if err := r.Get(ctx, client.ObjectKey{Namespace: na.Namespace, Name: name}, device); err != nil { + if apierrors.IsNotFound(err) { + errs = append(errs, fmt.Errorf("device %q referenced by interface %q not found", name, interfaces.Items[i].Name)) + continue + } + return nil, fmt.Errorf("get device %q: %w", name, err) + } + devices[name] = device + } + if len(errs) > 0 { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.DeviceResolutionFailedReason, + Message: kerrors.NewAggregate(errs).Error(), + }) + return nil, reconcile.TerminalError(kerrors.NewAggregate(errs)) + } + + return devices, nil +} + +func (r *NetworkAttachmentReconciler) resolveFabric(ctx context.Context, na *overlayv1alpha1.NetworkAttachment, devices map[string]*v1alpha1.Device) (*evpnv1alpha1.Fabric, error) { + var fabric *evpnv1alpha1.Fabric + + fabrics := &evpnv1alpha1.FabricList{} + if err := r.List(ctx, fabrics, client.InNamespace(na.Namespace)); err != nil { + return nil, fmt.Errorf("list fabrics: %w", err) + } + + var errs []error + for _, device := range devices { + var matchingFabrics []*evpnv1alpha1.Fabric + for i := range fabrics.Items { + fabricSelector, err := metav1.LabelSelectorAsSelector(&fabrics.Items[i].Spec.DeviceSelector) + if err != nil { + return nil, fmt.Errorf("parse device selector for fabric %q: %w", fabrics.Items[i].Name, err) + } + if fabricSelector.Matches(labels.Set(device.Labels)) { + matchingFabrics = append(matchingFabrics, &fabrics.Items[i]) + } + } + switch len(matchingFabrics) { + case 0: + errs = append(errs, fmt.Errorf("device %q does not match any fabric", device.Name)) + case 1: + matchedFabric := matchingFabrics[0] + if fabric == nil { + fabric = matchedFabric + continue + } + if fabric.Name != matchedFabric.Name { + errs = append(errs, fmt.Errorf("device %q resolves to fabric %q, want %q", device.Name, matchedFabric.Name, fabric.Name)) + } + default: + errs = append(errs, fmt.Errorf("device %q matches %d fabrics, want exactly one", device.Name, len(matchingFabrics))) + } + } + if len(errs) > 0 { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.FabricResolutionFailedReason, + Message: kerrors.NewAggregate(errs).Error(), + }) + return nil, reconcile.TerminalError(kerrors.NewAggregate(errs)) + } + + if fabric.Spec.Overlay.IBGP == nil { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.UnsupportedASNumberReason, + Message: fmt.Sprintf("Fabric %q has no iBGP configuration", fabric.Name), + }) + return nil, reconcile.TerminalError(fmt.Errorf("fabric %q has no iBGP configuration", fabric.Name)) + } + + return fabric, nil +} + +func (r *NetworkAttachmentReconciler) resolveVNIClaim(ctx context.Context, na *overlayv1alpha1.NetworkAttachment, network *overlayv1alpha1.Network, fabric *evpnv1alpha1.Fabric) (*poolv1alpha1.Claim, error) { + claim := &poolv1alpha1.Claim{ + Name: "vni-" + hash(network), + Namespace: na.Namespace, + } + if err := r.Get(ctx, client.ObjectKeyFromObject(claim), claim); err != nil { + if apierrors.IsNotFound(err) { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: v1alpha1.WaitingForDependenciesReason, + Message: fmt.Sprintf("Waiting for VNI claim %q to be created", claim.Name), + }) + return nil, reconcile.TerminalError(fmt.Errorf("VNI claim %q not found", claim.Name)) + } + return nil, fmt.Errorf("get VNI claim %q: %w", claim.Name, err) + } + + if owner := metav1.GetControllerOf(claim); owner == nil || + owner.APIVersion != evpnv1alpha1.GroupVersion.String() || owner.Kind != "Fabric" || owner.UID != fabric.UID { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.StretchedNetworkNotSupportedReason, + Message: fmt.Sprintf("VNI claim %q is not bound to fabric %q", claim.Name, fabric.Name), + }) + return nil, reconcile.TerminalError(fmt.Errorf("VNI claim %q is not bound to fabric %q", claim.Name, fabric.Name)) + } + + allocated := conditions.Get(claim, poolv1alpha1.AllocatedCondition) + if allocated == nil || allocated.Status != metav1.ConditionTrue || claim.Status.Value == "" { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: v1alpha1.WaitingForDependenciesReason, + Message: fmt.Sprintf("Waiting for VNI claim %q to be allocated", claim.Name), + }) + return nil, reconcile.TerminalError(fmt.Errorf("VNI claim %q is not allocated", claim.Name)) + } + + return claim, nil +} + +func (r *NetworkAttachmentReconciler) computeVNIRouteTarget(na *overlayv1alpha1.NetworkAttachment, fabric *evpnv1alpha1.Fabric, claim *poolv1alpha1.Claim) (vni uint64, rt string, err error) { + asNumber := fabric.Spec.Overlay.IBGP.ASNumber.String() + // RFC 8365 auto-derivation requires a 2-byte ASN; bit size 16 rejects larger and dotted ASNs. + asn, err := strconv.ParseUint(asNumber, 10, 16) + if err != nil || asn == 0 { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.UnsupportedASNumberReason, + Message: fmt.Sprintf("Fabric %q has unsupported AS number %q, want 1..65535", fabric.Name, asNumber), + }) + return 0, "", reconcile.TerminalError(fmt.Errorf("fabric %q has unsupported AS number %q, want 1..65535", fabric.Name, asNumber)) + } + + vni, err = strconv.ParseUint(claim.Status.Value, 10, 24) + if err != nil || vni == 0 || vni > 16777214 { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.InvalidVNIReason, + Message: fmt.Sprintf("Claim %q has invalid VNI %q", claim.Name, claim.Status.Value), + }) + return 0, "", reconcile.TerminalError(fmt.Errorf("claim %q has invalid VNI %q", claim.Name, claim.Status.Value)) + } + + // RFC 8365 divides the 32-bit local administrator as follows: + // + // bit 31 bits 30..28 bits 27..24 bits 23..0 + // +------------+------------+------------+----------------+ + // | A | Type | Domain ID | Service ID | + // | 1 bit | 3 bits | 4 bits | 24 bits | + // +------------+------------+------------+----------------+ + // + // A=0 means auto-derived, Type=1 means VXLAN, Domain ID=0, and Service ID is the VNI. + localAdministrator := uint32(1<<28) | uint32(vni) + + // Represent the RFC 8365 auto-derived route target in ASN:local-administrator notation. + rt = fmt.Sprintf("%d:%d", asn, localAdministrator) + + return vni, rt, nil +} + +func (r *NetworkAttachmentReconciler) validatePeerConflicts(ctx context.Context, na *overlayv1alpha1.NetworkAttachment, devices map[string]*v1alpha1.Device) error { + peers := &overlayv1alpha1.NetworkAttachmentList{} + if err := r.List( + ctx, + peers, + client.InNamespace(na.Namespace), + client.MatchingFields{networkAttachmentEncapsulationKey: na.Spec.Encapsulation.Key()}, + ); err != nil { + return fmt.Errorf("list network attachments with encapsulation %q: %w", na.Spec.Encapsulation.Key(), err) + } + + var errs []error + for i := range peers.Items { + peer := &peers.Items[i] + if peer.Name == na.Name { + continue + } + + peerSelector, err := metav1.LabelSelectorAsSelector(&peer.Spec.InterfaceSelector) + if err != nil { + return fmt.Errorf("parse interface selector for network attachment %q: %w", peer.Name, err) + } + + peerInterfaces := &v1alpha1.InterfaceList{} + if err := r.List( + ctx, + peerInterfaces, + client.InNamespace(peer.Namespace), + client.MatchingLabelsSelector{Selector: peerSelector}, + ); err != nil { + return fmt.Errorf("list interfaces for network attachment %q: %w", peer.Name, err) + } + + for j := range peerInterfaces.Items { + deviceName := peerInterfaces.Items[j].Spec.DeviceRef.Name + if _, ok := devices[deviceName]; !ok { + continue + } + errs = append(errs, fmt.Errorf("network attachment %q also requests encapsulation %q on device %q", peer.Name, na.Spec.Encapsulation.Key(), deviceName)) + break + } + } + if len(errs) > 0 { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.EncapsulationConflictReason, + Message: kerrors.NewAggregate(errs).Error(), + }) + return reconcile.TerminalError(kerrors.NewAggregate(errs)) + } + + return nil +} + +func (r *NetworkAttachmentReconciler) validateEncapsulationConflicts(ctx context.Context, na *overlayv1alpha1.NetworkAttachment, devices map[string]*v1alpha1.Device, vni uint64) error { + var errs []error + for _, device := range devices { + vlans := &v1alpha1.VLANList{} + if err := r.List(ctx, vlans, client.InNamespace(na.Namespace), client.MatchingFields{v1alpha1.DeviceRefIndexKey: device.Name}); err != nil { + return fmt.Errorf("list VLANs on device %q: %w", device.Name, err) + } + targetVLANs := sets.New[string]() + for i := range vlans.Items { + vlan := &vlans.Items[i] + if int32(vlan.Spec.ID) != na.Spec.Encapsulation.ID { + continue + } + targetVLANs.Insert(vlan.Name) + if !metav1.IsControlledBy(vlan, na) { + errs = append(errs, fmt.Errorf("VLAN %q already provides VLAN %d on device %q", vlan.Name, na.Spec.Encapsulation.ID, device.Name)) + } + } + evis := &v1alpha1.EVPNInstanceList{} + if err := r.List(ctx, evis, client.InNamespace(na.Namespace), client.MatchingFields{v1alpha1.DeviceRefIndexKey: device.Name}); err != nil { + return fmt.Errorf("list EVPN instances on device %q: %w", device.Name, err) + } + for i := range evis.Items { + evi := &evis.Items[i] + if metav1.IsControlledBy(evi, na) { + continue + } + if evi.Spec.VNI == int32(vni) { // #nosec G115 -- VNI validation bounds the value to int32. + errs = append(errs, fmt.Errorf("EVPN instance %q already provides VNI %d on device %q", evi.Name, vni, device.Name)) + continue + } + if evi.Spec.VLANRef != nil && targetVLANs.Has(evi.Spec.VLANRef.Name) { + errs = append(errs, fmt.Errorf("EVPN instance %q already references VLAN %q on device %q", evi.Name, evi.Spec.VLANRef.Name, device.Name)) + } + } + } + if len(errs) > 0 { + conditions.Set(na, metav1.Condition{ + Type: v1alpha1.ReadyCondition, + Status: metav1.ConditionFalse, + Reason: evpnv1alpha1.ResourceConflictReason, + Message: kerrors.NewAggregate(errs).Error(), + }) + return reconcile.TerminalError(kerrors.NewAggregate(errs)) + } + return nil +} + +func (r *NetworkAttachmentReconciler) persistInterfaceOwnership(na *overlayv1alpha1.NetworkAttachment, desiredInterfaces map[string]overlayv1alpha1.NetworkAttachmentInterfaceStatus) (changed bool) { + ownedInterfaces := make(map[string]overlayv1alpha1.NetworkAttachmentInterfaceStatus, len(na.Status.Interfaces)) + for _, status := range na.Status.Interfaces { + ownedInterfaces[status.InterfaceRef.Name] = status + } + + ownershipChanged := false + for name, desired := range desiredInterfaces { + if existing, ok := ownedInterfaces[name]; !ok || existing != desired { + ownershipChanged = true + break + } + } + if ownershipChanged { + maps.Copy(ownedInterfaces, desiredInterfaces) + na.Status.Interfaces = slices.Collect(maps.Values(ownedInterfaces)) + slices.SortFunc(na.Status.Interfaces, func(a, b overlayv1alpha1.NetworkAttachmentInterfaceStatus) int { + return cmp.Compare(a.InterfaceRef.Name, b.InterfaceRef.Name) + }) + return true + } + + return false +} + +func (r *NetworkAttachmentReconciler) reconcileEncapsulation(ctx context.Context, na *overlayv1alpha1.NetworkAttachment, devices map[string]*v1alpha1.Device, fabric *evpnv1alpha1.Fabric, vni uint64, routeTarget string) error { + for _, device := range devices { + prefix := "attachment-" + hash(na, device) + vlan := &v1alpha1.VLAN{Name: prefix + "-vlan", Namespace: na.Namespace} + if _, err := controllerutil.CreateOrPatch(ctx, r.Client, vlan, func() error { + if vlan.Labels == nil { + vlan.Labels = make(map[string]string) + } + vlan.Labels[evpnv1alpha1.NetworkLabel] = na.Spec.NetworkRef.Name + vlan.Labels[evpnv1alpha1.NetworkAttachmentLabel] = na.Name + vlan.Labels[evpnv1alpha1.FabricLabel] = fabric.Name + vlan.Spec.DeviceRef = v1alpha1.LocalObjectReference{Name: device.Name} + vlan.Spec.ID = int16(na.Spec.Encapsulation.ID) // #nosec G115 -- the API limits VLAN IDs to 1..4094. + vlan.Spec.AdminState = v1alpha1.AdminStateUp + return controllerutil.SetControllerReference(na, vlan, r.Scheme) + }); err != nil { + return fmt.Errorf("reconcile VLAN on device %q: %w", device.Name, err) + } + + evi := &v1alpha1.EVPNInstance{Name: prefix + "-evi", Namespace: na.Namespace} + if _, err := controllerutil.CreateOrPatch(ctx, r.Client, evi, func() error { + if evi.Labels == nil { + evi.Labels = make(map[string]string) + } + evi.Labels[evpnv1alpha1.NetworkLabel] = na.Spec.NetworkRef.Name + evi.Labels[evpnv1alpha1.NetworkAttachmentLabel] = na.Name + evi.Labels[evpnv1alpha1.FabricLabel] = fabric.Name + evi.Spec.DeviceRef = v1alpha1.LocalObjectReference{Name: device.Name} + evi.Spec.VNI = int32(vni) // #nosec G115 -- VNI validation bounds the value to int32. + evi.Spec.Type = v1alpha1.EVPNInstanceTypeBridged + evi.Spec.RouteDistinguisher = "Auto" + evi.Spec.RouteTargets = []v1alpha1.EVPNRouteTarget{{Value: routeTarget, Action: v1alpha1.RouteTargetActionBoth}} + evi.Spec.VLANRef = &v1alpha1.LocalObjectReference{Name: vlan.Name} + return controllerutil.SetControllerReference(na, evi, r.Scheme) + }); err != nil { + return fmt.Errorf("reconcile EVPN instance on device %q: %w", device.Name, err) + } + } + return nil +} + +func (r *NetworkAttachmentReconciler) reconcileInterfaceMembership(ctx context.Context, na *overlayv1alpha1.NetworkAttachment, desiredInterfaces map[string]overlayv1alpha1.NetworkAttachmentInterfaceStatus) error { + // Remove the allowed VLAN from owned Interfaces that are no longer selected. + for _, owned := range na.Status.Interfaces { + if _, desired := desiredInterfaces[owned.InterfaceRef.Name]; desired { + continue + } + + if err := client.IgnoreNotFound(r.patchInterface(ctx, client.ObjectKey{Namespace: na.Namespace, Name: owned.InterfaceRef.Name}, func(intf *v1alpha1.Interface) (bool, error) { + changed, err := intf.Spec.Switchport.RemoveAllowedVLAN(na.Spec.Encapsulation.ID) + if err != nil { + return false, fmt.Errorf("remove VLAN %d: %w", na.Spec.Encapsulation.ID, err) + } + return changed, nil + })); err != nil { + return err + } + } + + // Add the requested VLAN to every selected Interface. + for _, intf := range desiredInterfaces { + if err := r.patchInterface(ctx, client.ObjectKey{Namespace: na.Namespace, Name: intf.InterfaceRef.Name}, func(intf *v1alpha1.Interface) (bool, error) { + changed, err := intf.Spec.Switchport.AddAllowedVLAN(na.Spec.Encapsulation.ID) + if err != nil { + return false, fmt.Errorf("add VLAN %d: %w", na.Spec.Encapsulation.ID, err) + } + return changed, nil + }); err != nil { + return err + } + } + + na.Status.Interfaces = slices.Collect(maps.Values(desiredInterfaces)) + slices.SortFunc(na.Status.Interfaces, func(a, b overlayv1alpha1.NetworkAttachmentInterfaceStatus) int { + return cmp.Compare(a.InterfaceRef.Name, b.InterfaceRef.Name) + }) + + return nil +} + +func (r *NetworkAttachmentReconciler) deleteStaleResources(ctx context.Context, na *overlayv1alpha1.NetworkAttachment, devices map[string]*v1alpha1.Device) error { + vlanRefs := sets.New[string]() + + evis := &v1alpha1.EVPNInstanceList{} + if err := r.List(ctx, evis, client.InNamespace(na.Namespace), client.MatchingFields{controllerOwnerUIDKey: string(na.UID)}); err != nil { + return fmt.Errorf("list EVPN instances controlled by network attachment %q: %w", na.Name, err) + } + for i := range evis.Items { + evi := &evis.Items[i] + if !metav1.IsControlledBy(evi, na) { + continue + } + if _, desired := devices[evi.Spec.DeviceRef.Name]; desired { + continue + } + if evi.Spec.VLANRef != nil { + vlanRefs.Insert(evi.Spec.VLANRef.Name) + } + if evi.DeletionTimestamp.IsZero() { + if err := client.IgnoreNotFound(r.Delete(ctx, evi)); err != nil { + return fmt.Errorf("delete EVPN instance %q: %w", evi.Name, err) + } + } + } + + vlans := &v1alpha1.VLANList{} + if err := r.List(ctx, vlans, client.InNamespace(na.Namespace), client.MatchingFields{controllerOwnerUIDKey: string(na.UID)}); err != nil { + return fmt.Errorf("list VLANs controlled by network attachment %q: %w", na.Name, err) + } + for i := range vlans.Items { + vlan := &vlans.Items[i] + if !metav1.IsControlledBy(vlan, na) { + continue + } + if _, desired := devices[vlan.Spec.DeviceRef.Name]; desired { + continue + } + if vlanRefs.Has(vlan.Name) { + continue + } + if vlan.DeletionTimestamp.IsZero() { + if err := client.IgnoreNotFound(r.Delete(ctx, vlan)); err != nil { + return fmt.Errorf("delete VLAN %q: %w", vlan.Name, err) + } + } + } + + return nil +} + +func (r *NetworkAttachmentReconciler) finalize(ctx context.Context, na *overlayv1alpha1.NetworkAttachment) error { + var errs []error + for _, owned := range na.Status.Interfaces { + err := r.patchInterface(ctx, client.ObjectKey{Namespace: na.Namespace, Name: owned.InterfaceRef.Name}, func(intf *v1alpha1.Interface) (bool, error) { + changed, err := intf.Spec.Switchport.RemoveAllowedVLAN(na.Spec.Encapsulation.ID) + if err != nil { + return false, fmt.Errorf("remove VLAN %d: %w", na.Spec.Encapsulation.ID, err) + } + return changed, nil + }) + if err := client.IgnoreNotFound(err); err != nil { + errs = append(errs, err) + } + } + return kerrors.NewAggregate(errs) +} + +// patchInterface retrieves the Interface identified by key, applies the mutate function to it, and patches it if it was changed. +func (r *NetworkAttachmentReconciler) patchInterface(ctx context.Context, key client.ObjectKey, mutate func(*v1alpha1.Interface) (changed bool, err error)) error { + intf := &v1alpha1.Interface{} + if err := r.Get(ctx, key, intf); err != nil { + return fmt.Errorf("get interface %q: %w", key.Name, err) + } + orig := intf.DeepCopy() + changed, err := mutate(intf) + if err != nil { + return fmt.Errorf("mutate interface %q: %w", intf.Name, err) + } + if changed { + if err := r.Patch(ctx, intf, client.MergeFrom(orig)); err != nil { + return fmt.Errorf("patch interface %q: %w", intf.Name, err) + } + } + return nil +} + +// networkAttachmentToNetworkAttachments is a [handler.MapFunc] that enqueues +// NetworkAttachments requesting the same encapsulation on a selected Device. +func (r *NetworkAttachmentReconciler) networkAttachmentToNetworkAttachments(ctx context.Context, obj client.Object) []ctrl.Request { + na, ok := obj.(*overlayv1alpha1.NetworkAttachment) + if !ok { + panic(fmt.Sprintf("Expected a NetworkAttachment but got a %T", obj)) + } + + log := ctrl.LoggerFrom(ctx, "NetworkAttachment", klog.KObj(na)) + + selector, err := metav1.LabelSelectorAsSelector(&na.Spec.InterfaceSelector) + if err != nil { + log.Error(err, "Failed to parse interfaceSelector") + return nil + } + + interfaces := &v1alpha1.InterfaceList{} + if err := r.List( + ctx, + interfaces, + client.InNamespace(na.Namespace), + client.MatchingLabelsSelector{Selector: selector}, + ); err != nil { + log.Error(err, "Failed to list Interfaces") + return nil + } + + devices := make(map[string]struct{}) + for i := range interfaces.Items { + devices[interfaces.Items[i].Spec.DeviceRef.Name] = struct{}{} + } + + list := &overlayv1alpha1.NetworkAttachmentList{} + if err := r.List( + ctx, + list, + client.InNamespace(na.Namespace), + client.MatchingFields{networkAttachmentEncapsulationKey: na.Spec.Encapsulation.Key()}, + ); err != nil { + log.Error(err, "Failed to list NetworkAttachments") + return nil + } + + var requests []ctrl.Request + for i := range list.Items { + peer := &list.Items[i] + if peer.Name == na.Name { + continue + } + + peerSelector, err := metav1.LabelSelectorAsSelector(&peer.Spec.InterfaceSelector) + if err != nil { + log.Error(err, "Failed to parse NetworkAttachment interfaceSelector", "NetworkAttachment", klog.KObj(peer)) + continue + } + + peerInterfaces := &v1alpha1.InterfaceList{} + if err := r.List( + ctx, + peerInterfaces, + client.InNamespace(peer.Namespace), + client.MatchingLabelsSelector{Selector: peerSelector}, + ); err != nil { + log.Error(err, "Failed to list Interfaces", "NetworkAttachment", klog.KObj(peer)) + continue + } + + for j := range peerInterfaces.Items { + if _, ok := devices[peerInterfaces.Items[j].Spec.DeviceRef.Name]; !ok { + continue + } + log.V(2).Info("Enqueuing NetworkAttachment for reconciliation", "NetworkAttachment", klog.KObj(peer)) + requests = append(requests, ctrl.Request{NamespacedName: client.ObjectKeyFromObject(peer)}) + break + } + } + + return requests +} + +// networkToNetworkAttachments is a [handler.MapFunc] that enqueues +// NetworkAttachments referencing the changed Network. +func (r *NetworkAttachmentReconciler) networkToNetworkAttachments(ctx context.Context, obj client.Object) []ctrl.Request { + network, ok := obj.(*overlayv1alpha1.Network) + if !ok { + panic(fmt.Sprintf("Expected a Network but got a %T", obj)) + } + + log := ctrl.LoggerFrom(ctx, "Network", klog.KObj(network)) + + list := &overlayv1alpha1.NetworkAttachmentList{} + if err := r.List( + ctx, + list, + client.InNamespace(network.Namespace), + client.MatchingFields{networkAttachmentNetworkRefKey: network.Name}, + ); err != nil { + log.Error(err, "Failed to list NetworkAttachments") + return nil + } + + requests := make([]ctrl.Request, 0, len(list.Items)) + for i := range list.Items { + log.V(2).Info("Enqueuing NetworkAttachment for reconciliation", "NetworkAttachment", klog.KObj(&list.Items[i])) + requests = append(requests, ctrl.Request{NamespacedName: client.ObjectKeyFromObject(&list.Items[i])}) + } + + return requests +} + +// claimToNetworkAttachments is a [handler.MapFunc] that enqueues NetworkAttachments +// referencing the Network associated with a VNI Claim. +func (r *NetworkAttachmentReconciler) claimToNetworkAttachments(ctx context.Context, obj client.Object) []ctrl.Request { + claim, ok := obj.(*poolv1alpha1.Claim) + if !ok { + panic(fmt.Sprintf("Expected a Claim but got a %T", obj)) + } + + networkName := claim.Labels[evpnv1alpha1.NetworkLabel] + if networkName == "" { + return nil + } + + log := ctrl.LoggerFrom(ctx, "Claim", klog.KObj(claim)) + + list := &overlayv1alpha1.NetworkAttachmentList{} + if err := r.List( + ctx, + list, + client.InNamespace(claim.Namespace), + client.MatchingFields{networkAttachmentNetworkRefKey: networkName}, + ); err != nil { + log.Error(err, "Failed to list NetworkAttachments") + return nil + } + + requests := make([]ctrl.Request, 0, len(list.Items)) + for i := range list.Items { + log.V(2).Info("Enqueuing NetworkAttachment for reconciliation", "NetworkAttachment", klog.KObj(&list.Items[i])) + requests = append(requests, ctrl.Request{NamespacedName: client.ObjectKeyFromObject(&list.Items[i])}) + } + + return requests +} + +// interfaceToNetworkAttachments is a [handler.MapFunc] that enqueues NetworkAttachments +// when an Interface matches their selector or is recorded in their status. +func (r *NetworkAttachmentReconciler) interfaceToNetworkAttachments(ctx context.Context, obj client.Object) []ctrl.Request { + intf, ok := obj.(*v1alpha1.Interface) + if !ok { + panic(fmt.Sprintf("Expected an Interface but got a %T", obj)) + } + + log := ctrl.LoggerFrom(ctx, "Interface", klog.KObj(intf)) + list := &overlayv1alpha1.NetworkAttachmentList{} + if err := r.List(ctx, list, client.InNamespace(intf.Namespace)); err != nil { + log.Error(err, "Failed to list NetworkAttachments") + return nil + } + + requests := make([]ctrl.Request, 0, len(list.Items)) + for i := range list.Items { + na := &list.Items[i] + selector, err := metav1.LabelSelectorAsSelector(&na.Spec.InterfaceSelector) + if err != nil { + log.Error(err, "Failed to parse NetworkAttachment interfaceSelector", "NetworkAttachment", klog.KObj(na)) + continue + } + if selector.Matches(labels.Set(intf.Labels)) { + log.V(2).Info("Enqueuing NetworkAttachment for reconciliation", "NetworkAttachment", klog.KObj(na)) + requests = append(requests, ctrl.Request{NamespacedName: client.ObjectKeyFromObject(na)}) + } + } + + owned := &overlayv1alpha1.NetworkAttachmentList{} + if err := r.List( + ctx, + owned, + client.InNamespace(intf.Namespace), + client.MatchingFields{networkAttachmentInterfaceRefKey: intf.Name}, + ); err != nil { + log.Error(err, "Failed to list NetworkAttachments owning Interface") + return requests + } + for i := range owned.Items { + log.V(2).Info("Enqueuing NetworkAttachment for reconciliation", "NetworkAttachment", klog.KObj(&owned.Items[i])) + requests = append(requests, ctrl.Request{NamespacedName: client.ObjectKeyFromObject(&owned.Items[i])}) + } + + return requests +} + +// evpnInstanceToNetworkAttachments is a [handler.MapFunc] that enqueues +// the NetworkAttachment owning the VLAN referenced by an EVPNInstance. +// Attachment-owned EVPNInstances already trigger reconciliation through Owns(). +func (r *NetworkAttachmentReconciler) evpnInstanceToNetworkAttachments(ctx context.Context, obj client.Object) []ctrl.Request { + evi, ok := obj.(*v1alpha1.EVPNInstance) + if !ok { + panic(fmt.Sprintf("Expected an EVPNInstance but got a %T", obj)) + } + + log := ctrl.LoggerFrom(ctx, "EVPNInstance", klog.KObj(evi)) + + // Attachment-owned EVPNInstances already trigger reconciliation through Owns(). + if owner := metav1.GetControllerOf(evi); owner != nil && owner.Kind == "NetworkAttachment" && owner.APIVersion == overlayv1alpha1.GroupVersion.String() { + return nil + } + + if evi.Spec.VLANRef == nil { + return nil + } + + vlan := &v1alpha1.VLAN{} + if err := r.Get(ctx, client.ObjectKey{Namespace: evi.Namespace, Name: evi.Spec.VLANRef.Name}, vlan); err != nil { + if !apierrors.IsNotFound(err) { + log.Error(err, "Failed to get referenced VLAN") + } + return nil + } + + owner := metav1.GetControllerOf(vlan) + if owner == nil || owner.Kind != "NetworkAttachment" || owner.APIVersion != overlayv1alpha1.GroupVersion.String() { + return nil + } + + // Another EVPNInstance references an attachment-owned VLAN. + // Reconcile that attachment to detect the conflict or recover after deletion. + log.V(2).Info("Enqueuing NetworkAttachment for reconciliation", "name", owner.Name, "namespace", vlan.Namespace) + return []ctrl.Request{{Namespace: vlan.Namespace, Name: owner.Name}} +} + +// deviceToNetworkAttachments is a [handler.MapFunc] that enqueues NetworkAttachments +// selecting Interfaces on the changed Device. +func (r *NetworkAttachmentReconciler) deviceToNetworkAttachments(ctx context.Context, obj client.Object) []ctrl.Request { + device, ok := obj.(*v1alpha1.Device) + if !ok { + panic(fmt.Sprintf("Expected a Device but got a %T", obj)) + } + + log := ctrl.LoggerFrom(ctx, "Device", klog.KObj(device)) + + interfaces := &v1alpha1.InterfaceList{} + if err := r.List( + ctx, + interfaces, + client.InNamespace(device.Namespace), + client.MatchingFields{v1alpha1.DeviceRefIndexKey: device.Name}, + ); err != nil { + log.Error(err, "Failed to list Interfaces") + return nil + } + + var requests []ctrl.Request + for i := range interfaces.Items { + requests = append(requests, r.interfaceToNetworkAttachments(ctx, &interfaces.Items[i])...) + } + + return requests +} + +// fabricToNetworkAttachments is a [handler.MapFunc] that enqueues NetworkAttachments +// selecting Interfaces on Devices matched by the changed Fabric. +func (r *NetworkAttachmentReconciler) fabricToNetworkAttachments(ctx context.Context, obj client.Object) []ctrl.Request { + fabric, ok := obj.(*evpnv1alpha1.Fabric) + if !ok { + panic(fmt.Sprintf("Expected a Fabric but got a %T", obj)) + } + + log := ctrl.LoggerFrom(ctx, "Fabric", klog.KObj(fabric)) + + selector, err := metav1.LabelSelectorAsSelector(&fabric.Spec.DeviceSelector) + if err != nil { + log.Error(err, "Failed to parse Fabric deviceSelector") + return nil + } + + devices := &v1alpha1.DeviceList{} + if err := r.List( + ctx, + devices, + client.InNamespace(fabric.Namespace), + client.MatchingLabelsSelector{Selector: selector}, + ); err != nil { + log.Error(err, "Failed to list Devices") + return nil + } + + var requests []ctrl.Request + for i := range devices.Items { + requests = append(requests, r.deviceToNetworkAttachments(ctx, &devices.Items[i])...) + } + + return requests +} + +// hash returns a deterministic 128-bit hash of the ordered object UIDs, +// making collisions negligible without collision-recovery state. +func hash(objects ...client.Object) string { + if len(objects) == 0 { + panic("hash requires at least one object") + } + uids := make([]string, len(objects)) + for i, obj := range objects { + uids[i] = string(obj.GetUID()) + } + hash := sha256.Sum256([]byte(strings.Join(uids, "/"))) + return hex.EncodeToString(hash[:16]) +} diff --git a/internal/controller/evpn/networkattachment_controller_test.go b/internal/controller/evpn/networkattachment_controller_test.go new file mode 100644 index 000000000..5eb307ac1 --- /dev/null +++ b/internal/controller/evpn/networkattachment_controller_test.go @@ -0,0 +1,1602 @@ +// SPDX-FileCopyrightText: SAP SE or an SAP affiliate company and IronCore contributors +// SPDX-License-Identifier: Apache-2.0 + +package evpn + +import ( + "cmp" + "slices" + "strconv" + + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" + + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/intstr" + + "github.com/ironcore-dev/network-operator/api/core/v1alpha1" + evpnv1alpha1 "github.com/ironcore-dev/network-operator/api/evpn/v1alpha1" + overlayv1alpha1 "github.com/ironcore-dev/network-operator/api/overlay/v1alpha1" + poolv1alpha1 "github.com/ironcore-dev/network-operator/api/pool/v1alpha1" +) + +var _ = Describe("NetworkAttachment Controller", func() { + Context("When reconciling a resource", func() { + var ( + key client.ObjectKey + deviceKey client.ObjectKey + fabricKey client.ObjectKey + vniPoolKey client.ObjectKey + ) + + BeforeEach(func() { + net := &overlayv1alpha1.Network{ + GenerateName: "test-network-", + Namespace: metav1.NamespaceDefault, + } + Expect(k8sClient.Create(ctx, net)).To(Succeed()) + key = client.ObjectKeyFromObject(net) + + na := &overlayv1alpha1.NetworkAttachment{ + Name: net.Name, + Namespace: metav1.NamespaceDefault, + Spec: overlayv1alpha1.NetworkAttachmentSpec{ + NetworkRef: v1alpha1.LocalObjectReference{Name: net.Name}, + InterfaceSelector: metav1.LabelSelector{ + MatchLabels: map[string]string{"pod": "ap101"}, + }, + Encapsulation: overlayv1alpha1.Encapsulation{ + Type: overlayv1alpha1.EncapsulationTypeVLAN, + ID: 100, + }, + }, + } + Expect(k8sClient.Create(ctx, na)).To(Succeed()) + + vniPool := &poolv1alpha1.IndexPool{ + GenerateName: "vni-pool-", + Namespace: metav1.NamespaceDefault, + Spec: poolv1alpha1.IndexPoolSpec{ + Ranges: []v1alpha1.IndexRange{v1alpha1.MustParseIndexRange("10000..10010")}, + }, + } + Expect(k8sClient.Create(ctx, vniPool)).To(Succeed()) + vniPoolKey = client.ObjectKeyFromObject(vniPool) + + device := &v1alpha1.Device{ + GenerateName: "test-device-", + Namespace: metav1.NamespaceDefault, + Labels: map[string]string{"fabric-one": "true"}, + Spec: v1alpha1.DeviceSpec{ + Provider: "test-provider", + Endpoint: v1alpha1.Endpoint{Address: "192.0.2.1:9339"}, + }, + } + Expect(k8sClient.Create(ctx, device)).To(Succeed()) + deviceKey = client.ObjectKeyFromObject(device) + + fabric := &evpnv1alpha1.Fabric{ + GenerateName: "fabric-one-", + Namespace: metav1.NamespaceDefault, + Spec: evpnv1alpha1.FabricSpec{ + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"fabric-one": "true"}}, + Loopbacks: evpnv1alpha1.FabricLoopbacksSpec{ + IPAddressPoolRef: v1alpha1.LocalObjectReference{Name: "unused-loopback-pool"}, + }, + Underlay: evpnv1alpha1.FabricUnderlaySpec{ + Protocol: evpnv1alpha1.UnderlayProtocolOSPF, + InterfaceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + Addressing: evpnv1alpha1.FabricUnderlayAddressingSpec{Unnumbered: true}, + }, + Overlay: evpnv1alpha1.FabricOverlaySpec{ + Protocol: evpnv1alpha1.OverlayProtocolIBGP, + IBGP: &evpnv1alpha1.FabricIBGPSpec{ + ASNumber: intstr.FromInt(65000), + RouteReflectors: []evpnv1alpha1.RouteReflectorGroup{{ + Name: "unused", + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + ClientDeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + }}, + }, + }, + BUM: evpnv1alpha1.FabricBUMSpec{ + Type: evpnv1alpha1.BUMTypeMulticast, + PIM: &evpnv1alpha1.FabricPIMSpec{ + AnycastRendezvousPoints: []evpnv1alpha1.AnycastRendezvousPoint{{ + Name: "unused", + MulticastGroups: []v1alpha1.IPPrefix{v1alpha1.MustParsePrefix("224.0.0.0/4")}, + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + ClientDeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + }}, + }, + }, + VTEP: evpnv1alpha1.FabricVTEPSpec{ + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + }, + VNIPool: v1alpha1.TypedLocalObjectReference{ + APIVersion: poolv1alpha1.GroupVersion.String(), + Kind: "IndexPool", + Name: vniPool.Name, + }, + }, + } + Expect(k8sClient.Create(ctx, fabric)).To(Succeed()) + fabricKey = client.ObjectKeyFromObject(fabric) + }) + + AfterEach(func() { + // Finish Interface cleanup while the attachment's dependencies still exist. + na := &overlayv1alpha1.NetworkAttachment{Name: key.Name, Namespace: key.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, na))).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, key, &overlayv1alpha1.NetworkAttachment{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + }).Should(Succeed()) + + // Envtest does not garbage-collect attachment-owned resources. + Expect(k8sClient.DeleteAllOf(ctx, &v1alpha1.EVPNInstance{}, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + Expect(k8sClient.DeleteAllOf(ctx, &v1alpha1.VLAN{}, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + + net := &overlayv1alpha1.Network{Name: key.Name, Namespace: key.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, net))).To(Succeed()) + + // Stop Fabric reconciliation before removing Claims so they cannot be recreated. + fabric := &evpnv1alpha1.Fabric{Name: fabricKey.Name, Namespace: fabricKey.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, fabric))).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, fabricKey, &evpnv1alpha1.Fabric{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + }).Should(Succeed()) + + // Envtest has no garbage collector; Claims must finalize before their pools disappear. + Expect(k8sClient.DeleteAllOf(ctx, &poolv1alpha1.Claim{}, client.InNamespace(fabricKey.Namespace), client.MatchingLabels{evpnv1alpha1.FabricLabel: fabricKey.Name})).To(Succeed()) + Eventually(func(g Gomega) { + claims := &poolv1alpha1.ClaimList{} + g.Expect(k8sClient.List(ctx, claims, client.InNamespace(fabricKey.Namespace), client.MatchingLabels{evpnv1alpha1.FabricLabel: fabricKey.Name})).To(Succeed()) + g.Expect(claims.Items).To(BeEmpty()) + }).Should(Succeed()) + + // Claim finalization recycles its Index allocation without relying on garbage collection. + Eventually(func(g Gomega) { + indices := &poolv1alpha1.IndexList{} + g.Expect(k8sClient.List(ctx, indices, client.InNamespace(vniPoolKey.Namespace))).To(Succeed()) + g.Expect(indices.Items).NotTo(ContainElement(HaveField("Spec.PoolRef.Name", vniPoolKey.Name))) + }).Should(Succeed()) + vniPool := &poolv1alpha1.IndexPool{Name: vniPoolKey.Name, Namespace: vniPoolKey.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, vniPool))).To(Succeed()) + + device := &v1alpha1.Device{Name: deviceKey.Name, Namespace: deviceKey.Namespace} + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, device))).To(Succeed()) + }) + + It("successfully realizes a NetworkAttachment", func() { + By("Reporting no matching Interfaces before any Interface is created") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.NoMatchingInterfacesReason), + ))) + }).Should(Succeed()) + + By("Creating an unselected Physical member for the Aggregate Interface") + member := &v1alpha1.Interface{ + GenerateName: "aggregate-member-", + Namespace: key.Namespace, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/2", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + }, + } + Expect(k8sClient.Create(ctx, member)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, member))).To(Succeed()) + }) + + By("Creating selected Physical and Aggregate trunks on the same Device") + interfaces := []*v1alpha1.Interface{ + { + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{Mode: v1alpha1.SwitchportModeTrunk}, + }, + }, + { + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Port-Channel1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypeAggregate, + Aggregation: &v1alpha1.Aggregation{ + MemberInterfaceRefs: []v1alpha1.LocalObjectReference{{Name: member.Name}}, + ControlProtocol: v1alpha1.ControlProtocol{Mode: v1alpha1.LACPModeActive}, + }, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + AllowedVlans: []v1alpha1.IndexRange{{Start: 10, End: 20}, {Start: 200, End: 200}}, + }, + }, + }, + } + for _, intf := range interfaces { + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + } + DeferCleanup(func() { + for _, intf := range interfaces { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + } + }) + + fabric := &evpnv1alpha1.Fabric{} + Expect(k8sClient.Get(ctx, fabricKey, fabric)).To(Succeed()) + + na := &overlayv1alpha1.NetworkAttachment{} + Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + + By("Allocating one VNI Claim owned by the Fabric") + var allocatedVNI string + Eventually(func(g Gomega) { + claims := &poolv1alpha1.ClaimList{} + g.Expect(k8sClient.List(ctx, claims, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkLabel: key.Name})).To(Succeed()) + g.Expect(claims.Items).To(HaveLen(1)) + claim := &claims.Items[0] + g.Expect(claim.Spec.PoolRef).To(Equal(fabric.Spec.VNIPool)) + g.Expect(claim.Labels).To(HaveKeyWithValue(evpnv1alpha1.FabricLabel, fabric.Name)) + g.Expect(metav1.IsControlledBy(claim, fabric)).To(BeTrue()) + g.Expect(claim.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", poolv1alpha1.AllocatedCondition), + HaveField("Status", metav1.ConditionTrue), + ))) + g.Expect(claim.Status.Value).To(Equal("10000")) + g.Expect(claim.Status.AllocationRef).NotTo(BeNil()) + g.Expect(claim.Status.AllocationRef.Kind).To(Equal("Index")) + allocatedVNI = claim.Status.Value + }).Should(Succeed()) + + By("Reporting the Network allocation as Ready") + Eventually(func(g Gomega) { + net := &overlayv1alpha1.Network{} + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + g.Expect(net.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + }).Should(Succeed()) + + By("Creating one VLAN and bridged EVPNInstance for the selected Device") + Eventually(func(g Gomega) { + vlans := &v1alpha1.VLANList{} + g.Expect(k8sManager.GetClient().List(ctx, vlans, client.InNamespace(key.Namespace), client.MatchingFields{controllerOwnerUIDKey: string(na.UID)})).To(Succeed()) + g.Expect(vlans.Items).To(HaveLen(1)) + vlan := &vlans.Items[0] + g.Expect(vlan.Spec.DeviceRef.Name).To(Equal(deviceKey.Name)) + g.Expect(vlan.Spec.ID).To(Equal(int16(100))) + g.Expect(vlan.Spec.AdminState).To(Equal(v1alpha1.AdminStateUp)) + g.Expect(metav1.IsControlledBy(vlan, na)).To(BeTrue()) + g.Expect(vlan.Labels).To(SatisfyAll( + HaveKeyWithValue(evpnv1alpha1.NetworkLabel, key.Name), + HaveKeyWithValue(evpnv1alpha1.NetworkAttachmentLabel, na.Name), + HaveKeyWithValue(evpnv1alpha1.FabricLabel, fabric.Name), + )) + + evis := &v1alpha1.EVPNInstanceList{} + g.Expect(k8sManager.GetClient().List(ctx, evis, client.InNamespace(key.Namespace), client.MatchingFields{controllerOwnerUIDKey: string(na.UID)})).To(Succeed()) + g.Expect(evis.Items).To(HaveLen(1)) + evi := &evis.Items[0] + g.Expect(evi.Spec.DeviceRef.Name).To(Equal(deviceKey.Name)) + g.Expect(evi.Spec.VNI).To(Equal(int32(10000))) + g.Expect(strconv.FormatInt(int64(evi.Spec.VNI), 10)).To(Equal(allocatedVNI)) + g.Expect(evi.Spec.Type).To(Equal(v1alpha1.EVPNInstanceTypeBridged)) + g.Expect(evi.Spec.RouteDistinguisher).To(Equal("Auto")) + g.Expect(evi.Spec.RouteTargets).To(Equal([]v1alpha1.EVPNRouteTarget{{Value: "65000:268445456", Action: v1alpha1.RouteTargetActionBoth}})) + g.Expect(evi.Spec.VLANRef).To(Equal(&v1alpha1.LocalObjectReference{Name: vlan.Name})) + g.Expect(metav1.IsControlledBy(evi, na)).To(BeTrue()) + g.Expect(evi.Labels).To(SatisfyAll( + HaveKeyWithValue(evpnv1alpha1.NetworkLabel, key.Name), + HaveKeyWithValue(evpnv1alpha1.NetworkAttachmentLabel, na.Name), + HaveKeyWithValue(evpnv1alpha1.FabricLabel, fabric.Name), + )) + }).Should(Succeed()) + + By("Adding VLAN membership while preserving unrelated allowed VLANs") + Eventually(func(g Gomega) { + first := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(interfaces[0]), first)).To(Succeed()) + g.Expect(first.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 100, End: 100}})) + second := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(interfaces[1]), second)).To(Succeed()) + g.Expect(second.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 10, End: 20}, {Start: 100, End: 100}, {Start: 200, End: 200}})) + }).Should(Succeed()) + + expectedStatus := []overlayv1alpha1.NetworkAttachmentInterfaceStatus{ + {DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, InterfaceRef: v1alpha1.LocalObjectReference{Name: interfaces[0].Name}}, + {DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, InterfaceRef: v1alpha1.LocalObjectReference{Name: interfaces[1].Name}}, + } + slices.SortFunc(expectedStatus, func(a, b overlayv1alpha1.NetworkAttachmentInterfaceStatus) int { + return cmp.Compare(a.InterfaceRef.Name, b.InterfaceRef.Name) + }) + By("Recording ownership and forwarding context and reporting Ready") + Eventually(func(g Gomega) { + current := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, current)).To(Succeed()) + g.Expect(controllerutil.ContainsFinalizer(current, evpnv1alpha1.FinalizerName)).To(BeTrue()) + g.Expect(current.Status.Interfaces).To(Equal(expectedStatus)) + g.Expect(current.Status.ForwardingContextRef).To(Equal(&v1alpha1.TypedLocalObjectReference{ + APIVersion: evpnv1alpha1.GroupVersion.String(), + Kind: "Fabric", + Name: fabric.Name, + })) + g.Expect(current.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + HaveField("ObservedGeneration", current.Generation), + ))) + }).Should(Succeed()) + }) + + It("shares the Network allocation between attachments", func() { + By("Creating an unresolved attachment that must not block allocation") + unresolved := &overlayv1alpha1.NetworkAttachment{ + GenerateName: "unresolved-attachment-", + Namespace: key.Namespace, + Spec: overlayv1alpha1.NetworkAttachmentSpec{ + NetworkRef: v1alpha1.LocalObjectReference{Name: key.Name}, + InterfaceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + Encapsulation: overlayv1alpha1.Encapsulation{Type: overlayv1alpha1.EncapsulationTypeVLAN, ID: 102}, + }, + } + Expect(k8sClient.Create(ctx, unresolved)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, unresolved))).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, client.ObjectKeyFromObject(unresolved), &overlayv1alpha1.NetworkAttachment{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + }).Should(Succeed()) + }) + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(unresolved), na)).To(Succeed()) + g.Expect(na.Status.ForwardingContextRef).To(BeNil()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.NoMatchingInterfacesReason), + ))) + }).Should(Succeed()) + + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{Mode: v1alpha1.SwitchportModeTrunk}, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Waiting for the first attachment to bind the Network") + Eventually(func(g Gomega) { + net := &overlayv1alpha1.Network{} + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + g.Expect(net.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + }).Should(Succeed()) + claims := &poolv1alpha1.ClaimList{} + Expect(k8sClient.List(ctx, claims, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkLabel: key.Name})).To(Succeed()) + Expect(claims.Items).To(HaveLen(1)) + claim := claims.Items[0] + + By("Adding another attachment on a second Device in the same Fabric") + device := &v1alpha1.Device{} + Expect(k8sClient.Get(ctx, deviceKey, device)).To(Succeed()) + otherDevice := &v1alpha1.Device{ + GenerateName: "shared-device-", + Namespace: key.Namespace, + Labels: device.Labels, + Spec: device.Spec, + } + Expect(k8sClient.Create(ctx, otherDevice)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, otherDevice))).To(Succeed()) + }) + otherInterface := &v1alpha1.Interface{ + GenerateName: "shared-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap102"}, + Spec: intf.Spec, + } + otherInterface.Spec.DeviceRef.Name = otherDevice.Name + Expect(k8sClient.Create(ctx, otherInterface)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, otherInterface))).To(Succeed()) + }) + other := &overlayv1alpha1.NetworkAttachment{ + GenerateName: "shared-attachment-", + Namespace: key.Namespace, + Spec: overlayv1alpha1.NetworkAttachmentSpec{ + NetworkRef: v1alpha1.LocalObjectReference{Name: key.Name}, + InterfaceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"pod": "ap102"}}, + Encapsulation: overlayv1alpha1.Encapsulation{Type: overlayv1alpha1.EncapsulationTypeVLAN, ID: 101}, + }, + } + Expect(k8sClient.Create(ctx, other)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, other))).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, client.ObjectKeyFromObject(other), &overlayv1alpha1.NetworkAttachment{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + }).Should(Succeed()) + Expect(k8sClient.DeleteAllOf(ctx, &v1alpha1.EVPNInstance{}, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: other.Name})).To(Succeed()) + Expect(k8sClient.DeleteAllOf(ctx, &v1alpha1.VLAN{}, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: other.Name})).To(Succeed()) + }) + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(other), na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + g.Expect(k8sClient.List(ctx, claims, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkLabel: key.Name})).To(Succeed()) + g.Expect(claims.Items).To(HaveLen(1)) + g.Expect(claims.Items[0].UID).To(Equal(claim.UID)) + g.Expect(claims.Items[0].Status.Value).To(Equal(claim.Status.Value)) + evis := &v1alpha1.EVPNInstanceList{} + g.Expect(k8sClient.List(ctx, evis, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: other.Name})).To(Succeed()) + g.Expect(evis.Items).To(HaveLen(1)) + g.Expect(strconv.FormatInt(int64(evis.Items[0].Spec.VNI), 10)).To(Equal(claim.Status.Value)) + }).Should(Succeed()) + }) + + It("rejects unsupported selected Interface types", func() { + By("Creating a matching Loopback Interface") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-loopback-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Loopback1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypeLoopback, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Reporting the unsupported type without modifying the Interface") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.InvalidInterfaceReason), + ))) + + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport).To(BeNil()) + }).Should(Succeed()) + }) + + It("recovers when a selected Interface becomes an Exact trunk", func() { + By("Creating a matching Physical Interface without switchport configuration") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Reporting the missing switchport configuration") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.InvalidInterfaceReason), + ))) + }).Should(Succeed()) + + By("Configuring the Interface as an Exact trunk") + current := &v1alpha1.Interface{} + Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + current.Spec.Switchport = &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + } + Expect(k8sClient.Update(ctx, current)).To(Succeed()) + + By("Recovering through the Interface update watch") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + g.Expect(na.Status.Interfaces).To(Equal([]overlayv1alpha1.NetworkAttachmentInterfaceStatus{{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + InterfaceRef: v1alpha1.LocalObjectReference{Name: intf.Name}, + }})) + + intf := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(current), intf)).To(Succeed()) + g.Expect(intf.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 100, End: 100}})) + }).Should(Succeed()) + }) + + It("rejects selected Access switchports", func() { + By("Creating a matching Physical Interface in Access mode") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeAccess, + AccessVlan: 100, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Rejecting Access mode without changing the switchport configuration") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.InvalidInterfaceReason), + ))) + + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport).To(Equal(intf.Spec.Switchport)) + }).Should(Succeed()) + }) + + It("rejects selected trunks with unmanaged allowed VLANs", func() { + By("Creating a matching Physical trunk with unmanaged allowed VLANs") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeUnmanaged, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Rejecting Unmanaged mode without changing the switchport configuration") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.InvalidInterfaceReason), + ))) + + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport).To(Equal(intf.Spec.Switchport)) + }).Should(Succeed()) + }) + + It("recovers when a referenced Device becomes available", func() { + By("Creating a matching Interface referencing a missing Device") + deviceName := key.Name + "-device" + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceName}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Reporting the unresolved Device reference") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.DeviceResolutionFailedReason), + ))) + }).Should(Succeed()) + + By("Creating the referenced Device with labels matching the Fabric") + device := &v1alpha1.Device{ + Name: deviceName, + Namespace: key.Namespace, + Labels: map[string]string{"fabric-one": "true"}, + Spec: v1alpha1.DeviceSpec{ + Provider: "test-provider", + Endpoint: v1alpha1.Endpoint{Address: "192.0.2.2:9339"}, + }, + } + Expect(k8sClient.Create(ctx, device)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, device))).To(Succeed()) + }) + + By("Recovering through the Device creation watch") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + g.Expect(na.Status.Interfaces).To(Equal([]overlayv1alpha1.NetworkAttachmentInterfaceStatus{{ + DeviceRef: v1alpha1.LocalObjectReference{Name: device.Name}, + InterfaceRef: v1alpha1.LocalObjectReference{Name: intf.Name}, + }})) + + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 100, End: 100}})) + }).Should(Succeed()) + }) + + It("recovers when Device labels match a Fabric", func() { + By("Removing the Device's Fabric membership label") + Eventually(func(g Gomega) { + device := &v1alpha1.Device{} + g.Expect(k8sClient.Get(ctx, deviceKey, device)).To(Succeed()) + delete(device.Labels, "fabric-one") + g.Expect(k8sClient.Update(ctx, device)).To(Succeed()) + }).Should(Succeed()) + + By("Creating a matching Physical Exact trunk Interface") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Reporting that the Device does not resolve to a Fabric") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.FabricResolutionFailedReason), + ))) + }).Should(Succeed()) + + By("Restoring the Device's Fabric membership label") + Eventually(func(g Gomega) { + device := &v1alpha1.Device{} + g.Expect(k8sClient.Get(ctx, deviceKey, device)).To(Succeed()) + if device.Labels == nil { + device.Labels = make(map[string]string) + } + device.Labels["fabric-one"] = "true" + g.Expect(k8sClient.Update(ctx, device)).To(Succeed()) + }).Should(Succeed()) + + By("Recovering through the Device label-change watch") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + g.Expect(na.Status.ForwardingContextRef).To(Equal(&v1alpha1.TypedLocalObjectReference{ + APIVersion: evpnv1alpha1.GroupVersion.String(), + Kind: "Fabric", + Name: fabricKey.Name, + })) + + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 100, End: 100}})) + }).Should(Succeed()) + }) + + It("rejects Devices selected by multiple Fabrics", func() { + By("Creating another Fabric selecting the shared Device") + additionalFabric := &evpnv1alpha1.Fabric{ + GenerateName: "additional-fabric-", + Namespace: key.Namespace, + Spec: evpnv1alpha1.FabricSpec{ + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"fabric-one": "true"}}, + Loopbacks: evpnv1alpha1.FabricLoopbacksSpec{ + IPAddressPoolRef: v1alpha1.LocalObjectReference{Name: "unused-loopback-pool"}, + }, + Underlay: evpnv1alpha1.FabricUnderlaySpec{ + Protocol: evpnv1alpha1.UnderlayProtocolOSPF, + InterfaceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + Addressing: evpnv1alpha1.FabricUnderlayAddressingSpec{Unnumbered: true}, + }, + Overlay: evpnv1alpha1.FabricOverlaySpec{ + Protocol: evpnv1alpha1.OverlayProtocolIBGP, + IBGP: &evpnv1alpha1.FabricIBGPSpec{ + ASNumber: intstr.FromInt(65000), + RouteReflectors: []evpnv1alpha1.RouteReflectorGroup{{ + Name: "unused", + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + ClientDeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + }}, + }, + }, + BUM: evpnv1alpha1.FabricBUMSpec{ + Type: evpnv1alpha1.BUMTypeMulticast, + PIM: &evpnv1alpha1.FabricPIMSpec{ + AnycastRendezvousPoints: []evpnv1alpha1.AnycastRendezvousPoint{{ + Name: "unused", + MulticastGroups: []v1alpha1.IPPrefix{v1alpha1.MustParsePrefix("224.0.0.0/4")}, + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + ClientDeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + }}, + }, + }, + VTEP: evpnv1alpha1.FabricVTEPSpec{ + DeviceSelector: metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}}, + }, + VNIPool: v1alpha1.TypedLocalObjectReference{ + APIVersion: poolv1alpha1.GroupVersion.String(), + Kind: "IndexPool", + Name: vniPoolKey.Name, + }, + }, + } + Expect(k8sClient.Create(ctx, additionalFabric)).To(Succeed()) + additionalFabricKey := client.ObjectKeyFromObject(additionalFabric) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, additionalFabric))).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, additionalFabricKey, &evpnv1alpha1.Fabric{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + }).Should(Succeed()) + Expect(k8sClient.DeleteAllOf(ctx, &poolv1alpha1.Claim{}, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.FabricLabel: additionalFabricKey.Name})).To(Succeed()) + Eventually(func(g Gomega) { + claims := &poolv1alpha1.ClaimList{} + g.Expect(k8sClient.List(ctx, claims, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.FabricLabel: additionalFabricKey.Name})).To(Succeed()) + g.Expect(claims.Items).To(BeEmpty()) + }).Should(Succeed()) + }) + + By("Creating a matching Physical Exact trunk Interface") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Reporting ambiguous Fabric membership") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.FabricResolutionFailedReason), + ))) + }).Should(Succeed()) + + By("Deleting the additional Fabric to restore unambiguous membership") + Expect(k8sClient.Delete(ctx, additionalFabric)).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, additionalFabricKey, &evpnv1alpha1.Fabric{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + }).Should(Succeed()) + + By("Recovering through the Fabric deletion watch") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + g.Expect(na.Status.ForwardingContextRef).To(Equal(&v1alpha1.TypedLocalObjectReference{ + APIVersion: evpnv1alpha1.GroupVersion.String(), + Kind: "Fabric", + Name: fabricKey.Name, + })) + }).Should(Succeed()) + }) + + It("rejects allocations outside the supported VNI range", func() { + By("Configuring the IndexPool to allocate a reserved VNI value") + Eventually(func(g Gomega) { + pool := &poolv1alpha1.IndexPool{} + g.Expect(k8sClient.Get(ctx, vniPoolKey, pool)).To(Succeed()) + // The EVPNInstance API supports VNIs 1..16777214, excluding this value. + pool.Spec.Ranges = []v1alpha1.IndexRange{{Start: 16777215, End: 16777215}} + g.Expect(k8sClient.Update(ctx, pool)).To(Succeed()) + }).Should(Succeed()) + + By("Creating a matching Physical Exact trunk Interface") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Waiting for the Claim controller to allocate the configured value") + Eventually(func(g Gomega) { + claims := &poolv1alpha1.ClaimList{} + g.Expect(k8sClient.List(ctx, claims, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkLabel: key.Name})).To(Succeed()) + g.Expect(claims.Items).To(HaveLen(1)) + g.Expect(claims.Items[0].Status.Value).To(Equal("16777215")) + g.Expect(claims.Items[0].Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", poolv1alpha1.AllocatedCondition), + HaveField("Status", metav1.ConditionTrue), + ))) + }).Should(Succeed()) + + By("Rejecting the allocation as an invalid VNI") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.InvalidVNIReason), + ))) + }).Should(Succeed()) + }) + + It("rejects four-octet Fabric AS numbers", func() { + By("Configuring the Fabric with a four-octet ASN") + Eventually(func(g Gomega) { + fabric := &evpnv1alpha1.Fabric{} + g.Expect(k8sClient.Get(ctx, fabricKey, fabric)).To(Succeed()) + // RFC 8365 VNI-based route-target auto-derivation requires a two-octet ASN. + fabric.Spec.Overlay.IBGP.ASNumber = intstr.FromString("65536") + g.Expect(k8sClient.Update(ctx, fabric)).To(Succeed()) + }).Should(Succeed()) + + By("Creating a matching Physical Exact trunk Interface") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Reporting the unsupported ASN") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.UnsupportedASNumberReason), + ))) + }).Should(Succeed()) + }) + + It("cleans up when the Network starts deletion and recovers after recreation", func() { + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + AllowedVlans: []v1alpha1.IndexRange{{Start: 10, End: 20}}, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Waiting for realization and recording the original resource identities") + net := &overlayv1alpha1.Network{} + na := &overlayv1alpha1.NetworkAttachment{} + Eventually(func(g Gomega) { + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + }).Should(Succeed()) + Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + networkUID := net.UID + attachmentUID := na.UID + claims := &poolv1alpha1.ClaimList{} + Expect(k8sClient.List(ctx, claims, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkLabel: key.Name})).To(Succeed()) + Expect(claims.Items).To(HaveLen(1)) + claim := claims.Items[0] + evis := &v1alpha1.EVPNInstanceList{} + Expect(k8sClient.List(ctx, evis, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + Expect(evis.Items).To(HaveLen(1)) + eviUID := evis.Items[0].UID + + By("Holding the Network in termination while its deletion update triggers cleanup") + Eventually(func(g Gomega) { + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + controllerutil.AddFinalizer(net, "test.example.com/hold-deletion") + g.Expect(k8sClient.Update(ctx, net)).To(Succeed()) + }).Should(Succeed()) + DeferCleanup(func() { + current := &overlayv1alpha1.Network{} + err := k8sClient.Get(ctx, key, current) + if apierrors.IsNotFound(err) { + return + } + Expect(err).NotTo(HaveOccurred()) + if controllerutil.RemoveFinalizer(current, "test.example.com/hold-deletion") { + Expect(k8sClient.Update(ctx, current)).To(Succeed()) + } + }) + Expect(k8sClient.Delete(ctx, net)).To(Succeed()) + + Eventually(func(g Gomega) { + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + g.Expect(net.DeletionTimestamp.IsZero()).To(BeFalse()) + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.UID).To(Equal(attachmentUID)) + g.Expect(na.DeletionTimestamp.IsZero()).To(BeTrue()) + g.Expect(na.Status.Interfaces).To(BeEmpty()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.NetworkNotFoundReason), + ))) + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 10, End: 20}})) + g.Expect(k8sClient.List(ctx, evis, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + g.Expect(evis.Items).To(BeEmpty()) + vlans := &v1alpha1.VLANList{} + g.Expect(k8sClient.List(ctx, vlans, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + g.Expect(vlans.Items).To(BeEmpty()) + }).Should(Succeed()) + + By("Releasing the allocation while keeping the Fabric and attachment") + Eventually(func(g Gomega) { + g.Expect(apierrors.IsNotFound(k8sClient.Get(ctx, client.ObjectKeyFromObject(&claim), &poolv1alpha1.Claim{}))).To(BeTrue()) + g.Expect(k8sClient.Get(ctx, fabricKey, &evpnv1alpha1.Fabric{})).To(Succeed()) + indices := &poolv1alpha1.IndexList{} + g.Expect(k8sClient.List(ctx, indices, client.InNamespace(vniPoolKey.Namespace))).To(Succeed()) + g.Expect(indices.Items).NotTo(ContainElement(HaveField("Spec.PoolRef.Name", vniPoolKey.Name))) + }).Should(Succeed()) + + By("Completing Network deletion without deleting the attachment") + Eventually(func(g Gomega) { + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + controllerutil.RemoveFinalizer(net, "test.example.com/hold-deletion") + g.Expect(k8sClient.Update(ctx, net)).To(Succeed()) + }).Should(Succeed()) + Eventually(func(g Gomega) { + g.Expect(apierrors.IsNotFound(k8sClient.Get(ctx, key, &overlayv1alpha1.Network{}))).To(BeTrue()) + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.NetworkNotFoundReason), + ))) + }).Should(Succeed()) + + By("Recreating the Network and realizing the existing attachment with a fresh EVI") + net = &overlayv1alpha1.Network{Name: key.Name, Namespace: key.Namespace} + Expect(k8sClient.Create(ctx, net)).To(Succeed()) + Expect(net.UID).NotTo(Equal(networkUID)) + Eventually(func(g Gomega) { + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.UID).To(Equal(attachmentUID)) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 10, End: 20}, {Start: 100, End: 100}})) + allocated := &poolv1alpha1.Claim{} + g.Expect(k8sClient.Get(ctx, client.ObjectKey{Namespace: key.Namespace, Name: "vni-" + hash(net)}, allocated)).To(Succeed()) + g.Expect(allocated.UID).NotTo(Equal(claim.UID)) + g.Expect(k8sClient.List(ctx, evis, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + g.Expect(evis.Items).To(HaveLen(1)) + g.Expect(evis.Items[0].UID).NotTo(Equal(eviUID)) + g.Expect(strconv.FormatInt(int64(evis.Items[0].Spec.VNI), 10)).To(Equal(allocated.Status.Value)) + }).Should(Succeed()) + }) + + It("reports a missing referenced Network", func() { + By("Removing the original attachment before deleting its Network") + na := &overlayv1alpha1.NetworkAttachment{} + Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + spec := na.Spec + Expect(k8sClient.Delete(ctx, na)).To(Succeed()) + Eventually(func(g Gomega) { + g.Expect(apierrors.IsNotFound(k8sClient.Get(ctx, key, &overlayv1alpha1.NetworkAttachment{}))).To(BeTrue()) + }).Should(Succeed()) + By("Deleting the referenced Network before creating an Interface") + network := &overlayv1alpha1.Network{Name: key.Name, Namespace: key.Namespace} + Expect(k8sClient.Delete(ctx, network)).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, key, &overlayv1alpha1.Network{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + }).Should(Succeed()) + na = &overlayv1alpha1.NetworkAttachment{Name: key.Name, Namespace: key.Namespace, Spec: spec} + Expect(k8sClient.Create(ctx, na)).To(Succeed()) + + By("Creating a matching Physical Exact trunk Interface") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Reporting the unresolved Network reference") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.NetworkNotFoundReason), + ))) + }).Should(Succeed()) + }) + + It("does not adopt an existing VLAN on the selected Device", func() { + By("Creating an unowned VLAN with the requested ID") + vlan := &v1alpha1.VLAN{ + GenerateName: "existing-vlan-", + Namespace: key.Namespace, + Spec: v1alpha1.VLANSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + ID: 100, + Name: "existing-vlan", + AdminState: v1alpha1.AdminStateUp, + }, + } + Expect(k8sClient.Create(ctx, vlan)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, vlan))).To(Succeed()) + }) + + By("Creating a matching Physical Exact trunk Interface") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Reporting the conflict without adopting, changing, or deleting the VLAN") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.ResourceConflictReason), + ))) + + current := &v1alpha1.VLAN{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(vlan), current)).To(Succeed()) + g.Expect(metav1.GetControllerOf(current)).To(BeNil()) + g.Expect(current.Spec).To(Equal(vlan.Spec)) + g.Expect(current.DeletionTimestamp.IsZero()).To(BeTrue()) + }).Should(Succeed()) + }) + + It("recovers after a competing attachment is deleted", func() { + By("Creating another Network and attachment requesting VLAN 100 on the same Device") + network := &overlayv1alpha1.Network{ + GenerateName: "competing-network-", + Namespace: key.Namespace, + } + Expect(k8sClient.Create(ctx, network)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, network))).To(Succeed()) + }) + + other := &overlayv1alpha1.NetworkAttachment{ + GenerateName: "competing-attachment-", + Namespace: key.Namespace, + Spec: overlayv1alpha1.NetworkAttachmentSpec{ + NetworkRef: v1alpha1.LocalObjectReference{Name: network.Name}, + InterfaceSelector: metav1.LabelSelector{ + MatchLabels: map[string]string{"pod": "ap102"}, + }, + Encapsulation: overlayv1alpha1.Encapsulation{ + Type: overlayv1alpha1.EncapsulationTypeVLAN, + ID: 100, + }, + }, + } + Expect(k8sClient.Create(ctx, other)).To(Succeed()) + otherKey := client.ObjectKeyFromObject(other) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, other))).To(Succeed()) + }) + + By("Creating separately selected Exact trunk Interfaces on the shared Device") + interfaces := []*v1alpha1.Interface{ + { + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + }, + { + GenerateName: "competing-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap102"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/2", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + }, + } + for _, intf := range interfaces { + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + } + DeferCleanup(func() { + for _, intf := range interfaces { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + } + }) + + By("Reporting the encapsulation conflict on both attachments") + Eventually(func(g Gomega) { + for _, attachmentKey := range []client.ObjectKey{key, otherKey} { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, attachmentKey, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.EncapsulationConflictReason), + ))) + } + }).Should(Succeed()) + + By("Deleting the competing attachment") + Expect(k8sClient.Delete(ctx, other)).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, otherKey, &overlayv1alpha1.NetworkAttachment{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + }).Should(Succeed()) + + By("Recovering through the peer deletion watch") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + + intf := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(interfaces[0]), intf)).To(Succeed()) + g.Expect(intf.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 100, End: 100}})) + }).Should(Succeed()) + }) + + It("moves VLAN membership when the Interface selector changes", func() { + By("Creating the initially selected Interface and a replacement on the same Device") + interfaces := []*v1alpha1.Interface{ + { + GenerateName: "initial-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + }, + { + GenerateName: "replacement-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap102"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/2", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + }, + } + for _, intf := range interfaces { + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + } + DeferCleanup(func() { + for _, intf := range interfaces { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + } + }) + + By("Waiting for the initial Interface membership to be realized and recorded") + Eventually(func(g Gomega) { + intf := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(interfaces[0]), intf)).To(Succeed()) + g.Expect(intf.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 100, End: 100}})) + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Interfaces).To(Equal([]overlayv1alpha1.NetworkAttachmentInterfaceStatus{{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + InterfaceRef: v1alpha1.LocalObjectReference{Name: interfaces[0].Name}, + }})) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + }).Should(Succeed()) + + By("Changing the attachment selector to the replacement Interface") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + na.Spec.InterfaceSelector = metav1.LabelSelector{MatchLabels: map[string]string{"pod": "ap102"}} + g.Expect(k8sClient.Update(ctx, na)).To(Succeed()) + }).Should(Succeed()) + + By("Cleaning the old membership and recording only the replacement") + Eventually(func(g Gomega) { + initial := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(interfaces[0]), initial)).To(Succeed()) + g.Expect(initial.Spec.Switchport.AllowedVlans).To(BeNil()) + replacement := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(interfaces[1]), replacement)).To(Succeed()) + g.Expect(replacement.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 100, End: 100}})) + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Interfaces).To(Equal([]overlayv1alpha1.NetworkAttachmentInterfaceStatus{{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + InterfaceRef: v1alpha1.LocalObjectReference{Name: interfaces[1].Name}, + }})) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + }).Should(Succeed()) + }) + + It("cleans up realization when the Interface selector matches nothing", func() { + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + AllowedVlans: []v1alpha1.IndexRange{{Start: 10, End: 20}}, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Waiting for Interface membership and device resources to be realized") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 10, End: 20}, {Start: 100, End: 100}})) + vlans := &v1alpha1.VLANList{} + g.Expect(k8sClient.List(ctx, vlans, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + g.Expect(vlans.Items).To(HaveLen(1)) + evis := &v1alpha1.EVPNInstanceList{} + g.Expect(k8sClient.List(ctx, evis, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + g.Expect(evis.Items).To(HaveLen(1)) + }).Should(Succeed()) + + By("Changing the selector to match no Interfaces") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + na.Spec.InterfaceSelector = metav1.LabelSelector{MatchLabels: map[string]string{"never": "match"}} + g.Expect(k8sClient.Update(ctx, na)).To(Succeed()) + }).Should(Succeed()) + + By("Removing only owned membership and deleting EVIs before VLANs") + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.DeletionTimestamp.IsZero()).To(BeTrue()) + g.Expect(na.Status.Interfaces).To(BeEmpty()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionFalse), + HaveField("Reason", evpnv1alpha1.NoMatchingInterfacesReason), + ))) + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 10, End: 20}})) + evis := &v1alpha1.EVPNInstanceList{} + g.Expect(k8sClient.List(ctx, evis, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + g.Expect(evis.Items).To(BeEmpty()) + vlans := &v1alpha1.VLANList{} + g.Expect(k8sClient.List(ctx, vlans, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkAttachmentLabel: key.Name})).To(Succeed()) + g.Expect(vlans.Items).To(BeEmpty()) + }).Should(Succeed()) + }) + + It("removes Interface VLAN membership when the attachment is deleted", func() { + By("Creating a matching Physical Exact trunk Interface") + intf := &v1alpha1.Interface{ + GenerateName: "attachment-interface-", + Namespace: key.Namespace, + Labels: map[string]string{"pod": "ap101"}, + Spec: v1alpha1.InterfaceSpec{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + Name: "Ethernet1/1", + AdminState: v1alpha1.AdminStateUp, + Type: v1alpha1.InterfaceTypePhysical, + Switchport: &v1alpha1.Switchport{ + Mode: v1alpha1.SwitchportModeTrunk, + AllowedVlansMode: v1alpha1.AllowedVlansModeExact, + }, + }, + } + Expect(k8sClient.Create(ctx, intf)).To(Succeed()) + DeferCleanup(func() { + Expect(client.IgnoreNotFound(k8sClient.Delete(ctx, intf))).To(Succeed()) + }) + + By("Waiting for successful realization and recording the retained VNI Claim") + var claimKey client.ObjectKey + Eventually(func(g Gomega) { + na := &overlayv1alpha1.NetworkAttachment{} + g.Expect(k8sClient.Get(ctx, key, na)).To(Succeed()) + g.Expect(na.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + g.Expect(na.Status.Interfaces).To(Equal([]overlayv1alpha1.NetworkAttachmentInterfaceStatus{{ + DeviceRef: v1alpha1.LocalObjectReference{Name: deviceKey.Name}, + InterfaceRef: v1alpha1.LocalObjectReference{Name: intf.Name}, + }})) + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport.AllowedVlans).To(Equal([]v1alpha1.IndexRange{{Start: 100, End: 100}})) + claims := &poolv1alpha1.ClaimList{} + g.Expect(k8sClient.List(ctx, claims, client.InNamespace(key.Namespace), client.MatchingLabels{evpnv1alpha1.NetworkLabel: key.Name})).To(Succeed()) + g.Expect(claims.Items).To(HaveLen(1)) + g.Expect(claims.Items[0].Status.Value).NotTo(BeEmpty()) + claimKey = client.ObjectKeyFromObject(&claims.Items[0]) + }).Should(Succeed()) + + By("Deleting the attachment and waiting for finalizer cleanup") + na := &overlayv1alpha1.NetworkAttachment{Name: key.Name, Namespace: key.Namespace} + Expect(k8sClient.Delete(ctx, na)).To(Succeed()) + Eventually(func(g Gomega) { + err := k8sClient.Get(ctx, key, &overlayv1alpha1.NetworkAttachment{}) + g.Expect(apierrors.IsNotFound(err)).To(BeTrue()) + current := &v1alpha1.Interface{} + g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(intf), current)).To(Succeed()) + g.Expect(current.Spec.Switchport.AllowedVlans).To(BeNil()) + claim := &poolv1alpha1.Claim{} + g.Expect(k8sClient.Get(ctx, claimKey, claim)).To(Succeed()) + g.Expect(claim.DeletionTimestamp.IsZero()).To(BeTrue()) + net := &overlayv1alpha1.Network{} + g.Expect(k8sClient.Get(ctx, key, net)).To(Succeed()) + g.Expect(net.Status.Conditions).To(ContainElement(SatisfyAll( + HaveField("Type", v1alpha1.ReadyCondition), + HaveField("Status", metav1.ConditionTrue), + HaveField("Reason", v1alpha1.ReadyReason), + ))) + fabric := &evpnv1alpha1.Fabric{} + g.Expect(k8sClient.Get(ctx, fabricKey, fabric)).To(Succeed()) + g.Expect(metav1.IsControlledBy(claim, fabric)).To(BeTrue()) + }).Should(Succeed()) + }) + }) +}) diff --git a/internal/controller/evpn/suite_test.go b/internal/controller/evpn/suite_test.go index 7231ae023..1213a05b0 100644 --- a/internal/controller/evpn/suite_test.go +++ b/internal/controller/evpn/suite_test.go @@ -24,8 +24,9 @@ import ( "sigs.k8s.io/controller-runtime/pkg/log/zap" metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server" - corev1alpha1 "github.com/ironcore-dev/network-operator/api/core/v1alpha1" + "github.com/ironcore-dev/network-operator/api/core/v1alpha1" evpnv1alpha1 "github.com/ironcore-dev/network-operator/api/evpn/v1alpha1" + overlayv1alpha1 "github.com/ironcore-dev/network-operator/api/overlay/v1alpha1" poolv1alpha1 "github.com/ironcore-dev/network-operator/api/pool/v1alpha1" poolcontroller "github.com/ironcore-dev/network-operator/internal/controller/pool" "github.com/ironcore-dev/network-operator/internal/deviceutil" @@ -63,8 +64,9 @@ var _ = BeforeSuite(func() { ctx, cancel = context.WithCancel(ctrl.SetupSignalHandler()) Expect(evpnv1alpha1.AddToScheme(scheme.Scheme)).To(Succeed()) - Expect(corev1alpha1.AddToScheme(scheme.Scheme)).To(Succeed()) + Expect(v1alpha1.AddToScheme(scheme.Scheme)).To(Succeed()) Expect(poolv1alpha1.AddToScheme(scheme.Scheme)).To(Succeed()) + Expect(overlayv1alpha1.AddToScheme(scheme.Scheme)).To(Succeed()) // +kubebuilder:scaffold:scheme @@ -104,6 +106,36 @@ var _ = BeforeSuite(func() { provider.Register("test-provider", NewProvider) + for _, obj := range []client.Object{&v1alpha1.Interface{}, &v1alpha1.VLAN{}, &v1alpha1.EVPNInstance{}} { + err = k8sManager.GetFieldIndexer().IndexField(ctx, obj, v1alpha1.DeviceRefIndexKey, func(obj client.Object) []string { + switch obj := obj.(type) { + case *v1alpha1.Interface: + return []string{obj.Spec.DeviceRef.Name} + case *v1alpha1.VLAN: + return []string{obj.Spec.DeviceRef.Name} + case *v1alpha1.EVPNInstance: + return []string{obj.Spec.DeviceRef.Name} + default: + panic(fmt.Sprintf("unexpected device resource %T", obj)) + } + }) + Expect(err).NotTo(HaveOccurred()) + } + + err = (&NetworkReconciler{ + Client: k8sManager.GetClient(), + Scheme: k8sManager.GetScheme(), + Recorder: recorder, + }).SetupWithManager(ctx, k8sManager) + Expect(err).NotTo(HaveOccurred()) + + err = (&NetworkAttachmentReconciler{ + Client: k8sManager.GetClient(), + Scheme: k8sManager.GetScheme(), + Recorder: recorder, + }).SetupWithManager(ctx, k8sManager) + Expect(err).NotTo(HaveOccurred()) + err = (&FabricReconciler{ Client: k8sManager.GetClient(), Scheme: k8sManager.GetScheme(), @@ -111,6 +143,18 @@ var _ = BeforeSuite(func() { }).SetupWithManager(k8sManager) Expect(err).NotTo(HaveOccurred()) + err = (&poolcontroller.IndexPoolReconciler{ + Client: k8sManager.GetClient(), + Scheme: k8sManager.GetScheme(), + }).SetupWithManager(k8sManager) + Expect(err).NotTo(HaveOccurred()) + + err = (&poolcontroller.IndexReconciler{ + Client: k8sManager.GetClient(), + Scheme: k8sManager.GetScheme(), + }).SetupWithManager(ctx, k8sManager) + Expect(err).NotTo(HaveOccurred()) + err = (&poolcontroller.IPAddressPoolReconciler{ Client: k8sManager.GetClient(), Scheme: k8sManager.GetScheme(), diff --git a/internal/controller/overlay/doc.go b/internal/controller/overlay/doc.go new file mode 100644 index 000000000..11af71b5b --- /dev/null +++ b/internal/controller/overlay/doc.go @@ -0,0 +1,8 @@ +// SPDX-FileCopyrightText: SAP SE or an SAP affiliate company and IronCore contributors +// SPDX-License-Identifier: Apache-2.0 + +// Package overlay contains generic controllers for the +// overlay.networking.metal.ironcore.dev API group. It handles forwarding-independent +// lifecycle and status initialization for Networks and NetworkAttachments, leaving +// forwarding-specific realization to packages such as evpn. +package overlay diff --git a/internal/controller/overlay/network_controller.go b/internal/controller/overlay/network_controller.go index 1ae798cb2..1ce21b11d 100644 --- a/internal/controller/overlay/network_controller.go +++ b/internal/controller/overlay/network_controller.go @@ -137,8 +137,7 @@ func (r *NetworkReconciler) SetupWithManager(mgr ctrl.Manager) error { Complete(r) } -func (r *NetworkReconciler) reconcile(_ context.Context, net *overlayv1alpha1.Network) (ctrl.Result, error) { //nolint:unparam - conditions.RecomputeReady(net) +func (r *NetworkReconciler) reconcile(_ context.Context, net *overlayv1alpha1.Network) (ctrl.Result, error) { return ctrl.Result{}, nil } diff --git a/internal/controller/overlay/network_controller_test.go b/internal/controller/overlay/network_controller_test.go index ca535af40..297f08835 100644 --- a/internal/controller/overlay/network_controller_test.go +++ b/internal/controller/overlay/network_controller_test.go @@ -11,7 +11,6 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/ironcore-dev/network-operator/api/core/v1alpha1" overlayv1alpha1 "github.com/ironcore-dev/network-operator/api/overlay/v1alpha1" ) @@ -46,15 +45,6 @@ var _ = Describe("Network Controller", func() { g.Expect(k8sClient.Get(ctx, key, resource)).To(Succeed()) g.Expect(controllerutil.ContainsFinalizer(resource, overlayv1alpha1.FinalizerName)).To(BeTrue()) }).Should(Succeed()) - - By("Verifying the controller updates the status conditions") - Eventually(func(g Gomega) { - resource := &overlayv1alpha1.Network{} - g.Expect(k8sClient.Get(ctx, key, resource)).To(Succeed()) - g.Expect(resource.Status.Conditions).To(HaveLen(1)) - g.Expect(resource.Status.Conditions[0].Type).To(Equal(v1alpha1.ReadyCondition)) - g.Expect(resource.Status.Conditions[0].Status).To(Equal(metav1.ConditionTrue)) - }).Should(Succeed()) }) }) }) diff --git a/internal/controller/overlay/networkattachment_controller.go b/internal/controller/overlay/networkattachment_controller.go index 207427e7f..d01797656 100644 --- a/internal/controller/overlay/networkattachment_controller.go +++ b/internal/controller/overlay/networkattachment_controller.go @@ -137,8 +137,7 @@ func (r *NetworkAttachmentReconciler) SetupWithManager(mgr ctrl.Manager) error { Complete(r) } -func (r *NetworkAttachmentReconciler) reconcile(_ context.Context, na *overlayv1alpha1.NetworkAttachment) (ctrl.Result, error) { //nolint:unparam - conditions.RecomputeReady(na) +func (r *NetworkAttachmentReconciler) reconcile(_ context.Context, na *overlayv1alpha1.NetworkAttachment) (ctrl.Result, error) { return ctrl.Result{}, nil } diff --git a/internal/controller/overlay/networkattachment_controller_test.go b/internal/controller/overlay/networkattachment_controller_test.go index e85fa666d..ea9480085 100644 --- a/internal/controller/overlay/networkattachment_controller_test.go +++ b/internal/controller/overlay/networkattachment_controller_test.go @@ -71,15 +71,6 @@ var _ = Describe("NetworkAttachment Controller", func() { g.Expect(k8sClient.Get(ctx, key, resource)).To(Succeed()) g.Expect(controllerutil.ContainsFinalizer(resource, overlayv1alpha1.FinalizerName)).To(BeTrue()) }).Should(Succeed()) - - By("Verifying the controller updates the status conditions") - Eventually(func(g Gomega) { - resource := &overlayv1alpha1.NetworkAttachment{} - g.Expect(k8sClient.Get(ctx, key, resource)).To(Succeed()) - g.Expect(resource.Status.Conditions).To(HaveLen(1)) - g.Expect(resource.Status.Conditions[0].Type).To(Equal(v1alpha1.ReadyCondition)) - g.Expect(resource.Status.Conditions[0].Status).To(Equal(metav1.ConditionTrue)) - }).Should(Succeed()) }) }) }) From 6850814b69d7e3754534e1f60cf0b0009be81506 Mon Sep 17 00:00:00 2001 From: Pujol Date: Tue, 10 Nov 2026 18:34:07 +0100 Subject: [PATCH 3/3] Update tests to account for `defaultMulticastGroup` Signed-off-by: Pujol --- internal/controller/evpn/network_controller_test.go | 3 ++- .../controller/evpn/networkattachment_controller_test.go | 6 ++++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/internal/controller/evpn/network_controller_test.go b/internal/controller/evpn/network_controller_test.go index 93817669f..10e3c97f1 100644 --- a/internal/controller/evpn/network_controller_test.go +++ b/internal/controller/evpn/network_controller_test.go @@ -98,7 +98,8 @@ var _ = Describe("Network Controller", func() { }, }, BUM: evpnv1alpha1.FabricBUMSpec{ - Type: evpnv1alpha1.BUMTypeMulticast, + Type: evpnv1alpha1.BUMTypeMulticast, + DefaultMulticastGroup: new(v1alpha1.MustParsePrefix("224.0.0.0/4")), PIM: &evpnv1alpha1.FabricPIMSpec{ AnycastRendezvousPoints: []evpnv1alpha1.AnycastRendezvousPoint{{ Name: "unused", diff --git a/internal/controller/evpn/networkattachment_controller_test.go b/internal/controller/evpn/networkattachment_controller_test.go index 5eb307ac1..343206c2a 100644 --- a/internal/controller/evpn/networkattachment_controller_test.go +++ b/internal/controller/evpn/networkattachment_controller_test.go @@ -103,7 +103,8 @@ var _ = Describe("NetworkAttachment Controller", func() { }, }, BUM: evpnv1alpha1.FabricBUMSpec{ - Type: evpnv1alpha1.BUMTypeMulticast, + Type: evpnv1alpha1.BUMTypeMulticast, + DefaultMulticastGroup: new(v1alpha1.MustParsePrefix("224.0.0.0/4")), PIM: &evpnv1alpha1.FabricPIMSpec{ AnycastRendezvousPoints: []evpnv1alpha1.AnycastRendezvousPoint{{ Name: "unused", @@ -821,7 +822,8 @@ var _ = Describe("NetworkAttachment Controller", func() { }, }, BUM: evpnv1alpha1.FabricBUMSpec{ - Type: evpnv1alpha1.BUMTypeMulticast, + Type: evpnv1alpha1.BUMTypeMulticast, + DefaultMulticastGroup: new(v1alpha1.MustParsePrefix("224.0.0.0/4")), PIM: &evpnv1alpha1.FabricPIMSpec{ AnycastRendezvousPoints: []evpnv1alpha1.AnycastRendezvousPoint{{ Name: "unused",