feat(nodepool): decouple all platform boot image resolvers from ReleaseImage

Apply the same pattern from CNTRLPLANE-3026 (AWS) to all remaining
platforms: GCP, Azure, PowerVS, OpenStack, and KubeVirt. Each leaf
function now accepts *stream.Stream instead of *releaseinfo.ReleaseImage,
and callers resolve the stream internally via StreamForName("").

- GCP: DefaultNodePoolGCPImage() exported, accepts *stream.Stream
- PowerVS: getPowerVSImage() accepts *stream.Stream
- Azure: getAzureMarketplaceMetadata() accepts *stream.Stream
- OpenStack: OpenstackDefaultImage(), OpenStackReleaseImage(),
  PrefixedClusterImageName() accept *stream.Stream with nil guards
- KubeVirt: defaultImage() accepts *stream.Stream, GetImage()
  resolves stream once and passes to both defaultImage and
  openstack.OpenstackDefaultImage (fallback path)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Signed-off-by: Juan Manuel Parrilla Madrid <jparrill@redhat.com>

Author: jparrill

hypershift-operator/controllers/nodepool/aws.go

@@ -134,6 +134,9 @@ func resolveAWSAMI(hostedCluster *hyperv1.HostedCluster, nodePool *hyperv1.NodeP
 		return ami, nil
 	}
 	// Default behavior for Linux/RHCOS AMIs
