MTV-4498 | Add checking for related storage class space for conversio… (#4865)

…nTempStorageSize

Check CSIStorageCapacity when conversionTempStorageClass and
conversionTempStorageSize are set. Block migration (critical condition)
when the storage class reports insufficient capacity; add advisory
warning when capacity cannot be verified. Register storage/v1 in
controller scheme for CSIStorageCapacity list.

RESOLVES: MTV-4498
https://issues.redhat.com/browse/MTV-4498

Signed-off-by: Gwen Casey <gcasey@redhat.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

Author: gwencasey96

cmd/forklift-controller/main.go

@@ -33,6 +33,7 @@ import (
 	template "github.com/openshift/api/template/v1"
 	"github.com/pkg/profile"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+	storagev1 "k8s.io/api/storage/v1"
 	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
 	cnv "kubevirt.io/api/core/v1"
 	export "kubevirt.io/api/export/v1alpha1"
@@ -113,6 +114,10 @@ func main() {
 		log.Error(err, "unable to add K8s APIs to scheme")
 		os.Exit(1)
 	}
+	if err := storagev1.AddToScheme(mgr.GetScheme()); err != nil {
+		log.Error(err, "unable to add storage APIs to scheme")
+		os.Exit(1)
+	}
 	if err := net.AddToScheme(mgr.GetScheme()); err != nil {
 		log.Error(err, "unable to add CNI APIs to scheme")
 		os.Exit(1)

pkg/controller/plan/validation.go

@@ -30,6 +30,7 @@ import (
 	"github.com/kubev2v/forklift/pkg/templateutil"
 	batchv1 "k8s.io/api/batch/v1"
 	core "k8s.io/api/core/v1"
+	storagev1 "k8s.io/api/storage/v1"
 	k8serr "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/api/resource"
 	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -1953,7 +1954,7 @@ func (r *Reconciler) validateConversionTempStorage(plan *api.Plan) error {
 	}
 
 	// Validate that storageSize is a valid Kubernetes resource quantity
-	_, err := resource.ParseQuantity(storageSize)
+	requestedQty, err := resource.ParseQuantity(storageSize)
 	if err != nil {
 		conversionTempStorageSizeInvalid := libcnd.Condition{
 			Type:     NotValid,
@@ -1967,6 +1968,72 @@ func (r *Reconciler) validateConversionTempStorage(plan *api.Plan) error {
 		return nil
 	}
 
+	// Check CSIStorageCapacity when available: block migration if storage class
+	// reports insufficient capacity for the requested conversion temp volume size.
+	if err := r.validateConversionTempStorageCapacity(plan, storageClass, requestedQty); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// validateConversionTempStorageCapacity checks CSIStorageCapacity for the given
+// storage class. If any entry reports capacity sufficient for the requested size
+// (MaximumVolumeSize or Capacity >= requested), the check passes. If entries exist
+// but none have sufficient capacity, a blocking condition is set. If no entries
+// exist for the storage class, an advisory warning is set.
+func (r *Reconciler) validateConversionTempStorageCapacity(plan *api.Plan, storageClassName string, requested resource.Quantity) error {
+	ctx := context.Background()
+	list := &storagev1.CSIStorageCapacityList{}
+	if err := r.Client.List(ctx, list, client.InNamespace(core.NamespaceAll)); err != nil {
+		r.Log.Info("Could not list CSIStorageCapacity (capacity check skipped)", "error", err.Error(), "storageClass", storageClassName)
+		plan.Status.SetCondition(libcnd.Condition{
+			Type:     NotValid,
+			Status:   True,
+			Category: api.CategoryAdvisory,
+			Message:  fmt.Sprintf("Storage capacity for ConversionTempStorageClass %q could not be verified. Ensure sufficient space is available.", storageClassName),
+			Items:    []string{},
+		})
+		return nil
+	}
+
+	var matching []storagev1.CSIStorageCapacity
+	for i := range list.Items {
+		if list.Items[i].StorageClassName == storageClassName {
+			matching = append(matching, list.Items[i])
+		}
+	}
+
+	if len(matching) == 0 {
+		plan.Status.SetCondition(libcnd.Condition{
+			Type:     NotValid,
+			Status:   True,
+			Category: api.CategoryAdvisory,
+			Message:  fmt.Sprintf("No capacity information found for ConversionTempStorageClass %q. Ensure sufficient space is available.", storageClassName),
+			Items:    []string{},
+		})
+		return nil
+	}
+
+	for _, cap := range matching {
+		// Prefer MaximumVolumeSize (largest single volume); fall back to Capacity (available space).
+		if cap.MaximumVolumeSize != nil && cap.MaximumVolumeSize.Cmp(requested) >= 0 {
+			return nil
+		}
+		if cap.MaximumVolumeSize == nil && cap.Capacity != nil && cap.Capacity.Cmp(requested) >= 0 {
+			return nil
+		}
+	}
+
+	// Have capacity info but no entry can satisfy the requested size
+	plan.Status.SetCondition(libcnd.Condition{
+		Type:     NotValid,
+		Status:   True,
+		Category: api.CategoryCritical,
+		Message:  fmt.Sprintf("Insufficient space in storage class %q for conversion temp storage (requested %s). Migration may fail.", storageClassName, requested.String()),
+		Items:    []string{},
+	})
+	r.Log.Info("Conversion temp storage capacity insufficient", "storageClass", storageClassName, "requested", requested.String(), "plan", plan.Name, "namespace", plan.Namespace)
 	return nil
 }
 

pkg/controller/plan/validation_test.go

@@ -15,6 +15,8 @@ import (
 	ginkgo "github.com/onsi/ginkgo/v2"
 	"github.com/onsi/gomega"
 	core "k8s.io/api/core/v1"
+	storagev1 "k8s.io/api/storage/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
 	meta "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/version"
@@ -472,7 +474,12 @@ var _ = ginkgo.Describe("Plan Validations", func() {
 			source.Status.Conditions.SetCondition(libcnd.Condition{Type: libcnd.Ready, Status: libcnd.True})
 			destination.Status.Conditions.SetCondition(libcnd.Condition{Type: libcnd.Ready, Status: libcnd.True})
 
-			reconciler = createFakeReconciler(secret, plan, source, destination)
+			csiCap := &storagev1.CSIStorageCapacity{
+				ObjectMeta:       meta.ObjectMeta{Name: "fast-ssd-cap", Namespace: "kube-system"},
+				StorageClassName: "fast-ssd",
+				Capacity:         ptr.To(resource.MustParse("100Gi")),
+			}
+			reconciler = createFakeReconciler(secret, plan, source, destination, csiCap)
 			err := reconciler.validateConversionTempStorage(plan)
 
 			gomega.Expect(err).NotTo(gomega.HaveOccurred())
@@ -554,25 +561,61 @@ var _ = ginkgo.Describe("Plan Validations", func() {
 			gomega.Expect(condition.Message).To(gomega.ContainSubstring("is not a valid Kubernetes resource quantity"))
 		})
 
-		ginkgo.It("should pass with valid size formats", func() {
+		ginkgo.It("should pass with valid size formats when CSIStorageCapacity has sufficient capacity", func() {
 			secret := createSecret(sourceSecretName, sourceNamespace, false)
 			source := createProvider(sourceName, sourceNamespace, "https://source", api.OpenShift, &core.ObjectReference{Name: sourceSecretName, Namespace: sourceNamespace})
 			destination := createProvider(destName, destNamespace, "", api.OpenShift, &core.ObjectReference{})
 			source.Status.Conditions.SetCondition(libcnd.Condition{Type: libcnd.Ready, Status: libcnd.True})
 			destination.Status.Conditions.SetCondition(libcnd.Condition{Type: libcnd.Ready, Status: libcnd.True})
 
+			// Seed CSIStorageCapacity so capacity check passes (2Ti >= all requested sizes)
+			csiCap := &storagev1.CSIStorageCapacity{
+				ObjectMeta:       meta.ObjectMeta{Name: "fast-ssd-cap", Namespace: "kube-system"},
+				StorageClassName: "fast-ssd",
+				Capacity:         ptr.To(resource.MustParse("2Ti")),
+			}
+
 			validSizes := []string{"50Gi", "1Ti", "100Mi", "500G", "2T"}
 			for _, size := range validSizes {
 				plan := createPlan(testPlanName, testNamespace, source, destination)
 				plan.Spec.ConversionTempStorageClass = "fast-ssd"
 				plan.Spec.ConversionTempStorageSize = size
 
-				reconciler = createFakeReconciler(secret, plan, source, destination)
+				reconciler = createFakeReconciler(secret, plan, source, destination, csiCap)
 				err := reconciler.validateConversionTempStorage(plan)
 
 				gomega.Expect(err).NotTo(gomega.HaveOccurred(), "Size %s should be valid", size)
-				gomega.Expect(plan.Status.HasCondition(NotValid)).To(gomega.BeFalse(), "Size %s should not cause validation error", size)
+				gomega.Expect(plan.Status.HasBlockerCondition()).To(gomega.BeFalse(), "Size %s should not cause blocking validation error", size)
+			}
+		})
+
+		ginkgo.It("should block when CSIStorageCapacity reports insufficient capacity", func() {
+			secret := createSecret(sourceSecretName, sourceNamespace, false)
+			source := createProvider(sourceName, sourceNamespace, "https://source", api.OpenShift, &core.ObjectReference{Name: sourceSecretName, Namespace: sourceNamespace})
+			destination := createProvider(destName, destNamespace, "", api.OpenShift, &core.ObjectReference{})
+			plan := createPlan(testPlanName, testNamespace, source, destination)
+			plan.Spec.ConversionTempStorageClass = "ocs-storagecluster-ceph-rbd"
+			plan.Spec.ConversionTempStorageSize = "1Ti"
+			source.Status.Conditions.SetCondition(libcnd.Condition{Type: libcnd.Ready, Status: libcnd.True})
+			destination.Status.Conditions.SetCondition(libcnd.Condition{Type: libcnd.Ready, Status: libcnd.True})
+
+			// Only 70Gi available - not enough for 1Ti
+			csiCap := &storagev1.CSIStorageCapacity{
+				ObjectMeta:       meta.ObjectMeta{Name: "ceph-cap", Namespace: "openshift-storage"},
+				StorageClassName: "ocs-storagecluster-ceph-rbd",
+				Capacity:         ptr.To(resource.MustParse("70Gi")),
 			}
+
+			reconciler = createFakeReconciler(secret, plan, source, destination, csiCap)
+			err := reconciler.validateConversionTempStorage(plan)
+
+			gomega.Expect(err).NotTo(gomega.HaveOccurred())
+			gomega.Expect(plan.Status.HasBlockerCondition()).To(gomega.BeTrue())
+			cnd := plan.Status.FindCondition(NotValid)
+			gomega.Expect(cnd).NotTo(gomega.BeNil())
+			gomega.Expect(cnd.Category).To(gomega.Equal(api.CategoryCritical))
+			gomega.Expect(cnd.Message).To(gomega.ContainSubstring("Insufficient space"))
+			gomega.Expect(cnd.Message).To(gomega.ContainSubstring("1Ti"))
 		})
 	})
 })
@@ -741,6 +784,7 @@ func createFakeReconciler(objects ...runtime.Object) *Reconciler {
 	scheme := runtime.NewScheme()
 	_ = core.AddToScheme(scheme)
 	_ = k8snet.AddToScheme(scheme)
+	_ = storagev1.AddToScheme(scheme)
 	api.SchemeBuilder.AddToScheme(scheme)
 
 	client := fakeClient.NewClientBuilder().