Add v1beta2 changes to IBMPowerVSImage

Author: arshadd-b

api/v1beta2/conditions_consts.go

@@ -297,3 +297,20 @@ const (
 	// COSInstanceDeletingV1Beta2Reason surfaces when the COS instance is being deleted.
 	COSInstanceDeletingV1Beta2Reason = capiv1beta1.DeletingV1Beta2Reason
 )
+
+// IBMPowerVSCluster's Ready condition and corresponding reasons that will be used in v1Beta2 API version.
+const (
+	// IBMPowerVSClusterReadyV1Beta2Condition is true if the IBMPowerVSCluster's deletionTimestamp is not set, IBMPowerVSCluster's
+	// FailureDomainsReady, VCenterAvailable and ClusterModulesReady conditions are true.
+	IBMPowerVSImageReadyV1Beta2Condition = capiv1beta1.ReadyV1Beta2Condition
+
+	// IBMPowerVSClusterReadyV1Beta2Reason surfaces when the IBMPowerVSCluster readiness criteria is met.
+	IBMPowerVSImageReadyV1Beta2Reason = capiv1beta1.ReadyV1Beta2Reason
+
+	// IBMPowerVSClusterNotReadyV1Beta2Reason surfaces when the IBMPowerVSCluster readiness criteria is not met.
+	IBMPowerVSImageNotReadyV1Beta2Reason = capiv1beta1.NotReadyV1Beta2Reason
+
+	// IBMPowerVSClusterReadyUnknownV1Beta2Reason surfaces when at least one of the IBMPowerVSCluster readiness criteria is unknown
+	// and none of the IBMPowerVSCluster readiness criteria is met.
+	IBMPowerVSImageReadyUnknownV1Beta2Reason = capiv1beta1.ReadyUnknownV1Beta2Reason
+)

api/v1beta2/ibmpowervsimage_types.go

@@ -94,6 +94,21 @@ type IBMPowerVSImageStatus struct {
 	// Conditions defines current service state of the IBMPowerVSImage.
 	// +optional
 	Conditions clusterv1.Conditions `json:"conditions,omitempty"`
+
+	// v1beta2 groups all the fields that will be added or modified in IBMPowerVSCluster's status with the V1Beta2 version.
+	// +optional
+	V1Beta2 *IBMPowerVSImageV1Beta2Status `json:"v1beta2,omitempty"`
+}
+
+// IBMPowerVSImageV1Beta2Status groups all the fields that will be added or modified in IBMPowerVSCluster with the V1Beta2 version.
+// See https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20240916-improve-status-in-CAPI-resources.md for more context.
+type IBMPowerVSImageV1Beta2Status struct {
+	// conditions represents the observations of a DevCluster's current state.
+	// +optional
+	// +listType=map
+	// +listMapKey=type
+	// +kubebuilder:validation:MaxItems=32
+	Conditions []metav1.Condition `json:"conditions,omitempty"`
 }
 
 //+kubebuilder:object:root=true
@@ -121,6 +136,22 @@ func (r *IBMPowerVSImage) SetV1Beta1Conditions(conditions clusterv1.Conditions)
 	r.Status.Conditions = conditions
 }
 
+// GetConditions returns the set of conditions for this object.
+func (r *IBMPowerVSImage) GetConditions() []metav1.Condition {
+	if r.Status.V1Beta2 == nil {
+		return nil
+	}
+	return r.Status.V1Beta2.Conditions
+}
+
+// SetConditions sets conditions for an API object.
+func (r *IBMPowerVSImage) SetConditions(conditions []metav1.Condition) {
+	if r.Status.V1Beta2 == nil {
+		r.Status.V1Beta2 = &IBMPowerVSImageV1Beta2Status{}
+	}
+	r.Status.V1Beta2.Conditions = conditions
+}
+
 //+kubebuilder:object:root=true
 
 // IBMPowerVSImageList contains a list of IBMPowerVSImage.

api/v1beta2/types.go

@@ -64,6 +64,8 @@ var (
 
 	// PowerVSImageStateImporting is the string representing an image in a failed state.
 	PowerVSImageStateImporting = PowerVSImageState("importing")
+
+	PowerVSImageStateCompleted = PowerVSImageState("completed")
 )
 
 // ServiceInstanceState describes the state of a service instance.

cloud/scope/powervs_image.go

