Replace internal/ironic with backend-agnostic internal/management interface

Introduce a management.Client interface with GetPowerState/SetPowerState
methods and a config-driven factory/registry pattern, mirroring the
inventory interface in bare-metal-fulfillment-operator. The OpenStack
implementation wraps gophercloud Ironic calls. The controller and
cmd/main.go are updated to use management.Client, and internal/ironic/
is removed.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: DanNiESh

cmd/main.go

@@ -45,7 +45,7 @@ import (
 
 	v1alpha1 "github.com/osac-project/bare-metal-fulfillment-operator/api/v1alpha1"
 	"github.com/osac-project/host-management-openstack/internal/controller"
-	"github.com/osac-project/host-management-openstack/internal/ironic"
+	"github.com/osac-project/host-management-openstack/internal/management"
 	"github.com/osac-project/osac-operator/pkg/aap"
 	"github.com/osac-project/osac-operator/pkg/provisioning"
 	// +kubebuilder:scaffold:imports
@@ -233,15 +233,16 @@ func main() {
 		os.Exit(1)
 	}
 
-	// Ironic client for bare metal management
-	var ironicClient *ironic.Client
-	ironicCtx, ironicCancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer ironicCancel()
-	if ironicClient, err = ironic.NewClient(ironicCtx); err != nil {
-		setupLog.Error(err, "failed to create Ironic client")
+	mgmtCtx, mgmtCancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer mgmtCancel()
+	managementClient, err := management.NewOpenStackClient(mgmtCtx, &management.Config{
+		Type: "openstack",
+	})
+	if err != nil {
+		setupLog.Error(err, "failed to create management client")
 		os.Exit(1)
 	}
-	setupLog.Info("Connect to ironic", "endpoint", ironicClient.GetEndpoint())
+	setupLog.Info("Management client created", "type", "openstack")
 
 	// AAP provisioning provider for image provisioning workflows
 	var provisioningProvider provisioning.ProvisioningProvider
@@ -272,7 +273,7 @@ func main() {
 	hostLeaseReconciler := controller.NewHostLeaseReconciler(
 		mgr.GetClient(),
 		mgr.GetScheme(),
-		ironicClient,
+		managementClient,
 		provisioningProvider,
 		0, // Use DefaultRecheckInterval
 	)

internal/controller/hostlease_controller.go

@@ -24,7 +24,6 @@ import (
 	"time"
 
 	"github.com/go-logr/logr"
-	"github.com/gophercloud/gophercloud/v2/openstack/baremetal/v1/nodes"
 	"k8s.io/apimachinery/pkg/api/equality"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -37,30 +36,24 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 
 	v1alpha1 "github.com/osac-project/bare-metal-fulfillment-operator/api/v1alpha1"
-	"github.com/osac-project/host-management-openstack/internal/ironic"
+	"github.com/osac-project/host-management-openstack/internal/management"
 	opv1alpha1 "github.com/osac-project/osac-operator/api/v1alpha1"
 	"github.com/osac-project/osac-operator/pkg/provisioning"
 )
 
-// HostLeaseReconciler reconciles HostLease CRs for power management via Ironic.
 type HostLeaseReconciler struct {
 	client.Client
-	Scheme               *runtime.Scheme
-	IronicClient         ironic.NodeClient
-	ProvisioningProvider provisioning.ProvisioningProvider
-
-	// RecheckInterval is the interval for polling Ironic until power state matches desired state.
-	RecheckInterval time.Duration
-
-	// ProvisionPollInterval is the interval for polling AAP job status.
+	Scheme                *runtime.Scheme
+	ManagementClient      management.Client
+	ProvisioningProvider  provisioning.ProvisioningProvider
+	RecheckInterval       time.Duration
 	ProvisionPollInterval time.Duration
 }
 
-// NewHostLeaseReconciler creates a new HostLeaseReconciler with defaults applied.
 func NewHostLeaseReconciler(
 	client client.Client,
 	scheme *runtime.Scheme,
-	ironicClient ironic.NodeClient,
+	managementClient management.Client,
 	provider provisioning.ProvisioningProvider,
 	recheckInterval time.Duration,
 ) *HostLeaseReconciler {
@@ -71,7 +64,7 @@ func NewHostLeaseReconciler(
 	return &HostLeaseReconciler{
 		Client:                client,
 		Scheme:                scheme,
-		IronicClient:          ironicClient,
+		ManagementClient:      managementClient,
 		ProvisioningProvider:  provider,
 		RecheckInterval:       recheckInterval,
 		ProvisionPollInterval: DefaultProvisionPollInterval,
@@ -143,34 +136,44 @@ func (r *HostLeaseReconciler) handleUpdate(ctx context.Context, hostLease *v1alp
 		}
 	}
 
-	node, err := r.IronicClient.GetNode(ctx, hostLease.Spec.ExternalHostID)
+	powerStatus, err := r.ManagementClient.GetPowerState(ctx, hostLease.Spec.ExternalHostID)
 	if err != nil {
-		log.Error(err, "failed to get Ironic node", "nodeID", hostLease.Spec.ExternalHostID)
+		log.Error(err, "failed to get power state", "nodeID", hostLease.Spec.ExternalHostID)
 		r.syncHostLeaseStatus(hostLease, nil, err, log)
 		return ctrl.Result{}, err
 	}
-	log.V(1).Info("Ironic node", "nodeID", hostLease.Spec.ExternalHostID, "power_state", node.PowerState)
+	if powerStatus == nil {
+		err := fmt.Errorf("management backend returned nil power status for host %s", hostLease.Spec.ExternalHostID)
+		log.Error(err, "unexpected nil power status", "nodeID", hostLease.Spec.ExternalHostID)
+		r.syncHostLeaseStatus(hostLease, nil, err, log)
+		return ctrl.Result{}, err
+	}
+	log.V(1).Info("Host power state", "nodeID", hostLease.Spec.ExternalHostID, "power_state", powerStatus.State)
 
 	if hostLease.Spec.PoweredOn != nil {
-		if err := r.reconcilePower(ctx, hostLease, node, log); err != nil {
+		if err := r.reconcilePower(ctx, hostLease, powerStatus, log); err != nil {
 			r.syncHostLeaseStatus(hostLease, nil, err, log)
 			return ctrl.Result{}, err
 		}
 
-		node, err = r.IronicClient.GetNode(ctx, hostLease.Spec.ExternalHostID)
+		powerStatus, err = r.ManagementClient.GetPowerState(ctx, hostLease.Spec.ExternalHostID)
 		if err != nil {
-			log.Error(err, "failed to refresh node after power reconciliation", "nodeID", hostLease.Spec.ExternalHostID)
+			log.Error(err, "failed to refresh power state after reconciliation", "nodeID", hostLease.Spec.ExternalHostID)
+			r.syncHostLeaseStatus(hostLease, nil, err, log)
+			return ctrl.Result{}, err
+		}
+		if powerStatus == nil {
+			err := fmt.Errorf("management backend returned nil power status for host %s", hostLease.Spec.ExternalHostID)
+			log.Error(err, "unexpected nil power status after reconciliation", "nodeID", hostLease.Spec.ExternalHostID)
 			r.syncHostLeaseStatus(hostLease, nil, err, log)
 			return ctrl.Result{}, err
 		}
 	}
 
-	r.syncHostLeaseStatus(hostLease, node, nil, log)
+	r.syncHostLeaseStatus(hostLease, powerStatus, nil, log)
 
 	if hostLease.Spec.PoweredOn != nil {
-		currentlyOn := node.PowerState == ironic.PowerOn.String()
-		if *hostLease.Spec.PoweredOn != currentlyOn {
-			hostLease.Status.Phase = v1alpha1.HostLeasePhaseProgressing
+		if powerStatus.IsTransitioning || *hostLease.Spec.PoweredOn != (powerStatus.State == management.PowerOn) {
 			return ctrl.Result{RequeueAfter: r.RecheckInterval}, nil
 		}
 	}
@@ -303,38 +306,41 @@ func (r *HostLeaseReconciler) validateOpenStackHost(hostLease *v1alpha1.HostLeas
 	return true
 }
 
-func (r *HostLeaseReconciler) reconcilePower(ctx context.Context, hostLease *v1alpha1.HostLease, node *nodes.Node, log logr.Logger) error {
-	currentlyOn := node.PowerState == ironic.PowerOn.String()
+func (r *HostLeaseReconciler) reconcilePower(ctx context.Context, hostLease *v1alpha1.HostLease, powerStatus *management.PowerStatus, log logr.Logger) error {
+	currentlyOn := powerStatus.State == management.PowerOn
 	desiredOn := *hostLease.Spec.PoweredOn
 
-	// If Ironic is already processing a power state change, skip to avoid 409 Conflict.
-	if r.IronicClient.IsNodePowerTransitioning(node) {
+	if powerStatus.IsTransitioning {
 		log.V(1).Info("Node is transitioning, skipping power action",
-			"nodeID", hostLease.Spec.ExternalHostID,
-			"targetPowerState", node.TargetPowerState)
+			"nodeID", hostLease.Spec.ExternalHostID)
 		return nil
 	}
 
-	var err error
 	needsPowerUpdate := desiredOn != currentlyOn
 	if !needsPowerUpdate {
-		log.Info("Power state already matches desired", "poweredOn", desiredOn, "power_state", node.PowerState)
+		log.Info("Power state already matches desired", "poweredOn", desiredOn, "power_state", powerStatus.State)
 		return nil
 	}
 
-	targetState := ironic.PowerOff
+	targetState := management.PowerOff
 	action := "off"
 	if desiredOn {
-		targetState = ironic.PowerOn
+		targetState = management.PowerOn
 		action = "on"
 	}
 
 	log.Info("Powering "+action+" node", "nodeID", hostLease.Spec.ExternalHostID)
-	if err = r.IronicClient.SetPowerState(ctx, hostLease.Spec.ExternalHostID, targetState); err != nil {
+	if err := r.ManagementClient.SetPowerState(ctx, hostLease.Spec.ExternalHostID, targetState); err != nil {
+		if errors.Is(err, management.ErrTransitioning) {
+			log.Info("Node is transitioning (conflict), will retry",
+				"nodeID", hostLease.Spec.ExternalHostID)
+			return nil
+		}
 		log.Error(err, "failed to power "+action+" node", "nodeID", hostLease.Spec.ExternalHostID)
+		return err
 	}
 
-	return err
+	return nil
 }
 
 func (r *HostLeaseReconciler) reconcileProvisioning(ctx context.Context, hostLease *v1alpha1.HostLease) (ctrl.Result, error) {
@@ -393,8 +399,7 @@ func (r *HostLeaseReconciler) reconcileProvisioning(ctx context.Context, hostLea
 	return result, nil
 }
 
-// syncHostLeaseStatus syncs power-related conditions and observed power state in memory.
-func (r *HostLeaseReconciler) syncHostLeaseStatus(hostLease *v1alpha1.HostLease, node *nodes.Node, reconcileErr error, log logr.Logger) {
+func (r *HostLeaseReconciler) syncHostLeaseStatus(hostLease *v1alpha1.HostLease, powerStatus *management.PowerStatus, reconcileErr error, log logr.Logger) {
 	if reconcileErr != nil {
 		hostLease.Status.Phase = v1alpha1.HostLeasePhaseFailed
 		hostLease.SetStatusCondition(
@@ -407,13 +412,17 @@ func (r *HostLeaseReconciler) syncHostLeaseStatus(hostLease *v1alpha1.HostLease,
 		return
 	}
 
-	if node == nil {
+	if powerStatus == nil {
 		return
 	}
 
-	poweredOn := node.PowerState == ironic.PowerOn.String()
+	poweredOn := powerStatus.State == management.PowerOn
 	hostLease.Status.PoweredOn = &poweredOn
 
+	if powerStatus.IsTransitioning {
+		return
+	}
+
 	if hostLease.Spec.PoweredOn != nil && *hostLease.Spec.PoweredOn != poweredOn {
 		hostLease.SetStatusCondition(
 			v1alpha1.HostConditionPowerSynced,