Implementation of namespaced-volume migration

Author: noctarius

atlas-lib/controlplane/volumes.go

@@ -190,9 +190,15 @@ func (p CreateVolumeParams) toUnderscore(size int) cpapi.UnderscoreCreateParams
 	if p.Namespaced {
 		u.Namespaced = ptr.To(true)
 	}
+	// Always sent, unlike the other optional fields: the CSI driver sends an
+	// explicit 1 for a StorageClass that omits max_namespace_per_subsys, so
+	// omitting it here would make identical inputs depend on the control plane's
+	// own default and could silently produce a shared subsystem.
+	maxNS := 1
 	if p.MaxNamespacePerSubsys > 0 {
-		u.MaxNamespacePerSubsys = ptr.To(p.MaxNamespacePerSubsys)
+		maxNS = p.MaxNamespacePerSubsys
 	}
+	u.MaxNamespacePerSubsys = ptr.To(maxNS)
 	if p.NDCS > 0 {
 		u.Ndcs = ptr.To(p.NDCS)
 	}

helm-charts/charts/simplyblock-operator/crds/storage.simplyblock.io_volumemigrations.yaml

@@ -146,6 +146,14 @@ spec:
                   MigrationUUID is the identifier returned by the storage API when the
                   migration was submitted. Used for polling and cancellation.
                 type: string
+              multiNamespace:
+                description: |-
+                  MultiNamespace records that the volume shares its NVMe subsystem with
+                  sibling volumes ("namespaced" volumes), so moving it may affect more than
+                  one volume. Resolved once when the migration is submitted, from the
+                  StorageClass's max_namespace_per_subsys, and passed to the backend's
+                  ContinueMigration as the batch flag.
+                type: boolean
               phase:
                 description: Phase is the current lifecycle phase of the migration.
                 enum:

operator/api/v1alpha1/volumemigration_types.go