@@ -21,19 +21,16 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/go-logr/logr"
-
 	"github.com/IBM-Cloud/power-go-client/ibmpisession"
 	"github.com/IBM-Cloud/power-go-client/power/models"
 	"github.com/IBM/go-sdk-core/v5/core"
 	"github.com/IBM/platform-services-go-sdk/resourcecontrollerv2"
-
+	"github.com/go-logr/logr"
 	"k8s.io/klog/v2"
 
+	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
-	"sigs.k8s.io/cluster-api/util/patch"
-
 	infrav1beta2 "sigs.k8s.io/cluster-api-provider-ibmcloud/api/v1beta2"
 	"sigs.k8s.io/cluster-api-provider-ibmcloud/pkg/cloud/services/powervs"
 	"sigs.k8s.io/cluster-api-provider-ibmcloud/pkg/cloud/services/resourcecontroller"
@@ -55,9 +52,9 @@ type PowerVSImageScopeParams struct {
 
 // PowerVSImageScope defines a scope defined around a Power VS Cluster.
 type PowerVSImageScope struct {
-	logr.Logger
-	Client      client.Client
-	patchHelper *patch.Helper
+	//logr.Logger
+	Client client.Client
+	//patchHelper *patch.Helper
 
 	IBMPowerVSClient powervs.PowerVS
 	IBMPowerVSImage  *infrav1beta2.IBMPowerVSImage
@@ -83,23 +80,9 @@ func NewPowerVSImageScope(params PowerVSImageScopeParams) (scope *PowerVSImageSc
 	if params.Logger == (logr.Logger{}) {
 		params.Logger = klog.Background()
 	}
-	scope.Logger = params.Logger
-
-	helper, err := patch.NewHelper(params.IBMPowerVSImage, params.Client)
-	if err != nil {
-		err = fmt.Errorf("failed to init patch helper: %w", err)
-		return nil, err
-	}
-	scope.patchHelper = helper
 
 	// Create Resource Controller client.
 	var serviceOption resourcecontroller.ServiceOptions
-	// Fetch the resource controller endpoint.
-	rcEndpoint := endpoints.FetchEndpoints(string(endpoints.RC), params.ServiceEndpoint)
-	if rcEndpoint != "" {
-		serviceOption.URL = rcEndpoint
-		params.Logger.V(3).Info("Overriding the default resource controller endpoint", "ResourceControllerEndpoint", rcEndpoint)
-	}
 
 	rc, err := resourcecontroller.NewService(serviceOption)
 	if err != nil {
@@ -150,7 +133,7 @@ func NewPowerVSImageScope(params PowerVSImageScopeParams) (scope *PowerVSImageSc
 	// Fetch the service endpoint.
 	if svcEndpoint := endpoints.FetchPVSEndpoint(endpoints.ConstructRegionFromZone(*res.RegionID), params.ServiceEndpoint); svcEndpoint != "" {
 		options.IBMPIOptions.URL = svcEndpoint
-		scope.Logger.V(3).Info("overriding the default powervs service endpoint")
+		params.Logger.V(3).Info("overriding the default powervs service endpoint", "serviceEndpoint", svcEndpoint)
 	}
 
 	c, err := powervs.NewService(options)
@@ -179,58 +162,49 @@ func (i *PowerVSImageScope) ensureImageUnique(imageName string) (*models.ImageRe
 }
 
 // CreateImageCOSBucket creates a power vs image.
-func (i *PowerVSImageScope) CreateImageCOSBucket() (*models.ImageReference, *models.JobReference, error) {
-	s := i.IBMPowerVSImage.Spec
+func (i *PowerVSImageScope) CreateImageCOSBucket(ctx context.Context) (*models.ImageReference, *models.JobReference, error) {
+	log := ctrl.LoggerFrom(ctx)
+	imageSpec := i.IBMPowerVSImage.Spec
 	m := i.IBMPowerVSImage.ObjectMeta
 
 	imageReply, err := i.ensureImageUnique(m.Name)
 	if err != nil {
 		record.Warnf(i.IBMPowerVSImage, "FailedRetrieveImage", "Failed to retrieve image %q", m.Name)
 		return nil, nil, err
 	} else if imageReply != nil {
-		i.Info("Image already exists")
+		log.Info("Image already exists")
 		return imageReply, nil, nil
 	}
 
 	if lastJob, _ := i.GetImportJob(); lastJob != nil {
-		if *lastJob.Status.State != "completed" && *lastJob.Status.State != "failed" {
-			i.Info("Previous import job not yet finished", "state", *lastJob.Status.State)
+		if *lastJob.Status.State != string(infrav1beta2.PowerVSImageStateCompleted) && *lastJob.Status.State != string(infrav1beta2.PowerVSImageStateFailed) {
+			log.Info("Previous import job not yet finished", "state", *lastJob.Status.State)
 			return nil, nil, nil
 		}
 	}
 
 	body := &models.CreateCosImageImportJob{
 		ImageName:     &m.Name,
-		BucketName:    s.Bucket,
+		BucketName:    imageSpec.Bucket,
 		BucketAccess:  core.StringPtr(BucketAccess),
-		Region:        s.Region,
-		ImageFilename: s.Object,
-		StorageType:   s.StorageType,
+		Region:        imageSpec.Region,
+		ImageFilename: imageSpec.Object,
+		StorageType:   imageSpec.StorageType,
 	}
 
 	jobRef, err := i.IBMPowerVSClient.CreateCosImage(body)
 	if err != nil {
-		i.Info("Unable to create new import job request")
+		log.Info("Unable to create new import job request")
 		record.Warnf(i.IBMPowerVSImage, "FailedCreateImageImportJob", "Failed image import job creation - %v", err)
 		return nil, nil, err
 	}
-	i.Info("New import job request created")
+	log.Info("New import job request created")
 	record.Eventf(i.IBMPowerVSImage, "SuccessfulCreateImageImportJob", "Created image import job %q", *jobRef.ID)
 	return nil, jobRef, nil
 }
 
-// PatchObject persists the cluster configuration and status.
-func (i *PowerVSImageScope) PatchObject() error {
-	return i.patchHelper.Patch(context.TODO(), i.IBMPowerVSImage)
-}
-
-// Close closes the current scope persisting the cluster configuration and status.
-func (i *PowerVSImageScope) Close() error {
-	return i.PatchObject()
-}
-
 // DeleteImage will delete the image.
-func (i *PowerVSImageScope) DeleteImage() error {
+func (i *PowerVSImageScope) DeleteImage(ctx context.Context) error {
 	if err := i.IBMPowerVSClient.DeleteImage(i.IBMPowerVSImage.Status.ImageID); err != nil {
 		record.Warnf(i.IBMPowerVSImage, "FailedDeleteImage", "Failed image deletion - %v", err)
 		return err
@@ -245,7 +219,7 @@ func (i *PowerVSImageScope) GetImportJob() (*models.Job, error) {
 }
 
 // DeleteImportJob will delete the image import job.
-func (i *PowerVSImageScope) DeleteImportJob() error {
+func (i *PowerVSImageScope) DeleteImportJob(ctx context.Context) error {
 	if err := i.IBMPowerVSClient.DeleteJob(i.IBMPowerVSImage.Status.JobID); err != nil {
 		record.Warnf(i.IBMPowerVSImage, "FailedDeleteImageImportJob", "Failed image import job deletion - %v", err)
 		return err

cloud/scope/powervs_image_test.go

@@ -27,7 +27,6 @@ import (
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes/scheme"
-	"k8s.io/klog/v2"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 
@@ -63,7 +62,6 @@ func setupPowerVSImageScope(imageName string, mockpowervs *mock.MockPowerVS) *Po
 	client := fake.NewClientBuilder().WithScheme(scheme.Scheme).WithObjects(initObjects...).Build()
 	return &PowerVSImageScope{
 		Client:           client,
-		Logger:           klog.Background(),
 		IBMPowerVSClient: mockpowervs,
 		IBMPowerVSImage:  powervsImage,
 	}
@@ -148,7 +146,7 @@ func TestCreateImageCOSBucket(t *testing.T) {
 			mockpowervs.EXPECT().GetAllImage().Return(images, nil)
 			mockpowervs.EXPECT().GetCosImages(gomock.AssignableToTypeOf(serviceInstanceID)).Return(job, nil)
 			mockpowervs.EXPECT().CreateCosImage(gomock.AssignableToTypeOf(body)).Return(jobReference, nil)
-			_, out, err := scope.CreateImageCOSBucket()
+			_, out, err := scope.CreateImageCOSBucket(ctx)
 			g.Expect(err).To(BeNil())
 			require.Equal(t, jobReference, out)
 		})
@@ -162,7 +160,7 @@ func TestCreateImageCOSBucket(t *testing.T) {
 			}
 			scope := setupPowerVSImageScope("foo-image-1", mockpowervs)
 			mockpowervs.EXPECT().GetAllImage().Return(images, nil)
-			out, _, err := scope.CreateImageCOSBucket()
+			out, _, err := scope.CreateImageCOSBucket(ctx)
 			g.Expect(err).To(BeNil())
 			require.Equal(t, imageReference, out)
 		})
@@ -173,7 +171,7 @@ func TestCreateImageCOSBucket(t *testing.T) {
 			t.Cleanup(teardown)
 			scope := setupPowerVSImageScope(pvsImage, mockpowervs)
 			mockpowervs.EXPECT().GetAllImage().Return(images, errors.New("Failed to list images"))
-			_, _, err := scope.CreateImageCOSBucket()
+			_, _, err := scope.CreateImageCOSBucket(ctx)
 			g.Expect(err).To(Not(BeNil()))
 		})
 
@@ -189,7 +187,7 @@ func TestCreateImageCOSBucket(t *testing.T) {
 			scope := setupPowerVSImageScope(pvsImage, mockpowervs)
 			mockpowervs.EXPECT().GetAllImage().Return(images, nil)
 			mockpowervs.EXPECT().GetCosImages(gomock.AssignableToTypeOf(serviceInstanceID)).Return(job, nil)
-			_, _, err := scope.CreateImageCOSBucket()
+			_, _, err := scope.CreateImageCOSBucket(ctx)
 			g.Expect(err).To(BeNil())
 		})
 
@@ -201,7 +199,7 @@ func TestCreateImageCOSBucket(t *testing.T) {
 			mockpowervs.EXPECT().GetAllImage().Return(images, nil)
 			mockpowervs.EXPECT().GetCosImages(gomock.AssignableToTypeOf(serviceInstanceID)).Return(job, nil)
 			mockpowervs.EXPECT().CreateCosImage(gomock.AssignableToTypeOf(body)).Return(jobReference, errors.New("Failed to create image import job"))
-			_, _, err := scope.CreateImageCOSBucket()
+			_, _, err := scope.CreateImageCOSBucket(ctx)
 			g.Expect(err).To((Not(BeNil())))
 		})
 	})
@@ -231,7 +229,7 @@ func TestDeleteImage(t *testing.T) {
 			scope := setupPowerVSImageScope(pvsImage, mockpowervs)
 			scope.IBMPowerVSImage.Status.ImageID = pvsImage + idSuffix
 			mockpowervs.EXPECT().DeleteImage(gomock.AssignableToTypeOf(id)).Return(nil)
-			err := scope.DeleteImage()
+			err := scope.DeleteImage(ctx)
 			g.Expect(err).To(BeNil())
 		})
 
@@ -242,7 +240,7 @@ func TestDeleteImage(t *testing.T) {
 			scope := setupPowerVSImageScope(pvsImage, mockpowervs)
 			scope.IBMPowerVSImage.Status.ImageID = pvsImage + idSuffix
 			mockpowervs.EXPECT().DeleteImage(gomock.AssignableToTypeOf(id)).Return(errors.New("Failed to delete image"))
-			err := scope.DeleteImage()
+			err := scope.DeleteImage(ctx)
 			g.Expect(err).To(Not(BeNil()))
 		})
 	})
@@ -272,7 +270,7 @@ func TestDeleteImportJob(t *testing.T) {
 			scope := setupPowerVSImageScope(pvsImage, mockpowervs)
 			scope.IBMPowerVSImage.Status.JobID = "foo-job-id"
 			mockpowervs.EXPECT().DeleteJob(gomock.AssignableToTypeOf(id)).Return(nil)
-			err := scope.DeleteImportJob()
+			err := scope.DeleteImportJob(ctx)
 			g.Expect(err).To(BeNil())
 		})
 
@@ -283,7 +281,7 @@ func TestDeleteImportJob(t *testing.T) {
 			scope := setupPowerVSImageScope(pvsImage, mockpowervs)
 			scope.IBMPowerVSImage.Status.JobID = "foo-job-id"
 			mockpowervs.EXPECT().DeleteJob(gomock.AssignableToTypeOf(id)).Return(errors.New("Failed to delete image import job"))
-			err := scope.DeleteImportJob()
+			err := scope.DeleteImportJob(ctx)
 			g.Expect(err).To(Not(BeNil()))
 		})
 	})