Add QoS cases to the three ONTAP migration suites.

Disks created with min and max IOPS should keep those policies after live, stopped, and offline moves.

Author: sandeeplocharla

test/integration/plugins/ontap/migration/migration_test_base.py

@@ -1245,6 +1245,28 @@ def _root_disk_offering(cls, storage_tag):
         cls._cleanup.insert(0, offering)
         return offering
 
+    def _qos_disk_offering(self, disksize, miniops, maxiops, storage_tag=None):
+        """Create a disk offering that carries fixed min and max IOPS."""
+        data = {
+            "name": "ontap-migration-qos-%d-%d-%d" % (
+                miniops, maxiops, random.randint(0, 999999)
+            ),
+            "displaytext": "ONTAP migration QoS disk",
+            "disksize": disksize,
+            "miniops": miniops,
+            "maxiops": maxiops,
+        }
+        if storage_tag:
+            data["tags"] = storage_tag
+        offering = DiskOffering.create(self.apiClient, data)
+        self.__class__._cleanup.insert(0, offering)
+        return offering
+
+    def _qos_policy_name(self, miniops, maxiops):
+        """Return the ONTAP policy name the driver builds for these IOPS."""
+        svm = str(self.__class__.svm_name).replace(".", "_")
+        return "cs_%d_to_%d_iops_%s" % (miniops, maxiops, svm)
+
     @classmethod
     def _create_ontap_pool(cls, protocol, scope, cluster_id=None):
         config = cls.config_data
@@ -1324,9 +1346,11 @@ def _create_ontap_pool(cls, protocol, scope, cluster_id=None):
         )
         return pool
 
-    def _deploy_vm(self, storage_tag=None, host_id=None):
+    def _deploy_vm(self, storage_tag=None, host_id=None, root_offering=None):
         offering = self._service_offering()
-        root_disk_offering = self._root_disk_offering(storage_tag)
+        root_disk_offering = root_offering or self._root_disk_offering(
+            storage_tag
+        )
         cmd = deployVirtualMachineAPI.deployVirtualMachineCmd()
         cmd.zoneid = self.__class__.zone.id
         cmd.templateid = self.__class__.template_id
@@ -1453,9 +1477,12 @@ def _require_secondary_cluster(cls):
             )
         return cls.secondary_cluster_id
 
-    def _create_data_volume(self, pool):
+    def _create_data_volume(self, pool, offering=None):
         cls = self.__class__
