Refactor/iosxe separation of concerns (#75)

* Refactor driver code with clear separation of concerns

* Add driver tests

---------

Co-authored-by: Richard Cunningham <cunningr@cisco.com>

Author: cunningr

internal/drivers/iosxe/README.md

@@ -0,0 +1,45 @@
+# IOS-XE Driver Package
+
+This package implements the `CiscoKubernetesDeviceDriver` interface for Cisco IOS-XE devices using the AppHosting feature over RESTCONF.
+
+## Design Intent
+
+The code is organised into files with clear separation of concerns, roughly following these layers:
+
+| Layer | File(s) | Responsibility |
+|-------|---------|----------------|
+| **Constructor** | `driver.go` | `XEDriver` struct, factory constructor, marshallers/unmarshallers |
+| **Types** | `types.go` | Shared types (`AppHostingConfig`, `AppPhase`, `networkConfig`, etc.) |
+| **Device** | `device.go` | Device connectivity checks and node resource reporting |
+| **Transport** | `client.go` | Low-level device operations (install, activate, start, …). Named protocol-agnostically to support future NETCONF transport |
+| **Reconciler** | `reconciler.go` | App lifecycle state machine — drives apps toward their desired state |
+| **Pod Lifecycle** | `pod_lifecycle.go` | Kubernetes-facing interface methods (`DeployPod`, `DeletePod`, `GetPodStatus`, `ListPods`) |
+| **Pod Transforms** | `pod_transforms.go` | Pod.Spec → IOS-XE AppHosting config conversion (network, resources, labels) |
+| **Status Transforms** | `status_transforms.go` | App operational data → Pod.Status / ContainerStatus conversion |
+| **IP Discovery** | `ip_discovery.go` | Pod IP resolution from app-hosting oper data with ARP table fallback |
+| **Models** | `models.go` | YANG/ygot generated structs (do not edit by hand) |
+
+## Data Flow
+
+```
+Pod.Spec
+  │
+  ▼
+pod_transforms.go   ──►  AppHostingConfig (types.go)
+                              │
+                              ▼
+                         client.go  ◄──►  IOS-XE Device (RESTCONF)
+                              │
+                              ▼
+                        reconciler.go  (state machine: "" → DEPLOYED → ACTIVATED → RUNNING)
+                              │
+                              ▼
+                     ip_discovery.go  +  status_transforms.go
+                              │
+                              ▼
+                         Pod.Status
+```
+
+## Adding a New Transport
+
+`client.go` is intentionally named without a protocol prefix. To add NETCONF support, introduce a transport interface and provide RESTCONF / NETCONF implementations behind it, keeping the method signatures in `client.go` stable.

internal/drivers/iosxe/app_hosting.go internal/drivers/iosxe/client.gointernal/drivers/iosxe/app_hosting.go renamed to internal/drivers/iosxe/client.go

@@ -22,7 +22,6 @@ import (
 	"time"
 
 	"github.com/virtual-kubelet/virtual-kubelet/log"
-	v1 "k8s.io/api/core/v1"
 )
 
 // CreateAppHostingApp creates a single IOS-XE AppHosting app from an AppHostingConfig.
@@ -150,206 +149,6 @@ func (d *XEDriver) UninstallApp(ctx context.Context, appID string) error {
 	return nil
 }
 
-// ReconcileApp performs a single reconciliation step, driving the app one state
-// closer to its desired state and updating appConfig.Status in place.
-//
-// Forward (DesiredState = Running):
-//
-//	"" (no config)  → POST config + install RPC  → Converging
-//	"" (config, no oper) → re-issue install RPC   → Converging
-//	"DEPLOYED"      → activate RPC               → Converging
-//	"ACTIVATED"     → start RPC                  → Converging
-//	"RUNNING"       → no-op                      → Ready
-//
-// Reverse (DesiredState = Deleted):
-//
-//	"RUNNING"       → stop RPC                   → Deleting
-//	"ACTIVATED"/"STOPPED" → deactivate RPC       → Deleting
-//	"DEPLOYED"      → uninstall RPC              → Deleting
-//	"" (no oper)    → delete config              → Deleted
-func (d *XEDriver) ReconcileApp(ctx context.Context, appConfig *AppHostingConfig) {
-	appID := appConfig.AppName()
-	desired := appConfig.Spec.DesiredState
-
-	// 1. Observe current device state.
-	state := d.getAppState(ctx, appID)
-	appConfig.Status.ObservedState = state
-	appConfig.Status.LastTransition = time.Now()
-
-	log.G(ctx).Infof("ReconcileApp %s: observed=%q desired=%s phase=%s",
-		appID, state, desired, appConfig.Status.Phase)
-
-	// ── Forward path: drive toward RUNNING ────────────────────────────
-	if desired == AppDesiredStateRunning {
-		switch state {
-		case "RUNNING":
-			appConfig.Status.Phase = AppPhaseReady
-			appConfig.Status.Message = "App is running"
-			return
-
-		case "ACTIVATED":
-			// ACTIVATED → start
-			appConfig.Status.Phase = AppPhaseConverging
-			appConfig.Status.Message = "Starting app"
-			if err := d.StartApp(ctx, appID); err != nil {
-				log.G(ctx).Warnf("ReconcileApp %s: start failed: %v", appID, err)
-				appConfig.Status.Phase = AppPhaseError
-				appConfig.Status.Message = fmt.Sprintf("start failed: %v", err)
-			}
-			return
-
-		case "DEPLOYED":
-			// DEPLOYED → activate
-			appConfig.Status.Phase = AppPhaseConverging
-			appConfig.Status.Message = "Activating app"
-			if err := d.ActivateApp(ctx, appID); err != nil {
-				log.G(ctx).Warnf("ReconcileApp %s: activate failed: %v", appID, err)
-				appConfig.Status.Phase = AppPhaseError
-				appConfig.Status.Message = fmt.Sprintf("activate failed: %v", err)
-			}
-			return
-
-		default:
-			// No oper data (or unexpected state) — the install likely hasn't
-			// happened or failed silently. Re-issue install if we have an image.
-			imagePath := appConfig.ImagePath()
-			if imagePath == "" {
-				log.G(ctx).Warnf("ReconcileApp %s: no oper data and no image path; cannot install", appID)
-				appConfig.Status.Phase = AppPhaseError
-				appConfig.Status.Message = "no image path available for install"
-				return
-			}
-			appConfig.Status.Phase = AppPhaseConverging
-			appConfig.Status.Message = "Re-issuing install"
-			log.G(ctx).Warnf("ReconcileApp %s: no oper data; re-issuing install (image: %s)", appID, imagePath)
-			if err := d.InstallApp(ctx, appID, imagePath); err != nil {
-				log.G(ctx).Warnf("ReconcileApp %s: install failed: %v", appID, err)
-				appConfig.Status.Phase = AppPhaseError
-				appConfig.Status.Message = fmt.Sprintf("install failed: %v", err)
-			}
-			return
-		}
-	}
-
-	// ── Reverse path: drive toward deletion ───────────────────────────
-	if desired == AppDesiredStateDeleted {
-		switch state {
-		case "RUNNING":
-			appConfig.Status.Phase = AppPhaseDeleting
-			appConfig.Status.Message = "Stopping app"
-			if err := d.StopApp(ctx, appID); err != nil {
-				log.G(ctx).Warnf("ReconcileApp %s: stop failed: %v", appID, err)
-				appConfig.Status.Phase = AppPhaseError
-				appConfig.Status.Message = fmt.Sprintf("stop failed: %v", err)
-			}
-			return
-
-		case "ACTIVATED", "STOPPED":
-			appConfig.Status.Phase = AppPhaseDeleting
-			appConfig.Status.Message = "Deactivating app"
-			if err := d.DeactivateApp(ctx, appID); err != nil {
-				log.G(ctx).Warnf("ReconcileApp %s: deactivate failed: %v", appID, err)
-				appConfig.Status.Phase = AppPhaseError
-				appConfig.Status.Message = fmt.Sprintf("deactivate failed: %v", err)
-			}
-			return
-
-		case "DEPLOYED":
-			appConfig.Status.Phase = AppPhaseDeleting
-			appConfig.Status.Message = "Uninstalling app"
-			if err := d.UninstallApp(ctx, appID); err != nil {
-				log.G(ctx).Warnf("ReconcileApp %s: uninstall failed: %v", appID, err)
-				appConfig.Status.Phase = AppPhaseError
-				appConfig.Status.Message = fmt.Sprintf("uninstall failed: %v", err)
-			}
-			return
-
-		default:
-			// No operational data — safe to remove config.
-			appConfig.Status.Phase = AppPhaseDeleting
-			appConfig.Status.Message = "Removing config"
-			path := fmt.Sprintf("/restconf/data/Cisco-IOS-XE-app-hosting-cfg:app-hosting-cfg-data/apps/app=%s", appID)
-			if err := d.client.Delete(ctx, path); err != nil {
-				log.G(ctx).Warnf("ReconcileApp %s: config delete failed: %v", appID, err)
-				appConfig.Status.Phase = AppPhaseError
-				appConfig.Status.Message = fmt.Sprintf("config delete failed: %v", err)
-				return
-			}
-			appConfig.Status.Phase = AppPhaseDeleted
-			appConfig.Status.Message = "App fully removed"
-			log.G(ctx).Infof("ReconcileApp %s: fully deleted", appID)
-			return
-		}
-	}
-}
-
-// containerImagePath returns the image path for a named container in a pod spec.
-func containerImagePath(pod *v1.Pod, containerName string) string {
-	for i := range pod.Spec.Containers {
-		if pod.Spec.Containers[i].Name == containerName {
-			return pod.Spec.Containers[i].Image
-		}
-	}
-	return ""
-}
-
-// getAppState returns the current operational state string for appID, or ""
-// if the app has no oper data or the state cannot be determined.
-func (d *XEDriver) getAppState(ctx context.Context, appID string) string {
-	if d.client == nil {
-		return ""
-	}
-	allOper, err := d.GetAppOperationalData(ctx)
-	if err != nil {
-		log.G(ctx).Warnf("Could not fetch oper data to check state of app %s: %v", appID, err)
-		return ""
-	}
-	operData, ok := allOper[appID]
-	if !ok || operData == nil || operData.Details == nil || operData.Details.State == nil {
-		return ""
-	}
-	return *operData.Details.State
-}
-
-// DeleteApp orchestrates a reconciler-driven teardown of the app lifecycle.
-//
-// It creates a transient AppHostingConfig with DesiredState=Deleted and
-// repeatedly invokes ReconcileApp until the app reaches the Deleted phase
-// or a timeout is exceeded.
-//
-//	RUNNING  → stop → ACTIVATED → deactivate → DEPLOYED → uninstall → (absent) → config delete
-func (d *XEDriver) DeleteApp(ctx context.Context, appID string) error {
-	appConfig := &AppHostingConfig{
-		Metadata: AppHostingMetadata{AppName: appID},
-		Spec:     AppHostingSpec{DesiredState: AppDesiredStateDeleted},
-		Status:   AppHostingStatus{Phase: AppPhaseDeleting},
-	}
-
-	const maxAttempts = 15
-	const reconcileInterval = 4 * time.Second
-
-	for attempt := 1; attempt <= maxAttempts; attempt++ {
-		d.ReconcileApp(ctx, appConfig)
-
-		if appConfig.Status.Phase == AppPhaseDeleted {
-			log.G(ctx).Infof("Successfully deleted app %s after %d reconcile pass(es)", appID, attempt)
-			return nil
-		}
-
-		log.G(ctx).Debugf("DeleteApp %s: attempt %d/%d, phase=%s observed=%q msg=%s",
-			appID, attempt, maxAttempts, appConfig.Status.Phase, appConfig.Status.ObservedState, appConfig.Status.Message)
-
-		select {
-		case <-ctx.Done():
-			return fmt.Errorf("context cancelled while deleting app %s", appID)
-		case <-time.After(reconcileInterval):
-		}
-	}
-
-	return fmt.Errorf("app %s not fully deleted after %d reconcile attempts (last phase: %s, observed: %q)",
-		appID, maxAttempts, appConfig.Status.Phase, appConfig.Status.ObservedState)
-}
-
 // WaitForAppStatus polls the device until the app reaches the expected status or times out
 func (d *XEDriver) WaitForAppStatus(ctx context.Context, appID string, expectedStatus string, maxWaitTime time.Duration) error {
 	log.G(ctx).Infof("Waiting for app %s to reach status: %s", appID, expectedStatus)

internal/drivers/iosxe/device.go

@@ -0,0 +1,109 @@
+// Copyright © 2026 Cisco Systems Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package iosxe
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+
+	"github.com/cisco/virtual-kubelet-cisco/internal/drivers/common"
+	"github.com/virtual-kubelet/virtual-kubelet/log"
+	v1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+)
+
+// CheckConnection validates connectivity to the device and fetches device info
+func (d *XEDriver) CheckConnection(ctx context.Context) error {
+	res := &common.HostMeta{}
+
+	err := d.client.Get(ctx, "/.well-known/host-meta", res, d.gethostMetaUnmarshaller())
+	if err != nil {
+		return fmt.Errorf("connectivity check failed: %w", err)
+	}
+
+	log.G(ctx).Debugf("Restconf Root: %s\n", res.Links[0].Href)
+
+	d.deviceInfo = d.fetchDeviceInfo(ctx)
+	return nil
+}
+
+func (d *XEDriver) fetchDeviceInfo(ctx context.Context) *common.DeviceInfo {
+	info := &common.DeviceInfo{}
+
+	resp := &Cisco_IOS_XEDeviceHardwareOper_DeviceHardwareData{}
+	err := d.client.Get(ctx, "/restconf/data/Cisco-IOS-XE-device-hardware-oper:device-hardware-data", resp, d.unmarshaller)
+	if err != nil {
+		log.G(ctx).WithError(err).Debug("Failed to fetch device hardware info")
+		return info
+	}
+
+	// Get software version from device-system-data and extract just the version number
+	if resp.DeviceHardware != nil && resp.DeviceHardware.DeviceSystemData != nil {
+		if resp.DeviceHardware.DeviceSystemData.SoftwareVersion != nil {
+			info.SoftwareVersion = parseVersionNumber(*resp.DeviceHardware.DeviceSystemData.SoftwareVersion)
+		}
+	}
+
+	// Find the chassis inventory entry for serial and part number
+	if resp.DeviceHardware != nil && resp.DeviceHardware.DeviceInventory != nil {
+		for _, inv := range resp.DeviceHardware.DeviceInventory {
+			if inv.HwType == Cisco_IOS_XEDeviceHardwareOper_HwType_hw_type_chassis && inv.SerialNumber != nil && *inv.SerialNumber != "" {
+				info.SerialNumber = *inv.SerialNumber
+				if inv.PartNumber != nil {
+					info.ProductID = *inv.PartNumber
+				}
+				break
+			}
+		}
+	}
+
+	if info.SerialNumber != "" {
+		log.G(ctx).Infof("Device info: Serial=%s, Version=%s, Product=%s",
+			info.SerialNumber, info.SoftwareVersion, info.ProductID)
+	}
+
+	return info
+}
+
+// parseVersionNumber extracts the version number (e.g., "17.18.2") from the full software-version string
+func parseVersionNumber(fullVersion string) string {
+	re := regexp.MustCompile(`Version\s+(\d+\.\d+\.\d+)`)
+	matches := re.FindStringSubmatch(fullVersion)
+	if len(matches) > 1 {
+		return matches[1]
+	}
+	return fullVersion
+}
+
+// GetDeviceInfo returns cached device information
+func (d *XEDriver) GetDeviceInfo(ctx context.Context) (*common.DeviceInfo, error) {
+	if d.deviceInfo == nil {
+		return &common.DeviceInfo{}, nil
+	}
+	return d.deviceInfo, nil
+}
+
+// GetDeviceResources returns the available resources on the device
+func (d *XEDriver) GetDeviceResources(ctx context.Context) (*v1.ResourceList, error) {
+	resources := v1.ResourceList{
+		v1.ResourceCPU:     resource.MustParse("8"),
+		v1.ResourceMemory:  resource.MustParse("16Gi"),
+		v1.ResourceStorage: resource.MustParse("100Gi"),
+		v1.ResourcePods:    resource.MustParse("16"),
+	}
+
+	return &resources, nil
+}