Ensure MachineAPI is enabled before trying to use its resources

Currently, NHC only checks if it runs on OCP before trying to access
MachineAPI resources, however not all OCP clusters have MachineAPI
enabled.

This change gets if MachineAPI is enabled and creates resources
accordingly.

Signed-off-by: Carlo Lobrano <[email protected]>

Author: clobrano

controllers/cluster/capabilities.go

@@ -0,0 +1,42 @@
+package cluster
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/rest"
+
+	v1 "github.com/openshift/api/config/v1"
+	configv1 "github.com/openshift/client-go/config/clientset/versioned/typed/config/v1"
+)
+
+type Capabilities struct {
+	HasEtcdPDBQuorum, HasMachineAPI bool
+}
+
+// HasMachineAPICapability returns true if the cluster has the MachineAPI Enabled
+func HasMachineAPICapability(config *rest.Config) (bool, error) {
+	configV1Client, err := configv1.NewForConfig(config)
+	if err != nil {
+		return false, errors.Wrapf(err, "failed to create cluster version client")
+	}
+	cvs, err := configV1Client.ClusterVersions().List(context.Background(), metav1.ListOptions{})
+	if err != nil {
+		return false, errors.Wrapf(err, "failed to get ClusterVersion")
+	}
+
+	for _, cv := range cvs.Items {
+		if cv.Status.Capabilities.EnabledCapabilities == nil {
+			return false, nil
+		}
+		var MachineAPI v1.ClusterVersionCapability = "MachineAPI"
+		for _, capability := range cv.Status.Capabilities.EnabledCapabilities {
+			if capability == MachineAPI {
+				return true, nil
+			}
+		}
+	}
+	return false, nil
+}

controllers/mhc/checker.go

@@ -25,9 +25,9 @@ type Checker interface {
 }
 
 // NewMHCChecker creates a new Checker
-func NewMHCChecker(mgr manager.Manager, onOpenshift bool, mhcEvents chan<- event.GenericEvent) (Checker, error) {
+func NewMHCChecker(mgr manager.Manager, hasMachineAPI bool, mhcEvents chan<- event.GenericEvent) (Checker, error) {
 
-	if !onOpenshift {
+	if !hasMachineAPI {
 		return DummyChecker{}, nil
 	}
 

controllers/nodehealthcheck_controller.go

@@ -84,7 +84,7 @@ type NodeHealthCheckReconciler struct {
 	Recorder                    record.EventRecorder
 	ClusterUpgradeStatusChecker cluster.UpgradeChecker
 	MHCChecker                  mhc.Checker
-	OnOpenShift                 bool
+	Capabilities                cluster.Capabilities
 	MHCEvents                   chan event.GenericEvent
 	controller                  controller.Controller
 	watches                     map[string]struct{}
@@ -162,7 +162,7 @@ func (r *NodeHealthCheckReconciler) Reconcile(ctx context.Context, req ctrl.Requ
 	if err != nil {
 		return result, err
 	}
-	resourceManager := resources.NewManager(r.Client, ctx, r.Log, r.OnOpenShift, leaseManager, r.Recorder)
+	resourceManager := resources.NewManager(r.Client, ctx, r.Log, r.Capabilities.HasMachineAPI, leaseManager, r.Recorder)
 
 	// always check if we need to patch status before we exit Reconcile
 	nhcOrig := nhc.DeepCopy()
@@ -683,8 +683,7 @@ func (r *NodeHealthCheckReconciler) isControlPlaneRemediationAllowed(ctx context
 	}
 
 	// no ongoing control plane remediation, check etcd quorum
-	if !r.OnOpenShift {
-		// etcd quorum PDB is only installed in OpenShift
+	if !r.Capabilities.HasEtcdPDBQuorum {
 		return true, nil
 	}
 	var allowed bool

controllers/suite_test.go

@@ -197,7 +197,7 @@ var _ = BeforeSuite(func() {
 		ClusterUpgradeStatusChecker: upgradeChecker,
 		MHCChecker:                  mhcChecker,
 		MHCEvents:                   mhcEvents,
-		OnOpenShift:                 true,
+		Capabilities:                cluster.Capabilities{HasEtcdPDBQuorum: true, HasMachineAPI: true},
 	}).SetupWithManager(k8sManager)
 	Expect(err).NotTo(HaveOccurred())
 

main.go

@@ -143,8 +143,22 @@ func main() {
 		os.Exit(1)
 	}
 
+	var hasMachineAPI bool
+	if onOpenshift {
+		hasMachineAPI, err := cluster.HasMachineAPICapability(mgr.GetConfig())
+		if err != nil {
+			setupLog.Error(err, "failed to check if MachineAPI is enabled")
+			os.Exit(1)
+		}
+		if hasMachineAPI {
+			setupLog.Info("MachineAPI is enabled")
+		} else {
+			setupLog.Info("MachineAPI is not enabled")
+		}
+	}
+
 	mhcEvents := make(chan event.GenericEvent)
-	mhcChecker, err := mhc.NewMHCChecker(mgr, onOpenshift, mhcEvents)
+	mhcChecker, err := mhc.NewMHCChecker(mgr, hasMachineAPI, mhcEvents)
 	if err != nil {
 		setupLog.Error(err, "unable initialize MHC checker")
 		os.Exit(1)
@@ -154,20 +168,26 @@ func main() {
 		os.Exit(1)
 	}
 
+	clusterCapabilities := cluster.Capabilities{
+		// etcd quorum PDB is only installed in OpenShift
+		HasEtcdPDBQuorum: onOpenshift,
+		HasMachineAPI:    hasMachineAPI,
+	}
+
 	if err := (&controllers.NodeHealthCheckReconciler{
 		Client:                      mgr.GetClient(),
 		Log:                         ctrl.Log.WithName("controllers").WithName("NodeHealthCheck"),
 		Recorder:                    mgr.GetEventRecorderFor("NodeHealthCheck"),
 		ClusterUpgradeStatusChecker: upgradeChecker,
 		MHCChecker:                  mhcChecker,
-		OnOpenShift:                 onOpenshift,
+		Capabilities:                clusterCapabilities,
 		MHCEvents:                   mhcEvents,
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "NodeHealthCheck")
 		os.Exit(1)
 	}
 
-	if onOpenshift {
+	if hasMachineAPI {
 		featureGateMHCControllerDisabledEvents := make(chan event.GenericEvent)
 		featureGateAccessor := featuregates.NewAccessor(mgr.GetConfig(), featureGateMHCControllerDisabledEvents)
 		if err = mgr.Add(featureGateAccessor); err != nil {