Refactor storage codeblock in launch flow

Signed-off-by: Manjunath-A-C <[email protected]>

Author: manju956

cli/cmd/launch.py

@@ -125,83 +125,89 @@ def _launch(config, cookies, sys_uuid, vios_uuids):
         logger.info("Installation ISOs attached to the partition")
 
         logger.info("Setting up storage")
-        # Re-run scenario: Check if physical disk or virtual disk is already attached to partition
+        setup_storage(config, cookies, active_vios_servers, sys_uuid, partition_uuid)
+
+        lpar_state = activation.check_lpar_status(config, cookies, partition_uuid)
+        if lpar_state != "running":
+            logger.debug("Setting partition bootstring as 'cd/dvd-all'")
+            partition_payload = partition.get_partition_details(
+                config, cookies, sys_uuid, partition_uuid)
+            partition.set_partition_boot_string(
+                config, cookies, sys_uuid, partition_uuid, partition_payload, "cd/dvd-all")
+
+        logger.info("Activating the partition")
+        activation.activate_partition(config, cookies, partition_uuid)
+        logger.info("Partition activated")
+
+        logger.info("Monitoring boot process, this will take a while")
+        monitor_util.monitor_bootstrap_boot(config)
+        monitor_util.monitor_pim(config)
+    except (AIAppError, AuthError, NetworkError, PartitionError, StorageError, VIOSError, paramiko.SSHException, Exception) as e:
+        raise e
+
+def setup_storage(config, cookies, active_vios, sys_uuid, lpar_id):
+    try:
+        # Re-run scenario: Check if physical disk/virtualdisk/SAN storage(VFC) is already attached to partition
         storage_attached = False
-        for a_vios_uuid, a_vios in active_vios_servers.items():
+        for a_vios_uuid, a_vios in active_vios.items():
             logger.debug(f"Checking for existing physical disk attachment in VIOS '{a_vios_uuid}'")
             physical_disk_found, _ = storage.check_if_storage_attached(
-                a_vios, partition_uuid)
+                a_vios, lpar_id)
             if physical_disk_found:
                 logger.info(
-                    f"Physical disk is already attached to lpar '{partition_uuid}'")
+                    f"Physical disk is already attached to lpar '{lpar_id}'")
                 storage_attached = True
             if not storage_attached:
-                vdisk_found, vdisk_name = storage.check_if_vdisk_attached(a_vios, partition_uuid)
+                vdisk_found, vdisk_name = vstorage.check_if_vdisk_attached(a_vios, lpar_id)
                 if vdisk_found:
-                    logger.info(f"Virtual disk '{vdisk_name}' is already attached to lpar '{partition_uuid}'")
+                    logger.info(f"Virtual disk '{vdisk_name}' is already attached to lpar '{lpar_id}'")
                     storage_attached = True
             if not storage_attached:
                 vfc_disk_found, _ = storage.check_if_vfc_disk_attached(
-                    a_vios, partition_uuid)
+                    a_vios, lpar_id)
                 if vfc_disk_found:
                     logger.info(
-                        f"SAN storage(VFC) disk is already attached to lpar '{partition_uuid}'")
+                        f"SAN storage(VFC) disk is already attached to lpar '{lpar_id}'")
                     storage_attached = True
 
         vdisk_attached = False