+	if releaseImage == nil {
+		return "", fmt.Errorf("release image is nil")
+	}
 	streamMeta, err := releaseImage.StreamForName("")
 	if err != nil {
 		return "", fmt.Errorf("couldn't resolve stream metadata: %w", err)
@@ -365,6 +368,16 @@ func (r *NodePoolReconciler) setAWSConditions(_ context.Context, nodePool *hyper
 			})
 		} else {
 			// Default behavior for Linux/RHCOS AMIs
+			if releaseImage == nil {
+				SetStatusCondition(&nodePool.Status.Conditions, hyperv1.NodePoolCondition{
+					Type:               hyperv1.NodePoolValidPlatformImageType,
+					Status:             corev1.ConditionFalse,
+					Reason:             hyperv1.NodePoolValidationFailedReason,
+					Message:            fmt.Sprintf("Release image metadata is nil for release image %q", nodePool.Spec.Release.Image),
+					ObservedGeneration: nodePool.Generation,
+				})
+				return fmt.Errorf("release image is nil")
+			}
 			streamMeta, err := releaseImage.StreamForName("")
 			if err != nil {
 				SetStatusCondition(&nodePool.Status.Conditions, hyperv1.NodePoolCondition{

hypershift-operator/controllers/nodepool/azure.go

@@ -16,6 +16,7 @@ import (
 	capiazure "sigs.k8s.io/cluster-api-provider-azure/api/v1beta1"
 
 	"github.com/blang/semver"
+	"github.com/coreos/stream-metadata-go/stream"
 )
 
 // dummySSHKey is a base64 encoded dummy SSH public key.
@@ -81,7 +82,11 @@ func defaultAzureNodePoolImage(nodePool *hyperv1.NodePool, releaseImage *release
 	}
 
 	// Extract marketplace metadata from release payload
-	azureMarketplace, err := getAzureMarketplaceMetadata(releaseImage, streamArch)
+	streamMeta, err := releaseImage.StreamForName("")
+	if err != nil {
+		return fmt.Errorf("couldn't resolve stream metadata: %w", err)
+	}
+	azureMarketplace, err := getAzureMarketplaceMetadata(streamMeta, streamArch)
 	if err != nil {
 		return fmt.Errorf("failed to get Azure Marketplace metadata: %w", err)
 	}
@@ -119,13 +124,13 @@ func defaultAzureNodePoolImage(nodePool *hyperv1.NodePool, releaseImage *release
 	return nil
 }
 
-// getAzureMarketplaceMetadata extracts Azure Marketplace metadata from the release payload
-func getAzureMarketplaceMetadata(releaseImage *releaseinfo.ReleaseImage, arch string) (*azureMarketplaceMetadata, error) {
-	if releaseImage.StreamMetadata == nil {
+// getAzureMarketplaceMetadata extracts Azure Marketplace metadata from stream metadata.
+func getAzureMarketplaceMetadata(streamMeta *stream.Stream, arch string) (*azureMarketplaceMetadata, error) {
+	if streamMeta == nil {
 		return nil, nil // No stream metadata available
 	}
 
-	archData, foundArch := releaseImage.StreamMetadata.Architectures[arch]
+	archData, foundArch := streamMeta.Architectures[arch]
 	if !foundArch {
 		return nil, fmt.Errorf("architecture %s not found in stream metadata", arch)
 	}

hypershift-operator/controllers/nodepool/gcp.go

@@ -168,7 +168,11 @@ func resolveGCPImage(nodePool *hyperv1.NodePool, releaseImage *releaseinfo.Relea
 	}
 
 	// Resolve image from release metadata
-	image, err := defaultNodePoolGCPImage(nodePool.Spec.Arch, releaseImage)
+	streamMeta, err := releaseImage.StreamForName("")
+	if err != nil {
+		return "", fmt.Errorf("couldn't resolve stream metadata: %w", err)
+	}
+	image, err := DefaultNodePoolGCPImage(nodePool.Spec.Arch, streamMeta)
 	if err != nil {
 		return "", fmt.Errorf("couldn't discover a GCP image for release image: %w", err)
 	}

hypershift-operator/controllers/nodepool/gcp_test.go

@@ -535,63 +535,55 @@ func TestDefaultNodePoolGCPImage(t *testing.T) {
 	testCases := []struct {
 		name           string
 		arch           string
-		releaseImage   *releaseinfo.ReleaseImage
+		streamMeta     *stream.Stream
 		expectedImage  string
 		expectedErr    bool
 		expectedErrMsg string
 	}{
 		{
 			name: "When stream metadata has project and name for amd64, it should construct image path",
 			arch: hyperv1.ArchitectureAMD64,
-			releaseImage: &releaseinfo.ReleaseImage{
-				StreamMetadata: &stream.Stream{
-					Architectures: map[string]stream.Arch{
-						"x86_64": {
-							Images: stream.Images{
-								Gcp: &stream.GcpImage{
-									Project: "rhcos-cloud",
-									Name:    "rhcos-9-6-20251023-0-gcp-x86-64",
-								},
+			streamMeta: &stream.Stream{
+				Architectures: map[string]stream.Arch{
+					"x86_64": {
+						Images: stream.Images{
+							Gcp: &stream.GcpImage{
+								Project: "rhcos-cloud",
+								Name:    "rhcos-9-6-20251023-0-gcp-x86-64",
 							},
 						},
 					},
 				},
 			},
 			expectedImage: "projects/rhcos-cloud/global/images/rhcos-9-6-20251023-0-gcp-x86-64",
-			expectedErr:   false,
 		},
 		{
 			name: "When stream metadata has project and name for arm64, it should construct image path",
 			arch: hyperv1.ArchitectureARM64,
-			releaseImage: &releaseinfo.ReleaseImage{
-				StreamMetadata: &stream.Stream{
-					Architectures: map[string]stream.Arch{
-						"aarch64": {
-							Images: stream.Images{
-								Gcp: &stream.GcpImage{
-									Project: "rhcos-cloud",
-									Name:    "rhcos-9-6-20251023-0-gcp-aarch64",
-								},
+			streamMeta: &stream.Stream{
+				Architectures: map[string]stream.Arch{
+					"aarch64": {
+						Images: stream.Images{
+							Gcp: &stream.GcpImage{
+								Project: "rhcos-cloud",
+								Name:    "rhcos-9-6-20251023-0-gcp-aarch64",
 							},
 						},
 					},
 				},
 			},
 			expectedImage: "projects/rhcos-cloud/global/images/rhcos-9-6-20251023-0-gcp-aarch64",
-			expectedErr:   false,
 		},
 		{
-			name: "When architecture is not found in release metadata, it should return error",
+			name: "When architecture is not found in stream metadata, it should return error",
 			arch: "unsupported-arch",
-			releaseImage: &releaseinfo.ReleaseImage{
-				StreamMetadata: &stream.Stream{
-					Architectures: map[string]stream.Arch{
-						"x86_64": {
-							Images: stream.Images{
-								Gcp: &stream.GcpImage{
-									Project: "rhcos-cloud",
-									Name:    "rhcos-9-6-20251023-0-gcp-x86-64",
-								},
+			streamMeta: &stream.Stream{
+				Architectures: map[string]stream.Arch{
+					"x86_64": {
+						Images: stream.Images{
+							Gcp: &stream.GcpImage{
+								Project: "rhcos-cloud",
+								Name:    "rhcos-9-6-20251023-0-gcp-x86-64",
 							},
 						},
 					},
@@ -603,13 +595,11 @@ func TestDefaultNodePoolGCPImage(t *testing.T) {
 		{
 			name: "When GCP project and name are empty, it should return error",
 			arch: hyperv1.ArchitectureAMD64,
-			releaseImage: &releaseinfo.ReleaseImage{
-				StreamMetadata: &stream.Stream{
-					Architectures: map[string]stream.Arch{
-						"x86_64": {
-							Images: stream.Images{
-								Gcp: &stream.GcpImage{},
-							},
+			streamMeta: &stream.Stream{
+				Architectures: map[string]stream.Arch{
+					"x86_64": {
+						Images: stream.Images{
+							Gcp: &stream.GcpImage{},
 						},
 					},
 				},
@@ -620,14 +610,12 @@ func TestDefaultNodePoolGCPImage(t *testing.T) {
 		{
 			name: "When GCP project is empty but name is set, it should return error",
 			arch: hyperv1.ArchitectureAMD64,
-			releaseImage: &releaseinfo.ReleaseImage{
-				StreamMetadata: &stream.Stream{
-					Architectures: map[string]stream.Arch{
-						"x86_64": {
-							Images: stream.Images{
-								Gcp: &stream.GcpImage{
-									Name: "rhcos-x86-64",
-								},
+			streamMeta: &stream.Stream{
+				Architectures: map[string]stream.Arch{
+					"x86_64": {
+						Images: stream.Images{
+							Gcp: &stream.GcpImage{
+								Name: "rhcos-x86-64",
 							},
 						},
 					},
@@ -639,14 +627,12 @@ func TestDefaultNodePoolGCPImage(t *testing.T) {
 		{
 			name: "When GCP name is empty but project is set, it should return error",
 			arch: hyperv1.ArchitectureAMD64,
-			releaseImage: &releaseinfo.ReleaseImage{
-				StreamMetadata: &stream.Stream{
-					Architectures: map[string]stream.Arch{
-						"x86_64": {
-							Images: stream.Images{
-								Gcp: &stream.GcpImage{
-									Project: "rhcos-cloud",
-								},
+			streamMeta: &stream.Stream{
+				Architectures: map[string]stream.Arch{
+					"x86_64": {
+						Images: stream.Images{
+							Gcp: &stream.GcpImage{
+								Project: "rhcos-cloud",
 							},
 						},
 					},
@@ -655,13 +641,20 @@ func TestDefaultNodePoolGCPImage(t *testing.T) {
 			expectedErr:    true,
 			expectedErrMsg: "release image metadata has no GCP image for architecture \"amd64\"",
 		},
+		{
+			name:           "When stream metadata is nil, it should return error",
+			arch:           hyperv1.ArchitectureAMD64,
+			streamMeta:     nil,
+			expectedErr:    true,
+			expectedErrMsg: "stream metadata is nil",
+		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			g := NewWithT(t)
 
-			image, err := defaultNodePoolGCPImage(tc.arch, tc.releaseImage)
+			image, err := DefaultNodePoolGCPImage(tc.arch, tc.streamMeta)
 
 			if tc.expectedErr {
 				g.Expect(err).To(HaveOccurred())

hypershift-operator/controllers/nodepool/kubevirt/kubevirt.go

@@ -20,6 +20,7 @@ import (
 
 	capikubevirt "sigs.k8s.io/cluster-api-provider-kubevirt/api/v1alpha1"
 
+	"github.com/coreos/stream-metadata-go/stream"
 	jsonpatch "github.com/evanphx/json-patch/v5"
 	kubevirtv1 "kubevirt.io/api/core/v1"
 	"kubevirt.io/containerized-data-importer-api/pkg/apis/core/v1beta1"
@@ -36,15 +37,15 @@ var LocalStorageVolumes = []string{
 	"hotplug-disks",
 }
 
-func defaultImage(nodePoolArch string, releaseImage *releaseinfo.ReleaseImage) (string, string, error) {
+func defaultImage(nodePoolArch string, streamMeta *stream.Stream) (string, string, error) {
 	var archName string
 	switch nodePoolArch {
 	case hyperv1.ArchitectureS390X:
 		archName = hyperv1.ArchitectureS390X
 	default:
 		archName = hyperv1.ArchAliases[hyperv1.ArchitectureAMD64]
 	}
-	arch, foundArch := releaseImage.StreamMetadata.Architectures[archName]
+	arch, foundArch := streamMeta.Architectures[archName]
 
 	if !foundArch {
 		return "", "", fmt.Errorf("couldn't find OS metadata for architecture %q", archName)
@@ -90,9 +91,13 @@ func GetImage(nodePool *hyperv1.NodePool, releaseImage *releaseinfo.ReleaseImage
 		return newBootImage(imageName, isHTTP), nil
 	}
 
-	imageName, imageHash, err := defaultImage(nodePool.Spec.Arch, releaseImage)
+	streamMeta, err := releaseImage.StreamForName("")
+	if err != nil {
+		return nil, fmt.Errorf("couldn't resolve stream metadata: %w", err)
+	}
+	imageName, imageHash, err := defaultImage(nodePool.Spec.Arch, streamMeta)
 	if err != nil && allowUnsupportedRHCOSVariants(nodePool) {
-		imageName, imageHash, err = openstack.OpenstackDefaultImage(releaseImage)
+		imageName, imageHash, err = openstack.OpenstackDefaultImage(streamMeta)
 		if err != nil {
 			return nil, err
 		}

hypershift-operator/controllers/nodepool/kubevirt/kubevirt_test.go

@@ -1580,7 +1580,7 @@ func TestDefaultImage(t *testing.T) {
 			if testRI == nil {
 				testRI = ri
 			}
-			img, digest, err := defaultImage(tt.arch, testRI)
+			img, digest, err := defaultImage(tt.arch, testRI.StreamMetadata)
 			if tt.expectedError {
 				if err == nil {
 					t.Fatalf("expected error but got nil")

hypershift-operator/controllers/nodepool/nodepool_controller.go

@@ -759,16 +759,13 @@ func defaultNodePoolAMI(region string, specifiedArch string, streamMeta *stream.
 	return regionData.Image, nil
 }
 
-// defaultNodePoolGCPImage returns the default GCP image for a given architecture from release metadata.
-func defaultNodePoolGCPImage(specifiedArch string, releaseImage *releaseinfo.ReleaseImage) (string, error) {
-	if releaseImage == nil {
-		return "", fmt.Errorf("release image is nil, cannot determine GCP image")
-	}
-	if releaseImage.StreamMetadata == nil {
-		return "", fmt.Errorf("release image stream metadata is nil, cannot determine GCP image for architecture %q", specifiedArch)
+// DefaultNodePoolGCPImage returns the default GCP image for a given architecture from stream metadata.
+func DefaultNodePoolGCPImage(specifiedArch string, streamMeta *stream.Stream) (string, error) {
+	if streamMeta == nil {
+		return "", fmt.Errorf("stream metadata is nil, cannot determine GCP image for architecture %q", specifiedArch)
 	}
 
-	arch, foundArch := releaseImage.StreamMetadata.Architectures[hyperv1.ArchAliases[specifiedArch]]
+	arch, foundArch := streamMeta.Architectures[hyperv1.ArchAliases[specifiedArch]]
 	if !foundArch {
 		return "", fmt.Errorf("couldn't find OS metadata for architecture %q", specifiedArch)
 	}

hypershift-operator/controllers/nodepool/nodepool_controller_test.go

@@ -571,8 +571,14 @@ func TestDefaultNodePoolAMI(t *testing.T) {
 		t.Fatalf("failed to parse multi-stream fixture: %v", err)
 	}
 	ri := &releaseinfo.ReleaseImage{StreamMetadata: defaultStream, OSStreams: osStreams}
-	rhel9Stream, _ := ri.StreamForName("rhel-9")
-	rhel10Stream, _ := ri.StreamForName("rhel-10")
+	rhel9Stream, err := ri.StreamForName("rhel-9")
+	if err != nil {
+		t.Fatalf("failed to resolve rhel-9 stream: %v", err)
+	}
+	rhel10Stream, err := ri.StreamForName("rhel-10")
+	if err != nil {
+		t.Fatalf("failed to resolve rhel-10 stream: %v", err)
+	}
 
 	testCases := []struct {
 		name          string

hypershift-operator/controllers/nodepool/openstack.go

@@ -51,7 +51,11 @@ func (c *CAPI) openstackMachineTemplate(templateNameGenerator func(spec any) (st
 }
 func (r *NodePoolReconciler) setOpenStackConditions(ctx context.Context, nodePool *hyperv1.NodePool, hcluster *hyperv1.HostedCluster, _ string, releaseImage *releaseinfo.ReleaseImage) error {
 	if nodePool.Spec.Platform.OpenStack.ImageName == "" {
-		_, err := openstack.OpenStackReleaseImage(releaseImage)
+		streamMeta, err := releaseImage.StreamForName("")
+		if err != nil {
+			return fmt.Errorf("couldn't resolve stream metadata: %w", err)
+		}
+		_, err = openstack.OpenStackReleaseImage(streamMeta)
 		if err != nil {
 			SetStatusCondition(&nodePool.Status.Conditions, hyperv1.NodePoolCondition{
 				Type:               hyperv1.NodePoolValidPlatformImageType,
@@ -89,7 +93,11 @@ func (r *NodePoolReconciler) setOpenStackConditions(ctx context.Context, nodePoo
 // An ORC object will be created or updated with the image spec.
 // The image name will be returned.
 func (r *NodePoolReconciler) reconcileOpenStackImageCR(ctx context.Context, client client.Client, hcluster *hyperv1.HostedCluster, release *releaseinfo.ReleaseImage, nodePool *hyperv1.NodePool) (string, error) {
-	releaseVersion, err := openstack.OpenStackReleaseImage(release)
+	streamMeta, err := release.StreamForName("")
+	if err != nil {
+		return "", fmt.Errorf("couldn't resolve stream metadata: %w", err)
+	}
+	releaseVersion, err := openstack.OpenStackReleaseImage(streamMeta)
 	if err != nil {
 		return "", err
 	}