Request microversion 1.109 for health API support

The Health field on Ironic nodes requires API microversion 1.109 or
later. Without requesting this version, Ironic omits the field from
responses and health is permanently reported as Unknown.

- Add HasHealthAPI() feature check for microversion >= 1.109
- Update ChooseMicroversion() to negotiate 1.109 when available
- Guard GetHealth() to skip the getNode() call when Ironic is too old
- Suppress ErrNeedsRegistration log noise in GetHealth() since it is
  expected before host registration

Signed-off-by: Jacob Anders <jacob-anders-dev@proton.me>
Assisted-by: Claude (claude-4.6-opus-high-thinking)
(cherry picked from commit 751c99a58201f39ba937ff19cfe79b8d5f0718ac)

Author: jacob-anders

pkg/provisioner/ironic/clients/features.go

@@ -45,7 +45,8 @@ func (af AvailableFeatures) Log(logger logr.Logger) {
 		"maxVersion", fmt.Sprintf("1.%d", af.MaxVersion),
 		"chosenVersion", af.ChooseMicroversion(),
 		"virtualMediaGET", af.HasVirtualMediaGetAPI(),
-		"disablePowerOff", af.HasDisablePowerOff())
+		"disablePowerOff", af.HasDisablePowerOff(),
+		"healthAPI", af.HasHealthAPI())
 }
 
 func (af AvailableFeatures) HasVirtualMediaGetAPI() bool {
@@ -56,7 +57,15 @@ func (af AvailableFeatures) HasDisablePowerOff() bool {
 	return af.MaxVersion >= 95 //nolint:mnd
 }
 
+func (af AvailableFeatures) HasHealthAPI() bool {
+	return af.MaxVersion >= 109 //nolint:mnd
+}
+
 func (af AvailableFeatures) ChooseMicroversion() string {
+	if af.HasHealthAPI() {
+		return "1.109"
+	}
+
 	if af.HasDisablePowerOff() {
 		return "1.95"
 	}

pkg/provisioner/ironic/clients/features_test.go

@@ -6,7 +6,6 @@ import (
 )
 
 func TestAvailableFeatures_ChooseMicroversion(t *testing.T) {
-	microVersion := "1.95"
 	type fields struct {
 		MaxVersion int
 	}
@@ -16,25 +15,39 @@ func TestAvailableFeatures_ChooseMicroversion(t *testing.T) {
 		want    string
 	}{
 		{
-			name: fmt.Sprintf("MaxVersion < %d return microversion %s", 89, baselineVersionString),
+			name: fmt.Sprintf("MaxVersion < %d return microversion %s", baseline, baselineVersionString),
 			feature: fields{
 				MaxVersion: 50,
 			},
 			want: baselineVersionString,
 		},
 		{
-			name: fmt.Sprintf("MaxVersion = %d return %s", 89, microVersion),
+			name: "MaxVersion = 95 return 1.95",
 			feature: fields{
 				MaxVersion: 95,
 			},
-			want: microVersion,
+			want: "1.95",
 		},
 		{
-			name: fmt.Sprintf("MaxVersion > %d return %s", 89, microVersion),
+			name: "MaxVersion between 95 and 109 return 1.95",
 			feature: fields{
 				MaxVersion: 100,
 			},
-			want: microVersion,
+			want: "1.95",
+		},
+		{
+			name: "MaxVersion = 109 return 1.109",
+			feature: fields{
+				MaxVersion: 109,
+			},
+			want: "1.109",
+		},
+		{
+			name: "MaxVersion > 109 return 1.109",
+			feature: fields{
+				MaxVersion: 120,
+			},
+			want: "1.109",
 		},
 	}
 	for _, tt := range tests {

pkg/provisioner/ironic/ironic.go

@@ -1990,3 +1990,20 @@ func (p *ironicProvisioner) HasPowerFailure(ctx context.Context) bool {
 	}
 	return node.Fault == "power failure"
 }
+
+// TODO(jacobanders): GetHealth calls getNode() which makes an additional HTTP
+// request to Ironic on every reconcile. Consider passing the node object through
+// computeConditions or caching it per reconcile cycle to avoid redundant calls.
+func (p *ironicProvisioner) GetHealth(ctx context.Context) string {
+	if !p.availableFeatures.HasHealthAPI() {
+		return ""
+	}
+	node, err := p.getNode(ctx)
+	if err != nil {
+		if !errors.Is(err, provisioner.ErrNeedsRegistration) {
+			p.log.Error(err, "ignored error while checking health status")
+		}
+		return ""
+	}
+	return node.Health
+}

pkg/provisioner/ironic/power_test.go

@@ -462,3 +462,66 @@ func TestSoftPowerOffFallback(t *testing.T) {
 	require.Error(t, err)
 	assert.ErrorAs(t, err, &softPowerOffUnsupportedError{})
 }
+
+func TestGetHealth(t *testing.T) {
+	nodeUUID := "33ce8659-7400-4c68-9535-d10766f07a58"
+	cases := []struct {
+		name           string
+		ironic         *testserver.IronicMock
+		expectedHealth string
+	}{
+		{
+			name: "healthy node",
+			ironic: testserver.NewIronic(t).Node(nodes.Node{
+				UUID:   nodeUUID,
+				Health: provisioner.HealthOK,
+			}),
+			expectedHealth: provisioner.HealthOK,
+		},
+		{
+			name: "warning health",
+			ironic: testserver.NewIronic(t).Node(nodes.Node{
+				UUID:   nodeUUID,
+				Health: provisioner.HealthWarning,
+			}),
+			expectedHealth: provisioner.HealthWarning,
+		},
+		{
+			name: "critical health",
+			ironic: testserver.NewIronic(t).Node(nodes.Node{
+				UUID:   nodeUUID,
+				Health: provisioner.HealthCritical,
+			}),
+			expectedHealth: provisioner.HealthCritical,
+		},
+		{
+			name: "empty health",
+			ironic: testserver.NewIronic(t).Node(nodes.Node{
+				UUID: nodeUUID,
+			}),
+			expectedHealth: "",
+		},
+		{
+			name:           "node not found returns empty",
+			ironic:         testserver.NewIronic(t).NoNode(nodeUUID),
+			expectedHealth: "",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			tc.ironic.Start()
+			defer tc.ironic.Stop()
+
+			host := makeHost()
+			host.Status.Provisioning.ID = nodeUUID
+			auth := clients.AuthConfig{Type: clients.NoAuth}
+			prov, err := newProvisionerWithSettings(host, bmc.Credentials{}, nullEventPublisher, tc.ironic.Endpoint(), auth)
+			require.NoError(t, err)
+			prov.availableFeatures = clients.AvailableFeatures{MaxVersion: 109}
+
+			health := prov.GetHealth(t.Context())
+			assert.Equal(t, tc.expectedHealth, health)
+		})
+	}
+}