-        use_vdisk = util.use_virtual_disk(config)
-        # Create and attach virtual disk to the partition
-        if use_vdisk and not storage_attached:
-            vios_storage_list = vios_operation.get_vios_with_physical_storage(
-                config, active_vios_servers)
-            if len(vios_storage_list) == 0:
-                logger.error(
-                    "failed to find physical volume for the partition")
-                raise StorageError(
-                    "failed to find physical volume for the partition")
-            vios_storage_uuid = vios_storage_list[0][0]
-            updated_vios_payload = vios_operation.get_vios_details(config, cookies, sys_uuid, vios_storage_uuid)
-            use_existing_vd = util.use_existing_vd(config)
-            if use_existing_vd:
-                vstorage.attach_virtualdisk(updated_vios_payload, config, cookies, partition_uuid, sys_uuid, vios_storage_uuid)
-                vdisk_attached = True
-            else:
-                # Create volume group, virtual disk and attach storage
-                use_existing_vg = util.use_existing_vg(config)
-                if not use_existing_vg:
-                    # Create volume group
-                    vg_id = vstorage.create_volumegroup(config, cookies, vios_storage_uuid)
-                else:
-                    vg_id = vstorage.get_volume_group_id(config, cookies, vios_storage_uuid, util.get_volume_group_name(config))
-                    vstorage.create_virtualdisk(config, cookies, vios_storage_uuid, vg_id)
-                    updated_vios_payload = vios_operation.get_vios_details(config, cookies, sys_uuid, vios_storage_uuid)
-                    vstorage.attach_virtualdisk(updated_vios_payload, config, cookies, partition_uuid, sys_uuid, vios_storage_uuid)
-                    vdisk_attached = True
+        if not util.use_physical_volume(config) and not storage_attached:
+            handle_virtual_disk(config, cookies, active_vios, sys_uuid, lpar_id)
+            vdisk_attached = True
 
         if not storage_attached and not vdisk_attached:
             vios_storage_list = vios_operation.get_vios_with_physical_storage(
-                config, active_vios_servers)
+                config, active_vios)
             if len(vios_storage_list) == 0:
                 logger.error(
                     "failed to find physical volume for the partition")
                 raise StorageError(
                     "failed to find physical volume for the partition")
             storage.attach_physical_storage(
-                config, cookies, sys_uuid, partition_uuid, vios_storage_list)
-
-        partition_payload = partition.get_partition_details(
-            config, cookies, sys_uuid, partition_uuid)
-        logger.debug("Setting partition bootstring as 'cd/dvd-all'")
-        partition.set_partition_boot_string(
-            config, cookies, sys_uuid, partition_uuid, partition_payload, "cd/dvd-all")
+                config, cookies, sys_uuid, lpar_id, vios_storage_list)
+    except (StorageError, VIOSError, Exception) as e:
+        raise e
 
-        logger.info("Activating the partition")
-        activation.activate_partition(config, cookies, partition_uuid)
-        logger.info("Partition activated")
+def handle_virtual_disk(config, cookies, active_vios, sys_uuid, lpar_id):
+    try:
+        vios_storage_list = vios_operation.get_vios_with_physical_storage(
+            config, active_vios)
+        if len(vios_storage_list) == 0:
+            logger.error("failed to find physical volume for the partition")
+            raise StorageError("failed to find physical volume for the partition")
+        vios_storage_uuid = vios_storage_list[0][0]
+        updated_vios_payload = vios_operation.get_vios_details(config, cookies, sys_uuid, vios_storage_uuid)
+
+        # Check if virtual storage already exists under the given volumegroup
+        vg_id = vstorage.get_volume_group_id(config, cookies, vios_storage_uuid, util.get_volume_group_name(config))
+        found, _, _ = vstorage.check_if_vdisk_exists(config, cookies, vios_storage_uuid, vg_id, util.get_virtual_disk_name(config))
+        # Create virtualdisk only if it doesn't exist under volumegroup
+        if not found:
+            vstorage.create_virtualdisk(config, cookies, vios_storage_uuid, vg_id)
+            updated_vios_payload = vios_operation.get_vios_details(config, cookies, sys_uuid, vios_storage_uuid)
 
-        logger.info("Monitoring boot process, this will take a while")
-        monitor_util.monitor_bootstrap_boot(config)
-        monitor_util.monitor_pim(config)
-    except (AIAppError, AuthError, NetworkError, PartitionError, StorageError, VIOSError, paramiko.SSHException, Exception) as e:
+        vstorage.attach_virtualdisk(updated_vios_payload, config, cookies, lpar_id, sys_uuid, vios_storage_uuid)
+    except (StorageError, VIOSError, Exception) as e:
         raise e
-
+    logger.info(f"virtualdisk is attached to parition '{lpar_id}' successfully")
+    return

cli/storage/storage.py

@@ -67,34 +67,6 @@ def check_if_storage_attached(vios, partition_uuid):
         raise e
     return found, phys_disk
 