-        offering_id = getattr(cls, "small_disk_offering_id", None)
+        if offering is not None:
+            offering_id = offering.id
+        else:
+            offering_id = getattr(cls, "small_disk_offering_id", None)
         if offering_id is None:
             offering = DiskOffering.create(cls.apiClient, {
                 "name": "ontap-migration-data-%d" % random.randint(0, 999999),
@@ -1475,6 +1502,67 @@ def _create_data_volume(self, pool):
         cls.created_volumes.append(volume)
         return volume
 
+    def _assert_volume_qos(self, volume, protocol, pool, miniops, maxiops):
+        """Check CloudStack IOPS and the destination ONTAP QoS policy."""
+        current = self._get_volume(volume.id)
+        self.assertEqual(int(current.miniops), miniops)
+        self.assertEqual(int(current.maxiops), maxiops)
+        expected = self._qos_policy_name(miniops, maxiops)
+        if protocol.upper() == "NFS3":
+            record = self.__class__.ontap.get_nfs_file(
+                pool.name, current.path
+            )
+        else:
+            record = self.__class__.ontap.get_lun(
+                self.__class__.svm_name,
+                self._backend_name("ISCSI", pool, current),
+            )
+        policy = (record or {}).get("qos_policy") or {}
+        self.assertEqual(
+            policy.get("name"),
+            expected,
+            "Volume %s on %s has QoS %s, expected %s"
+            % (current.id, pool.name, policy.get("name"), expected),
+        )
+        return current
+
+    def _assert_vm_qos(self, vm, protocol, pool, root_iops, data_iops):
+        """Check root and data disks after a VM storage migration."""
+        volumes = self._vm_volumes(vm.id)
+        roots = [
+            volume for volume in volumes
+            if str(getattr(volume, "type", "")).upper() == "ROOT"
+        ]
+        data = [
+            volume for volume in volumes
+            if str(getattr(volume, "type", "")).upper() != "ROOT"
+        ]
+        self.assertEqual(len(roots), 1)
+        self.assertTrue(data)
+        self._assert_volume_qos(
+            roots[0], protocol, pool, root_iops[0], root_iops[1]
+        )
+        for volume in data:
+            self._assert_volume_qos(
+                volume, protocol, pool, data_iops[0], data_iops[1]
+            )
+
+    def _prepare_qos_vm(self, root_iops, data_iops, stop=False):
+        """Deploy a DefaultPrimary VM whose root and data disks have IOPS."""
+        host = self._host_for_cluster(self.__class__.cluster.id)
+        root = self._qos_disk_offering(
+            8, root_iops[0], root_iops[1], self._default_storage_tag()
+        )
+        vm = self._deploy_vm(host_id=host.id, root_offering=root)
+        data = self._create_data_volume(
+            self.__class__.default_pool,
+            self._qos_disk_offering(1, data_iops[0], data_iops[1]),
+        )
+        self._attach_volume(vm, data)
+        if stop:
+            self._stop_vm(vm)
+        return self._get_vm(vm.id)
+
     def _attach_volume(self, vm, volume):
         cmd = attachVolumeAPI.attachVolumeCmd()
         cmd.id = volume.id

test/integration/plugins/ontap/migration/test_01_live_vm_with_storage_migration.py

@@ -24,6 +24,8 @@
   14 relocate one host once, then NFS3 cross-cluster C1/C2/Z cases
   18-21 iSCSI cross-cluster C1/C2/Z cases
   22 reject a cluster-1 pool mapped to a cluster-2 destination host
+  23-26 live QoS migration for NFS3 and iSCSI, including two policies
+  27 live NFS3 move where root and data keep different QoS policies
 """
 
 import unittest
@@ -592,3 +594,38 @@ def test_22_reject_pool_not_reachable_from_destination_host(self):
             destination_pool=dest,
         )
         self._assert_host_snapshot_unchanged(host_snapshot, vm)
+
+    def _live_qos(self, protocol, root_iops, data_iops, second_pool=False):
+        vm = self._prepare_qos_vm(root_iops, data_iops)
+        pool = self._c1a(protocol)
+        vm, pool = self._live_migrate(vm, pool, protocol)
+        self._assert_vm_qos(vm, protocol, pool, root_iops, data_iops)
+        if second_pool:
+            pool = self._c1b(protocol)
+            vm, pool = self._live_migrate(vm, pool, protocol)
+            self._assert_vm_qos(vm, protocol, pool, root_iops, data_iops)
+
+    @attr(tags=["ontap_migration", "live_storage"], required_hardware=True)
+    def test_23_nfs3_qos_default_primary_to_cluster(self):
+        """Live-migrate QoS disks from DefaultPrimary onto NFS3."""
+        self._live_qos("NFS3", (100, 500), (100, 500))
+
+    @attr(tags=["ontap_migration", "live_storage"], required_hardware=True)
+    def test_24_nfs3_qos_cluster_to_cluster(self):
+        """Live-migrate QoS disks between two NFS3 cluster pools."""
+        self._live_qos("NFS3", (100, 500), (100, 500), second_pool=True)
+
+    @attr(tags=["ontap_migration", "live_storage"], required_hardware=True)
+    def test_25_iscsi_qos_default_primary_to_cluster(self):
+        """Live-migrate QoS disks from DefaultPrimary onto iSCSI."""
+        self._live_qos("ISCSI", (100, 500), (100, 500))
+
+    @attr(tags=["ontap_migration", "live_storage"], required_hardware=True)
+    def test_26_iscsi_qos_cluster_to_cluster(self):
+        """Live-migrate QoS disks between two iSCSI cluster pools."""
+        self._live_qos("ISCSI", (100, 500), (100, 500), second_pool=True)
+
+    @attr(tags=["ontap_migration", "live_storage"], required_hardware=True)
+    def test_27_nfs3_qos_root_and_data_different_policies(self):
+        """Live NFS3 move keeps a different QoS policy on each disk."""
+        self._live_qos("NFS3", (100, 500), (200, 800))

test/integration/plugins/ontap/migration/test_02_stopped_vm_storage_migration.py

@@ -40,6 +40,8 @@
   13 reject NFS3-to-iSCSI storage migration
   14 reject iSCSI-to-NFS3 storage migration
   15 reject the stopped-VM API form once the VM is running
+  16-19 stopped QoS migration for NFS3 and iSCSI
+  20 stopped iSCSI move where root and data keep different QoS policies
 
 Migration out of ONTAP into non-ONTAP storage is never requested; the
 DefaultPrimary pool is only ever a source.
@@ -314,3 +316,52 @@ def test_15_reject_running_vm(self):
             "VM is not Stopped",
         )
         self.assertEqual(self._get_vm(vm.id).state, "Running")
+
+    def _stopped_qos(self, protocol, root_iops, data_iops, second_pool=False):
+        vm = self._prepare_qos_vm(root_iops, data_iops, stop=True)
+        volumes = self._vm_volumes(vm.id)
+        source = self._pool_by_id(volumes[0].storageid)
+        pool = self._migration_pool(protocol)
+        self._migrate_stopped_vm_storage(vm, pool)
+        self._assert_migration_success(
+            volumes, pool, protocol, vm=vm,
+            expected_vm_state="Stopped", expected_vm_id=vm.id,
+            source_pool=source,
+        )
+        self._assert_vm_qos(vm, protocol, pool, root_iops, data_iops)
+        if not second_pool:
+            return
+        moved = self._vm_volumes(vm.id)
+        pool = self._migration_pool(protocol, 1)
+        self._migrate_stopped_vm_storage(vm, pool)
+        self._assert_migration_success(
+            moved, pool, protocol, vm=vm,
+            expected_vm_state="Stopped", expected_vm_id=vm.id,
+            source_pool=self._migration_pool(protocol),
+        )
+        self._assert_vm_qos(vm, protocol, pool, root_iops, data_iops)
+
+    @attr(tags=["ontap_migration", "stopped_vm"], required_hardware=True)
+    def test_16_nfs3_qos_default_primary_to_cluster(self):
+        """Move stopped QoS disks from DefaultPrimary onto NFS3."""
+        self._stopped_qos("NFS3", (100, 500), (100, 500))
+
+    @attr(tags=["ontap_migration", "stopped_vm"], required_hardware=True)
+    def test_17_nfs3_qos_cluster_to_cluster(self):
+        """Move stopped QoS disks between two NFS3 cluster pools."""
+        self._stopped_qos("NFS3", (100, 500), (100, 500), second_pool=True)
+
+    @attr(tags=["ontap_migration", "stopped_vm"], required_hardware=True)
+    def test_18_iscsi_qos_default_primary_to_cluster(self):
+        """Move stopped QoS disks from DefaultPrimary onto iSCSI."""
+        self._stopped_qos("ISCSI", (100, 500), (100, 500))
+
+    @attr(tags=["ontap_migration", "stopped_vm"], required_hardware=True)
+    def test_19_iscsi_qos_cluster_to_cluster(self):
+        """Move stopped QoS disks between two iSCSI cluster pools."""
+        self._stopped_qos("ISCSI", (100, 500), (100, 500), second_pool=True)
+
+    @attr(tags=["ontap_migration", "stopped_vm"], required_hardware=True)
+    def test_20_iscsi_qos_root_and_data_different_policies(self):
+        """Stopped iSCSI move keeps a different QoS policy on each disk."""
+        self._stopped_qos("ISCSI", (100, 500), (200, 800))

test/integration/plugins/ontap/migration/test_03_volume_migration.py

@@ -28,6 +28,9 @@
   21 reject running-attached migration without livemigrate
   22 reject running-attached migration with livemigrate
   23 reject migration to the volume's current pool
+  24-25 migrate a detached QoS volume between cluster pools
+  26-27 migrate one attached QoS disk and leave the root disk
+  28 migrate a detached QoS volume from DefaultPrimary onto NFS3
 
 Every successful migration verifies CloudStack identity and attachment state,
 the destination ONTAP object and access state, and source cleanup when the
@@ -488,3 +491,76 @@ def test_23_reject_same_pool(self):
             False,
             "already on the destination storage pool",
         )
+
+    def _detached_qos(self, protocol, miniops, maxiops):
+        source = self._migration_pool(protocol)
+        destination = self._migration_pool(protocol, 1)
+        offering = self._qos_disk_offering(1, miniops, maxiops)
+        volume = self._create_data_volume(source, offering)
+        self._migrate_volume_offline(volume, destination)
+        self._assert_migration_success(
+            [volume], destination, protocol, source_pool=source
+        )
+        self._assert_volume_qos(
+            volume, protocol, destination, miniops, maxiops
+        )
+
+    def _attached_qos_leaves_root(self, protocol):
+        vm = self._prepare_qos_vm((100, 500), (200, 800), stop=True)
+        source = self._migration_pool(protocol)
+        self._migrate_stopped_vm_storage(vm, source)
+        root = self._root_volume(vm)
+        data = [
+            volume for volume in self._vm_volumes(vm.id)
+            if volume.id != root.id
+        ][0]
+        destination = self._migration_pool(protocol, scope="ZONE")
+        self._migrate_volume_offline(data, destination)
+        self._assert_migration_success(
+            [data], destination, protocol, vm=vm,
+            expected_vm_state="Stopped", expected_vm_id=vm.id,
+            source_pool=source,
+        )
+        self._assert_volume_qos(data, protocol, destination, 200, 800)
+        self.assertEqual(self._get_volume(root.id).storageid, source.id)
+        self._assert_volume_qos(root, protocol, source, 100, 500)
+
+    @attr(tags=["ontap_migration", "volume_migration"],
+          required_hardware=True)
+    def test_24_nfs3_qos_detached_cluster_to_cluster(self):
+        """Migrate a detached NFS3 volume that was created with QoS."""
+        self._detached_qos("NFS3", 100, 500)
+
+    @attr(tags=["ontap_migration", "volume_migration"],
+          required_hardware=True)
+    def test_25_iscsi_qos_detached_cluster_to_cluster(self):
+        """Migrate a detached iSCSI volume that was created with QoS."""
+        self._detached_qos("ISCSI", 100, 500)
+
+    @attr(tags=["ontap_migration", "volume_migration"],
+          required_hardware=True)
+    def test_26_nfs3_qos_attached_stopped_vm(self):
+        """Migrate one stopped NFS3 data disk and leave the root disk."""
+        self._attached_qos_leaves_root("NFS3")
+
+    @attr(tags=["ontap_migration", "volume_migration"],
+          required_hardware=True)
+    def test_27_iscsi_qos_attached_stopped_vm(self):
+        """Migrate one stopped iSCSI data disk and leave the root disk."""
+        self._attached_qos_leaves_root("ISCSI")
+
+    @attr(tags=["ontap_migration", "volume_migration"],
+          required_hardware=True)
+    def test_28_nfs3_qos_detached_default_primary_to_ontap(self):
+        """Migrate a QoS volume from DefaultPrimary onto NFS3."""
+        offering = self._qos_disk_offering(1, 100, 500)
+        volume = self._create_data_volume(
+            self.__class__.default_pool, offering
+        )
+        destination = self._migration_pool("NFS3")
+        self._migrate_volume_offline(volume, destination)
+        self._assert_migration_success(
+            [volume], destination, "NFS3",
+            source_pool=self.__class__.default_pool,
+        )
+        self._assert_volume_qos(volume, "NFS3", destination, 100, 500)

test/integration/plugins/ontap/ontap_test_base.py

@@ -624,7 +624,7 @@ def get_lun(self, svm_name, lun_path):
         """Return the ONTAP LUN record for the given full path, or None."""
         data = self._get("/storage/luns",
                          params={"svm.name": svm_name, "name": lun_path,
-                                 "fields": "name,uuid,serial_number,enabled,status,space.size"})
+                                 "fields": "name,uuid,serial_number,qos_policy,enabled,status,space.size"})
         records = data.get("records", [])
         return records[0] if records else None
 
@@ -679,6 +679,24 @@ def list_files_in_volume(self, vol_name, path="/"):
         return [r.get("name", "") for r in resp.get("records", [])
                 if r.get("name") not in (".", "..")]
 
+    def get_nfs_file(self, vol_name, file_name):
+        """Return one file record, including its QoS policy, or None."""
+        vol = self.get_volume(vol_name)
+        if not vol or not vol.get("uuid"):
+            return None
+        from urllib.parse import quote
+        encoded_path = quote("/" + str(file_name), safe="")
+        try:
+            resp = self._get(
+                "/storage/volumes/%s/files/%s" % (vol["uuid"], encoded_path),
+                params={"fields": "name,qos_policy"},
+            )
+        except Exception:
+            return None
+        if isinstance(resp, dict) and resp.get("records"):
+            return resp["records"][0]
+        return resp or None
+
     def _unmap_lun(self, svm_name, lun_uuid):
         """Best-effort removal of all lun-maps for a LUN UUID."""
         try: