Add provider implementation for NXOS

Author: nikatza

api/cisco/nx/v1alpha1/lldpconfig_types.go

@@ -18,36 +18,34 @@ type LLDPConfigSpec struct {
 	// +kubebuilder:validation:Minimum=1
 	// +kubebuilder:validation:Maximum=10
 	// +kubebuilder:default=2
-	InitDelay *int16 `json:"initDelay,omitempty"`
+	InitDelay int16 `json:"initDelay,omitempty"`
 
 	// HoldTime defines the time in seconds that the receiving device should hold the LLDP information before discarding it.
 	// +optional
 	// +kubebuilder:validation:Minimum=1
 	// +kubebuilder:validation:Maximum=255
 	// +kubebuilder:default=120
-	HoldTime *int16 `json:"holdTime,omitempty"`
+	HoldTime int16 `json:"holdTime,omitempty"`
 
-	// Interfaces defines the LLDP configuration per interface.
+	// InterfaceConfigurations defines the LLDP configuration per interface.
 	// +optional
-	Interfaces []LLDPInterfaceConfig `json:"interfaces,omitempty"`
+	InterfaceConfigurations []LLDPInterfaceConfig `json:"interfaceConfigurations,omitempty"`
 }
 
 type LLDPInterfaceConfig struct {
 	// InterfaceRef references the interface to configure LLDP on.
 	// +required
 	InterfaceRef v1alpha1.LocalObjectReference `json:"interfaceRef"`
 
-	// AdminSt defines the administrative state of LLDP on the interface
-	// +required
-	AdminSt v1alpha1.AdminState `json:"adminSt"`
-
 	// AdminRxState defines the administrative state for receiving LLDP PDUs on the interface.
 	// +optional
-	AdminRxState *v1alpha1.AdminState `json:"adminRxState,omitempty"`
+	// +kubebuilder:default=Up
+	AdminRxState v1alpha1.AdminState `json:"adminRxState,omitempty"`
 
 	// AdminTxState defines the administrative state for transmitting LLDP PDUs on the interface.
 	// +optional
-	AdminTxState *v1alpha1.AdminState `json:"adminTxState,omitempty"`
+	// +kubebuilder:default=Up
+	AdminTxState v1alpha1.AdminState `json:"adminTxState,omitempty"`
 }
 
 // +kubebuilder:object:root=true

api/cisco/nx/v1alpha1/zz_generated.deepcopy.go

@@ -53,6 +53,7 @@ type LLDPStatus struct {
 // +kubebuilder:resource:path=lldps
 // +kubebuilder:resource:singular=lldp
 // +kubebuilder:printcolumn:name="Device",type=string,JSONPath=`.spec.deviceRef.name`
+// +kubebuilder:printcolumn:name="Admin State",type=string,JSONPath=`.spec.adminState`
 // +kubebuilder:printcolumn:name="Ready",type=string,JSONPath=`.status.conditions[?(@.type=="Ready")].status`
 // +kubebuilder:printcolumn:name="Configured",type=string,JSONPath=`.status.conditions[?(@.type=="Configured")].status`,priority=1
 // +kubebuilder:printcolumn:name="Operational",type=string,JSONPath=`.status.conditions[?(@.type=="Operational")].status`,priority=1

api/core/v1alpha1/lldp_types.go

@@ -18,6 +18,9 @@ spec:
     - jsonPath: .spec.deviceRef.name
       name: Device
       type: string
+    - jsonPath: .spec.adminState
+      name: Admin State
+      type: string
     - jsonPath: .status.conditions[?(@.type=="Ready")].status
       name: Ready
       type: string

config/crd/bases/networking.metal.ironcore.dev_lldps.yaml

@@ -55,25 +55,21 @@ spec:
                 maximum: 10
                 minimum: 1
                 type: integer
-              interfaces:
-                description: Interfaces defines the LLDP configuration per interface.
+              interfaceConfigurations:
+                description: InterfaceConfigurations defines the LLDP configuration
+                  per interface.
                 items:
                   properties:
                     adminRxState:
+                      default: Up
                       description: AdminRxState defines the administrative state for
                         receiving LLDP PDUs on the interface.
                       enum:
                       - Up
                       - Down
                       type: string
-                    adminSt:
-                      description: AdminSt defines the administrative state of LLDP
-                        on the interface
-                      enum:
-                      - Up
-                      - Down
-                      type: string
                     adminTxState:
+                      default: Up
                       description: AdminTxState defines the administrative state for
                         transmitting LLDP PDUs on the interface.
                       enum:
@@ -96,7 +92,6 @@ spec:
                       type: object
                       x-kubernetes-map-type: atomic
                   required:
-                  - adminSt
                   - interfaceRef
                   type: object
                 type: array

config/crd/bases/nx.cisco.networking.metal.ironcore.dev_lldpconfigs.yaml

@@ -6,7 +6,12 @@ metadata:
     app.kubernetes.io/managed-by: kustomize
   name: leaf1-lldpconfig
 spec:
-  initDelay: 5
+  initDelay: 10
   holdTime: 120
-  interfaceRef:
-    - name: leaf1-physif-eth1/1
+  interfaceConfigurations:
+    - interfaceRef:
+        name: eth1-1
+    - interfaceRef:
+        name: eth1-2
+      adminRxState: Down
+      adminTxState: Down

config/samples/cisco/nx/v1alpha1_lldpconfig.yaml

@@ -29,6 +29,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 
+	nxv1alpha1 "github.com/ironcore-dev/network-operator/api/cisco/nx/v1alpha1"
 	"github.com/ironcore-dev/network-operator/api/core/v1alpha1"
 	"github.com/ironcore-dev/network-operator/internal/conditions"
 	"github.com/ironcore-dev/network-operator/internal/deviceutil"
@@ -204,6 +205,9 @@ type lldpScope struct {
 	Connection     *deviceutil.Connection
 	ProviderConfig *provider.ProviderConfig
 	Provider       provider.LLDPProvider
+	// Interfaces maps k8s object names to Interface objects associated with the LLDP, required by
+	// - cisco/nx
+	Interfaces map[string]*v1alpha1.Interface
 }
 
 func (r *LLDPReconciler) reconcile(ctx context.Context, s *lldpScope) (_ ctrl.Result, reterr error) {
@@ -244,6 +248,7 @@ func (r *LLDPReconciler) reconcile(ctx context.Context, s *lldpScope) (_ ctrl.Re
 	err := s.Provider.EnsureLLDP(ctx, &provider.LLDPRequest{
 		LLDP:           s.LLDP,
 		ProviderConfig: s.ProviderConfig,
+		Interfaces:     s.Interfaces,
 	})
 
 	cond := conditions.FromError(err)
@@ -278,7 +283,7 @@ func (r *LLDPReconciler) reconcile(ctx context.Context, s *lldpScope) (_ ctrl.Re
 }
 
 // validateProviderConfigRef checks if the referenced provider configuration is compatible with the target platform.
-func (r *LLDPReconciler) validateProviderConfigRef(_ context.Context, s *lldpScope) error {
+func (r *LLDPReconciler) validateProviderConfigRef(ctx context.Context, s *lldpScope) error {
 	if s.LLDP.Spec.ProviderConfigRef == nil {
 		return nil
 	}
@@ -302,9 +307,26 @@ func (r *LLDPReconciler) validateProviderConfigRef(_ context.Context, s *lldpSco
 			Type:    v1alpha1.ConfiguredCondition,
 			Status:  metav1.ConditionFalse,
 			Reason:  v1alpha1.IncompatibleProviderConfigRef,
-			Message: fmt.Sprintf("ProviderConfigRef is not compatible with Device: %v", err),
+			Message: fmt.Sprintf("ProviderConfigRef kind '%s' with API version '%s' is not compatible with this device type", s.LLDP.Spec.ProviderConfigRef.Kind, s.LLDP.Spec.ProviderConfigRef.APIVersion),
 		})
-		return reconcile.TerminalError(fmt.Errorf("unsupported provider config ref kind %q on this provider", gv))
+		return reconcile.TerminalError(fmt.Errorf("unsupported pProviderConfigRef Kind %q on this provider", gv))
+	}
+
+	gvk := schema.GroupVersionKind{
+		Group:   gv.Group,
+		Version: gv.Version,
+		Kind:    s.LLDP.Spec.ProviderConfigRef.Kind,
+	}
+
+	// only cisco/nx for the moment
+	if gvk == nxv1alpha1.GroupVersion.WithKind("LLDPConfig") {
+		lc := new(nxv1alpha1.LLDPConfig)
+		if err := s.ProviderConfig.Into(lc); err != nil {
+			return reconcile.TerminalError(fmt.Errorf("failed to parse provider config into LLDPConfig: %w", err))
+		}
+		if err := r.validateProviderConfigNXOS(ctx, lc, s); err != nil {
+			return reconcile.TerminalError(fmt.Errorf("configuration error in provider config ref %w", err))
+		}
 	}
 	return nil
 }
@@ -325,8 +347,50 @@ func (r *LLDPReconciler) validateUniqueLLDPPerDevice(ctx context.Context, s *lld
 				Reason:  v1alpha1.DuplicateResourceOnDevice,
 				Message: fmt.Sprintf("Another LLDP (%s) already exists for device %s", lldp.Name, s.LLDP.Spec.DeviceRef.Name),
 			})
-			return reconcile.TerminalError(fmt.Errorf("only one lldp resource allowed per device (%s)", s.LLDP.Spec.DeviceRef.Name))
+			return reconcile.TerminalError(fmt.Errorf("only one LLDP resource allowed per device (%s)", s.LLDP.Spec.DeviceRef.Name))
+		}
+	}
+	return nil
+}
+
+// validateProviderConfigNXOS validates the provider configuration for the NXOS platform.
+// Updates scope and adds interfaces referenced by the LLDP configuration to the scope.
+func (r *LLDPReconciler) validateProviderConfigNXOS(ctx context.Context, cfg *nxv1alpha1.LLDPConfig, s *lldpScope) error {
+	// Ensure all referenced interfaces exist and belong to she same device as the LLDP.
+	s.Interfaces = make(map[string]*v1alpha1.Interface)
+	for _, ifCfg := range cfg.Spec.InterfaceConfigurations {
+		intf := new(v1alpha1.Interface)
+		if err := r.Get(ctx, client.ObjectKey{Name: ifCfg.InterfaceRef.Name, Namespace: s.LLDP.Namespace}, intf); err != nil {
+			if apierrors.IsNotFound(err) {
+				conditions.Set(s.LLDP, metav1.Condition{
+					Type:    v1alpha1.ConfiguredCondition,
+					Status:  metav1.ConditionFalse,
+					Reason:  v1alpha1.InterfaceNotFoundReason,
+					Message: fmt.Sprintf("Referenced interface %q not found", ifCfg.InterfaceRef.Name),
+				})
+				return fmt.Errorf("referenced interface %q not found: %w", ifCfg.InterfaceRef.Name, err)
+			}
+			return fmt.Errorf("failed to get referenced interface %q: %w", ifCfg.InterfaceRef.Name, err)
+		}
+		if intf.Spec.DeviceRef.Name != s.Device.Name {
+			conditions.Set(s.LLDP, metav1.Condition{
+				Type:    v1alpha1.ConfiguredCondition,
+				Status:  metav1.ConditionFalse,
+				Reason:  v1alpha1.CrossDeviceReferenceReason,
+				Message: fmt.Sprintf("Referenced interface %q belongs to device %q, expected %q", ifCfg.InterfaceRef.Name, intf.Spec.DeviceRef.Name, s.Device.Name),
+			})
+			return fmt.Errorf("referenced interface %q belongs to device %q, expected %q", ifCfg.InterfaceRef.Name, intf.Spec.DeviceRef.Name, s.Device.Name)
+		}
+		if intf.Spec.Type != v1alpha1.InterfaceTypePhysical && intf.Spec.Type != v1alpha1.InterfaceTypeAggregate {
+			conditions.Set(s.LLDP, metav1.Condition{
+				Type:    v1alpha1.ConfiguredCondition,
+				Status:  metav1.ConditionFalse,
+				Reason:  v1alpha1.InvalidInterfaceTypeReason,
+				Message: fmt.Sprintf("Referenced interface %q is of type %q, expected %q or %q", ifCfg.InterfaceRef.Name, intf.Spec.Type, v1alpha1.InterfaceTypePhysical, v1alpha1.InterfaceTypeAggregate),
+			})
+			return fmt.Errorf("referenced interface %q is of type %q, expected %q or %q", ifCfg.InterfaceRef.Name, intf.Spec.Type, v1alpha1.InterfaceTypePhysical, v1alpha1.InterfaceTypeAggregate)
 		}
+		s.Interfaces[ifCfg.InterfaceRef.Name] = intf
 	}
 	return nil
 }