-def check_if_vdisk_attached(vios, partition_uuid):
-    found = False
-    vdisk = ""
-    if partition_uuid == "":
-        return found, vdisk
-
-    try:
-        soup = BeautifulSoup(vios, 'xml')
-        scsi_mappings = soup.find_all('VirtualSCSIMapping')
-        # Iterate over all SCSI mappings and look for Storage followed by VirtualDisk XML tags
-        for scsi in scsi_mappings:
-            lpar_link = scsi.find("AssociatedLogicalPartition")
-            if lpar_link is not None and partition_uuid in lpar_link.attrs["href"]:
-                storage = scsi.find("Storage")
-                if storage is not None:
-                    logical_vol = storage.find("VirtualDisk")
-                    if logical_vol is not None:
-                        logger.debug(
-                            f"Found virtual disk SCSI mapping for partition '{partition_uuid}' in VIOS")
-                        found = True
-                        vdisk = logical_vol.find("DiskName").text
-                        break
-    except Exception as e:
-        logger.error(
-            "failed to check if storage SCSI mapping is present in VIOS")
-        raise e
-    return found, vdisk
-
 def check_if_vfc_disk_attached(vios, partition_uuid):
     found = False
     portname = ""

cli/storage/virtual_storage.py

@@ -130,6 +130,64 @@ def get_volume_group_details(config, cookies, vios_uuid, vg_id):
     vol_group_details = str(soup.find("VolumeGroup"))
     return vol_group_details
 
+def check_if_vdisk_attached(vios, partition_uuid):
+    found = False
+    vdisk = ""
+    if partition_uuid == "":
+        return found, vdisk
+
+    try:
+        soup = BeautifulSoup(vios, 'xml')
+        scsi_mappings = soup.find_all('VirtualSCSIMapping')
+        # Iterate over all SCSI mappings and look for Storage followed by VirtualDisk XML tags
+        for scsi in scsi_mappings:
+            lpar_link = scsi.find("AssociatedLogicalPartition")
+            if lpar_link is not None and partition_uuid in lpar_link.attrs["href"]:
+                storage = scsi.find("Storage")
+                if storage is not None:
+                    logical_vol = storage.find("VirtualDisk")
+                    if logical_vol is not None:
+                        logger.debug(
+                            f"Found virtual disk SCSI mapping for partition '{partition_uuid}' in VIOS")
+                        found = True
+                        vdisk = logical_vol.find("DiskName").text
+                        break
+    except Exception as e:
+        logger.error(
+            "failed to check if storage SCSI mapping is present in VIOS")
+        raise e
+    return found, vdisk
+
+# Checks if virtualdisk is created under a given volumegroup
+def check_if_vdisk_exists(config, cookies, vios_uuid, vg_id, vdisk):
+    try:
+        url = f"https://{util.get_host_address(config)}/rest/api/uom/VirtualIOServer/{vios_uuid}/VolumeGroup/{vg_id}"
+        headers = {"x-api-key": util.get_session_key(
+            config), "Content-Type": "application/vnd.ibm.powervm.uom+xml; type=VolumeGroup"}
+        response = requests.get(url, headers=headers,
+                                cookies=cookies, verify=False)
+        if response.status_code != 200:
+            logger.error(
+                f"failed to get volumegroup details, error: {response.text}")
+            raise Exception(
+                f"failed to get volumegroup details, error: {response.text}")
+        soup = BeautifulSoup(response.text, 'xml')
+
+        # remove virtual disk
+        volume_group = soup.find("VolumeGroup")
+        vdisks = soup.find_all("VirtualDisk")
+        present = False
+        virt_disk_xml = None
+        for disk in vdisks:
+            disk_name = disk.find("DiskName")
+            if disk_name is not None and disk_name.text == vdisk:
+                present = True
+                virt_disk_xml = disk
+                break
+    except Exception as e:
+        raise e
+    return present, virt_disk_xml, volume_group
+
 def create_virtualdisk(config, cookies, vios_uuid, vg_id):
     # Get Volume group details
     vg_details = get_volume_group_details(config, cookies, vios_uuid, vg_id)

cli/utils/command_util.py

@@ -3,12 +3,14 @@
 from bs4 import BeautifulSoup
 
 import cli.auth.auth as auth
+import cli.storage.storage as storage
+import cli.storage.virtual_storage as vstorage
 import cli.utils.common as common
 import cli.utils.validator as validator
 import cli.utils.string_util as util
 import cli.utils.iso_util as iso_util
 import cli.vios.vios as vios_operation
-import cli.storage.storage as storage
+
 
 logger = common.get_logger("command-util")
 
@@ -79,27 +81,16 @@ def remove_vopt_device(config, cookies, vios, vopt_name):
 
 def remove_virtual_disk(config, cookies, vios_uuid, vg_id, vdisk):
     try:
-        url = f"https://{util.get_host_address(config)}/rest/api/uom/VirtualIOServer/{vios_uuid}/VolumeGroup/{vg_id}"
-        headers = {"x-api-key": util.get_session_key(
-            config), "Content-Type": "application/vnd.ibm.powervm.uom+xml; type=VolumeGroup"}
-        response = requests.get(url, headers=headers,
-                                cookies=cookies, verify=False)
-        if response.status_code != 200:
-            logger.error(
-                f"failed to get volumegroup details, error: {response.text}")
-            raise Exception(
-                f"failed to get volumegroup details, error: {response.text}")
-        soup = BeautifulSoup(response.text, 'xml')
-
-        # remove virtual disk
-        vdisks = soup.find_all("VirtualDisk")
-        for disk in vdisks:
-            disk_name = disk.find("DiskName")
-            if disk_name is not None and disk_name.text == vdisk:
-                disk.decompose()
-
-        # Get VolumeGroup XML payload after dropping virtualdisk
-        vg = soup.find("VolumeGroup")
+        found, vdisk, vg = vstorage.check_if_vdisk_exists(config, cookies, vios_uuid, vdisk)
+        if not found:
+            logger.debug(f"No virtualdisk '{vdisk}' is found under volumegroup")
+            return
+        # drop virtualdisk xml block
+        vdisk.decompose()
+
+        uri = f"/rest/api/uom/VirtualIOServer/{vios_uuid}/VolumeGroup/{vg_id}"
+        hmc_host = util.get_host_address(config)
+        url =  "https://" +  hmc_host + uri
         headers = {"x-api-key": util.get_session_key(
             config), "Content-Type": "application/vnd.ibm.powervm.uom+xml; type=VolumeGroup"}
         response = requests.post(url, data=str(vg),

cli/utils/string_util.py

@@ -113,22 +113,16 @@ def get_ssh_pub_key(config):
 
 # storage related Getters
 def get_volume_group_name(config):
-    return config["partition"]["storage"]["vg_name"]
+    return config["virtual-disk"]["vg_name"]
 
 def get_virtual_disk_name(config):
-    return config["partition"]["storage"]["vdisk_name"]
+    return config["virtual-disk"]["vdisk_name"]
 
-def use_virtual_disk(config):
-    return config["partition"]["storage"].as_bool("use_virtual_disk")
-
-def use_existing_vd(config):
-    return config["partition"]["storage"].as_bool("use_existing_vd")
-
-def use_existing_vg(config):
-    return config["partition"]["storage"].as_bool("use_existing_vg")
+def use_physical_volume(config):
+    return config["partition"]["storage"].as_bool("use_physical_volume")
 
 def get_virtual_disk_size(config):
-    return config["partition"]["storage"]["vdisk_size"]
+    return config["virtual-disk"]["vdisk_size"]
 
 def get_required_disk_size(config):
     return config["partition"]["storage"]["size"]

config.ini

@@ -57,13 +57,8 @@
       nameserver = ""
   [[storage]]
     size = "120"
-    use_virtual_disk = False
-    # Populate below parameters if virtual disk needs to be attached to PIM partition
-    vdisk_name = ""
-    vdisk_size = ""
-    use_existing_vd = False
-    use_existing_vg = True
-    vg_name = ""
+    # set below attribute to 'false' if virtual disk needs to be created and attached to PIM partition
+    use_physical_volume = true
 
 # Advanced configs
 [custom-flavor]
@@ -86,6 +81,11 @@
     max-memory = 32
     desired-memory = 32
     min-memory = 10
+[virtual-disk]
+    # Populate below parameters if virtual disk needs to be attached to PIM partition
+    vdisk_name = ""
+    vdisk_size = ""
+    vg_name = ""
 [ssh]
   user-name = "pim"
   pub-key-file = ""