@@ -103,6 +103,13 @@ type VolumeMigrationStatus struct {
 	// Set during the Validating phase; cleared when the phase advances to Running.
 	ValidationJobName string `json:"validationJobName,omitempty"`
 
+	// MultiNamespace records that the volume shares its NVMe subsystem with
+	// sibling volumes ("namespaced" volumes), so moving it may affect more than
+	// one volume. Resolved once when the migration is submitted, from the
+	// StorageClass's max_namespace_per_subsys, and passed to the backend's
+	// ContinueMigration as the batch flag.
+	MultiNamespace bool `json:"multiNamespace,omitempty"`
+
 	// StartedAt is the time the migration was submitted to the storage API.
 	StartedAt *metav1.Time `json:"startedAt,omitempty"`
 

operator/config/crd/bases/storage.simplyblock.io_volumemigrations.yaml

@@ -146,6 +146,14 @@ spec:
                   MigrationUUID is the identifier returned by the storage API when the
                   migration was submitted. Used for polling and cancellation.
                 type: string
+              multiNamespace:
+                description: |-
+                  MultiNamespace records that the volume shares its NVMe subsystem with
+                  sibling volumes ("namespaced" volumes), so moving it may affect more than
+                  one volume. Resolved once when the migration is submitted, from the
+                  StorageClass's max_namespace_per_subsys, and passed to the backend's
+                  ContinueMigration as the batch flag.
+                type: boolean
               phase:
                 description: Phase is the current lifecycle phase of the migration.
                 enum:

operator/dist/install.yaml

@@ -3579,6 +3579,14 @@ spec:
                   MigrationUUID is the identifier returned by the storage API when the
                   migration was submitted. Used for polling and cancellation.
                 type: string
+              multiNamespace:
+                description: |-
+                  MultiNamespace records that the volume shares its NVMe subsystem with
+                  sibling volumes ("namespaced" volumes), so moving it may affect more than
+                  one volume. Resolved once when the migration is submitted, from the
+                  StorageClass's max_namespace_per_subsys, and passed to the backend's
+                  ContinueMigration as the batch flag.
+                type: boolean
               phase:
                 description: Phase is the current lifecycle phase of the migration.
                 enum:

operator/internal/autoplacement/logical_volume_selector.go

@@ -325,9 +325,6 @@ func (lvs *LogicalVolumeSelector) BuildCSIManagedVolumes(ctx context.Context, cl
 	return managed, nil
 }
 
-// storageClassResolver adapts the controller-runtime client to
-// kube.StorageClassResolver, so the rebalancer resolves provisioning Properties
-// through the shared kube package rather than reimplementing the parsing. Gets
 // BuildNamespacedSet returns the set of simplyblock CSI-managed volume UUIDs in
 // the cluster whose StorageClass provisions a multi-namespace NVMe subsystem
 // (max_namespace_per_subsys > 1). Such volumes share a subsystem with sibling

operator/internal/controller/volumemigration_controller.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"time"
 
+	atlaskube "github.com/simplyblock/atlas/kube"
 	"github.com/simplyblock/atlas/ptr"
 	vmigration "github.com/simplyblock/simplyblock-operator/internal/volumemigration"
 	batchv1 "k8s.io/api/batch/v1"
@@ -37,6 +38,7 @@ import (
 // +kubebuilder:rbac:groups="",resources=pods/log,verbs=get
 // +kubebuilder:rbac:groups=storage.simplyblock.io,resources=storageclusters,verbs=get;list;watch
 // +kubebuilder:rbac:groups=storage.simplyblock.io,resources=storageclusters/status,verbs=get;update;patch
+// +kubebuilder:rbac:groups=storage.k8s.io,resources=storageclasses,verbs=get
 
 // VolumeMigrationReconciler reconciles VolumeMigration resources.
 type VolumeMigrationReconciler struct {
@@ -50,6 +52,9 @@ type VolumeMigrationReconciler struct {
 	// otherwise miss a genuinely-running consumer and cause validation to be
 	// skipped for a live volume, breaking its I/O path after cutover.
 	apiReader client.Reader
+	// scResolver reads the StorageClass that provisioned a PV, to tell whether the
+	// volume is namespaced (shares its NVMe subsystem with siblings).
+	scResolver atlaskube.Resolver
 }
 
 // errConsumerNotReady indicates that a pod references the volume's PVC but is not
@@ -161,6 +166,9 @@ func (r *VolumeMigrationReconciler) reconcileStart(
 	vm.Status.ClusterUUID = clusterUUID
 	vm.Status.VolumeUUID = volumeUUID
 	vm.Status.PoolUUID = poolUUID
+	// Resolved here, where the PV (and through it the StorageClass) is at hand, and
+	// persisted so the later continue step needs no second lookup.
+	vm.Status.MultiNamespace = r.isMultiNamespaceMigration(ctx, pv)
 	// SourceNodeUUID and SnapsTotal are populated from GetMigration once status=Running.
 	vm.Status.Connections = conns
 	vm.Status.StartedAt = &now
@@ -174,6 +182,39 @@ func (r *VolumeMigrationReconciler) reconcileStart(
 	return ctrl.Result{Requeue: true}, nil
 }
 
+// isMultiNamespaceMigration reports whether the migration may affect more than
+// one volume, i.e. whether the volume's NVMe subsystem is shared with sibling
+// volumes ("namespaced" volumes). The answer comes from the StorageClass that
+// provisioned the PV: max_namespace_per_subsys > 1
+// (atlaskube.Properties.IsMultiNamespace) makes every volume of the class
+// shared, including one that is currently still the first — and so far only —
+// namespace in its subsystem. The volume's live NSID would be the host-side
+// counterpart, but it is not part of the control plane's volume or migration
+// data and the operator has no host sysfs access to Identify it.
+//
+// A StorageClass that cannot be resolved is treated as single-namespace and
+// logged, the same fail-open stance the rebalancer's namespaced-set collection
+// takes: one unreadable class must not stall a migration.
+func (r *VolumeMigrationReconciler) isMultiNamespaceMigration(
+	ctx context.Context,
+	pv *corev1.PersistentVolume,
+) bool {
+	log := logf.FromContext(ctx)
+
+	props, err := atlaskube.ResolvePropertiesForPV(ctx, r.scResolver, pv)
+	if err != nil {
+		log.Info("Cannot resolve StorageClass for volume; assuming a single-namespace migration",
+			"pv", pv.Name, "error", err.Error())
+		return false
+	}
+	if props.IsMultiNamespace() {
+		log.Info("StorageClass provisions namespaced volumes; migration is namespaced",
+			"pv", pv.Name, "maxNamespacePerSubsys", props.MaxNamespacePerSubsys)
+		return true
+	}
+	return false
+}
+
 // reconcileValidating creates a Job on the target worker node that:
 //  1. Runs `nvme connect` for each connection returned by CreateMigration.
 //  2. Runs `nvme list --verbose` and verifies all new NQNs appear with ANA
@@ -336,7 +377,7 @@ func (r *VolumeMigrationReconciler) performMigration(
 		log.Info("Migration already terminal before continue; advancing to Running for classification",
 			"migration", vm.Status.MigrationUUID, "status", m.Status)
 	case m.Phase == webapi.MigrationPhasePreCreated:
-		if err := r.apiClient.ContinueMigration(ctx, vm.Status.ClusterUUID, vm.Status.PoolUUID, vm.Status.VolumeUUID, vm.Status.MigrationUUID); err != nil {
+		if err := r.apiClient.ContinueMigration(ctx, vm.Status.ClusterUUID, vm.Status.PoolUUID, vm.Status.VolumeUUID, vm.Status.MigrationUUID, vm.Status.MultiNamespace); err != nil {
 			// The continue may have taken effect despite the error. Only a
 			// migration still stuck in pre_created is a genuine start failure
 			// worth cancelling; anything else means it already advanced.
@@ -763,6 +804,7 @@ func (r *VolumeMigrationReconciler) SetupWithManager(
 		return fmt.Errorf("create k8s client for log collection: %w", err)
 	}
 	r.coreClient = k8s.CoreV1()
+	r.scResolver = atlaskube.NewLiveResolver(k8s)
 	// Uncached reader for the consumer-detection decision (see resolveConsumerNodeName).
 	r.apiReader = mgr.GetAPIReader()
 	return ctrl.NewControllerManagedBy(mgr).