@@ -376,7 +440,7 @@ func (r *LLDPReconciler) mapProviderConfigToLLDP(ctx context.Context, obj client
 
 	list := &v1alpha1.LLDPList{}
 	if err := r.List(ctx, list, client.InNamespace(obj.GetNamespace())); err != nil {
-		log.Error(err, "Failed to list LLDPs")
+		log.Error(err, "failed to list LLDPs")
 		return nil
 	}
 
@@ -388,7 +452,7 @@ func (r *LLDPReconciler) mapProviderConfigToLLDP(ctx context.Context, obj client
 			m.Spec.ProviderConfigRef.Name == obj.GetName() &&
 			m.Spec.ProviderConfigRef.Kind == gkv.Kind &&
 			m.Spec.ProviderConfigRef.APIVersion == gkv.GroupVersion().Identifier() {
-			log.Info("Enqueuing LLDP for reconciliation", "LLDP", klog.KObj(&m))
+			log.Info("Found matching LLDP for provider config change, enqueuing for reconciliation", "LLDP", klog.KObj(&m))
 			requests = append(requests, reconcile.Request{
 				NamespacedName: types.NamespacedName{
 					Name:      m.Name,

internal/controller/core/lldp_controller.go

@@ -108,7 +108,7 @@ var _ = Describe("LLDP Controller", func() {
 				g.Expect(lldp.OwnerReferences[0].Name).To(Equal(deviceName))
 			}).Should(Succeed())
 
-			By("Veryfing the controller updates the status conditions")
+			By("Verifying the controller updates the status conditions")
 			Eventually(func(g Gomega) {
 				lldp = &v1alpha1.LLDP{}
 				g.Expect(k8sClient.Get(ctx, resourceKey, lldp)).To(Succeed())

internal/controller/core/lldp_controller_test.go

@@ -0,0 +1,45 @@
+// SPDX-FileCopyrightText: 2025 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: Apache-2.0
+
+package nxos
+
+import "github.com/ironcore-dev/network-operator/internal/provider/cisco/gnmiext/v2"
+
+var (
+	_ gnmiext.Configurable = (*LLDP)(nil)
+)
+
+type LLDP struct {
+	// HoldTime is the number of seconds that a receiving device should hold the information sent by another device before discarding it.
+	HoldTime Option[uint16] `json:"holdTime"`
+	// InitDelay is the number of seconds for LLDP to initialize on any interface.
+	InitDelay Option[uint16] `json:"initDelayTime"`
+	// IfItems contains the per-interface LLDP configuration.
+	IfItems struct {
+		IfList gnmiext.List[string, *LLDPIfItem] `json:"If-list,omitzero"`
+	} `json:"if-items,omitzero"`
+}
+
+func (*LLDP) XPath() string {
+	return "System/lldp-items/inst-items"
+}
+
+func (*LLDP) IsListItem() {}
+
+type LLDPIfItem struct {
+	InterfaceName string          `json:"id"`
+	AdminRxSt     Option[AdminSt] `json:"adminRxSt"`
+	AdminTxSt     Option[AdminSt] `json:"adminTxSt"`
+}
+
+func (i *LLDPIfItem) Key() string { return i.InterfaceName }
+
+type LLDPOper struct {
+	OperSt OperSt `json:"operSt"`
+}
+
+func (*LLDPOper) IsListItem() {}
+
+func (o *LLDPOper) XPath() string {
+	return "System/fm-items/lldp-items"
+}

internal/provider/cisco/nxos/lldp.go

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: 2025 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: Apache-2.0
+
+package nxos
+
+func init() {
+	lldp := &LLDP{
+		HoldTime:  NewOption(uint16(200)),
+		InitDelay: NewOption(uint16(5)),
+	}
+
+	lldp.IfItems.IfList.Set(&LLDPIfItem{
+		InterfaceName: "eth7/1",
+		AdminRxSt:     NewOption(AdminStDisabled),
+		AdminTxSt:     NewOption(AdminStDisabled),
+	})
+
+	lldp.IfItems.IfList.Set(&LLDPIfItem{
+		InterfaceName: "eth8/1",
+		AdminTxSt:     NewOption(AdminStDisabled),
+	})
+
+	Register("lldp", lldp)
+}