Added wait to delete pv

Signed-off-by: Avdhoot <[email protected]>

Author: avd-sagare

ocs_ci/ocs/cnv/virtual_machine.py

@@ -655,18 +655,21 @@ def delete(self):
         if self.volume_interface == constants.VM_VOLUME_PVC:
             # Deletes only when PVC & VIS obj exists
             if self.pvc_obj:
+                self.pvc_obj.reload()
+                pv_name = self.pvc_obj.data.get("spec").get("volumeName")
                 self.pvc_obj.delete()
                 self.pvc_obj.ocp.wait_for_delete(
                     resource_name=self.pvc_obj.name, timeout=180
                 )
+                self.pvc_obj.ocp.wait_for_delete(resource_name=pv_name, timeout=300)
             if self.volumeimportsource_obj:
                 self.volumeimportsource_obj.delete()
         elif self.volume_interface == constants.VM_VOLUME_DV:
             # Deletes only when DV obj exists
             if self.dv_obj:
                 self.dv_obj.delete()
                 self.dv_obj.ocp.wait_for_delete(
-                    resource_name=self.dv_obj.name, timeout=180
+                    resource_name=self.dv_obj.name, timeout=300
                 )
         if self.ns_obj:
             self.ns_obj.delete_project(project_name=self.namespace)

ocs_ci/templates/cnv-vm-workload/vm.yaml

@@ -17,7 +17,7 @@ spec:
       architecture: amd64
       domain:
         cpu:
-          cores: 1
+          cores: 2
           sockets: 1
           threads: 1
         devices:
@@ -37,7 +37,7 @@ spec:
           networkInterfaceMultiqueue: true
           rng: {}
         memory:
-          guest: 2Gi
+          guest: 6Gi
         resources: {}
       evictionStrategy: LiveMigrate
       networks:

tests/conftest.py

@@ -9,7 +9,6 @@
 import threading
 import json
 from concurrent.futures.thread import ThreadPoolExecutor
-from concurrent.futures import as_completed
 from datetime import datetime
 from math import floor
 from shutil import copyfile, rmtree
@@ -7314,42 +7313,31 @@ def factory(namespace=None):
         # Load VM configs from cnv_vm_workload yaml
         vm_configs = templating.load_yaml(constants.CNV_VM_WORKLOADS)
 
-        # Function to create a VM using cnv_workload
-        def create_vm(index, vm_config, sc_obj_def_compr, sc_obj_aggressive, namespace):
-            # Determine the storage class based on the compression type
-            if vm_config["sc_compression"] == "default":
-                storageclass = sc_obj_def_compr.name
-            elif vm_config["sc_compression"] == "aggressive":
-                storageclass = sc_obj_aggressive.name
-
-            return cnv_workload(
-                volume_interface=vm_config["volume_interface"],
-                access_mode=vm_config["access_mode"],
-                storageclass=storageclass,
-                pvc_size="30Gi",  # Assuming pvc_size is fixed for all
-                source_url=constants.CNV_FEDORA_SOURCE,  # Assuming source_url is the same for all VMs
-                namespace=namespace,
-            )[index]
-
-        # Use ThreadPoolExecutor for parallel execution
+        # Use ThreadPoolExecutor to create VMs parallel
         with ThreadPoolExecutor() as executor:
-            future_to_vm = {
-                executor.submit(
-                    create_vm,
-                    index,
-                    vm_config,
-                    sc_obj_def_compr,
-                    sc_obj_aggressive,
-                    namespace,
-                ): vm_config
-                for index, vm_config in enumerate(vm_configs["cnv_vm_configs"])
-            }
+            futures = []
+            for vm_config in vm_configs["cnv_vm_configs"]:
+                # Determine the storage class based on the compression type
+                if vm_config["sc_compression"] == "default":
+                    storageclass = sc_obj_def_compr.name
+                elif vm_config["sc_compression"] == "aggressive":
+                    storageclass = sc_obj_aggressive.name
+                future = executor.submit(
+                    cnv_workload,
+                    volume_interface=vm_config["volume_interface"],
+                    access_mode=vm_config["access_mode"],
+                    storageclass=storageclass,
+                    pvc_size="30Gi",  # Assuming pvc_size is fixed for all
+                    source_url=constants.CNV_FEDORA_SOURCE,  # Assuming source_url is the same for all VMs
+                    namespace=namespace,
+                )
+
+                futures.append((future, vm_config["sc_compression"]))
 
-            for future in as_completed(future_to_vm):
-                vm_config = future_to_vm[future]
+            for future, sc_compression in futures:
                 try:
-                    vm_obj = future.result()
-                    if vm_config["sc_compression"] == "aggressive":
+                    vm_obj = future.result()[0]
+                    if sc_compression == "aggressive":
                         vm_list_agg_compr.append(vm_obj)
                     else:
                         vm_list_default_compr.append(vm_obj)