flynt

Signed-off-by: Justin Cinkelj <[email protected]>

Author: justinc1

plugins/module_utils/client.py

@@ -205,9 +205,7 @@ def _request_no_log(
             # Wrong username/password, or expired access token
             if e.code == 401:
                 raise AuthError(
-                    "Failed to authenticate with the instance: {0} {1}".format(
-                        e.code, e.reason
-                    ),
+                    f"Failed to authenticate with the instance: {e.code} {e.reason}",
                 )
             # Other HTTP error codes do not necessarily mean errors.
             # This is for the caller to decide.
@@ -255,9 +253,9 @@ def request(
         escaped_path = quote(path.strip("/"))
         if escaped_path:
             escaped_path = "/" + escaped_path
-        url = "{0}{1}".format(self.host, escaped_path)
+        url = f"{self.host}{escaped_path}"
         if query:
-            url = "{0}?{1}".format(url, urlencode(query))
+            url = f"{url}?{urlencode(query)}"
         headers = dict(headers or DEFAULT_HEADERS, **self.auth_header)
         if data is not None:
             headers["Content-type"] = "application/json"

plugins/module_utils/errors.py

@@ -33,63 +33,61 @@ def __init__(self, message: str):
 
 class UnexpectedAPIResponse(ScaleComputingError):
     def __init__(self, response: Request):
-        self.message = "Unexpected response - {0} {1}".format(
-            response.status, response.data
-        )
+        self.message = f"Unexpected response - {response.status} {response.data}"
         self.response_status = response.status
         super(UnexpectedAPIResponse, self).__init__(self.message)
 
 
 class InvalidUuidFormatError(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
-        self.message = "Invalid UUID - {0}".format(data)
+        self.message = f"Invalid UUID - {data}"
         super(InvalidUuidFormatError, self).__init__(self.message)
 
 
 # In-case function parameter is optional but required
 class MissingFunctionParameter(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
-        self.message = "Missing parameter - {0}".format(data)
+        self.message = f"Missing parameter - {data}"
         super(MissingFunctionParameter, self).__init__(self.message)
 
 
 # In-case argument spec doesn't catch exception
 class MissingValueAnsible(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
-        self.message = "Missing value - {0}".format(data)
+        self.message = f"Missing value - {data}"
         super(MissingValueAnsible, self).__init__(self.message)
 
 
 # In-case argument spec doesn't catch exception
 class MissingValueHypercore(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
-        self.message = "Missing values from hypercore API - {0}".format(data)
+        self.message = f"Missing values from hypercore API - {data}"
         super(MissingValueHypercore, self).__init__(self.message)
 
 
 class DeviceNotUnique(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
-        self.message = "Device is not unique - {0} - already exists".format(data)
+        self.message = f"Device is not unique - {data} - already exists"
         super(DeviceNotUnique, self).__init__(self.message)
 
 
 class VMNotFound(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
-        self.message = "Virtual machine - {0} - not found".format(data)
+        self.message = f"Virtual machine - {data} - not found"
         super(VMNotFound, self).__init__(self.message)
 
 
 class ReplicationNotUnique(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
         self.message = (
-            "There is already a replication on - {0} - virtual machine".format(data)
+            f"There is already a replication on - {data} - virtual machine"
         )
         super(ReplicationNotUnique, self).__init__(self.message)
 
 
 class ClusterConnectionNotFound(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
-        self.message = "No cluster connection found - {0}".format(data)
+        self.message = f"No cluster connection found - {data}"
         super(ClusterConnectionNotFound, self).__init__(self.message)
 
 
@@ -109,7 +107,7 @@ def __init__(self) -> None:
 
 class SupportTunnelError(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
-        self.message = "{0}".format(data)
+        self.message = f"{data}"
         super(SupportTunnelError, self).__init__(self.message)
 
 

plugins/module_utils/rest_client.py

@@ -77,9 +77,7 @@ def get_record(
             )
         if must_exist and not records:
             raise errors.ScaleComputingError(
-                "No records from endpoint {0} match the {1} query.".format(
-                    endpoint, query
-                )
+                f"No records from endpoint {endpoint} match the {query} query."
             )
         return records[0] if records else None
 

plugins/module_utils/role.py

@@ -66,7 +66,7 @@ def get_role_from_uuid(
         cls, role_uuid: str, rest_client: RestClient, must_exist: bool = False
     ) -> Optional[Role]:
         hypercore_dict = rest_client.get_record(
-            "/rest/v1/Role/{0}".format(role_uuid), must_exist=must_exist
+            f"/rest/v1/Role/{role_uuid}", must_exist=must_exist
         )
         role = cls.from_hypercore(hypercore_dict)
         return role

plugins/module_utils/task_tag.py

@@ -42,7 +42,7 @@ def wait_task(
 
         while True:
             task_status = rest_client.get_record(
-                "{0}/{1}".format("/rest/v1/TaskTag", task["taskTag"]), query={}
+                f"/rest/v1/TaskTag/{task['taskTag']}", query={}
             )
             if task_status is None:  # No such task_status is found
                 break
@@ -71,6 +71,6 @@ def get_task_status(
         if not task["taskTag"]:
             return None
         task_status: Optional[Dict[Any, Any]] = rest_client.get_record(
-            "{0}/{1}".format("/rest/v1/TaskTag", task["taskTag"]), query={}
+            f"/rest/v1/TaskTag/{task['taskTag']}", query={}
         )
         return task_status if task_status else None

plugins/module_utils/user.py

@@ -89,7 +89,7 @@ def get_user_from_uuid(
         cls, user_uuid, rest_client: RestClient, must_exist: bool = False
     ) -> Optional[User]:
         hypercore_dict = rest_client.get_record(
-            "/rest/v1/User/{0}".format(user_uuid), must_exist=must_exist
+            f"/rest/v1/User/{user_uuid}", must_exist=must_exist
         )
         user = cls.from_hypercore(hypercore_dict)
         return user

plugins/module_utils/vm.py

@@ -809,9 +809,7 @@ def filter_specific_objects(results, query, object_type):
         filtered_results = filter_results(results, query)
         if len(filtered_results) > 1:
             raise errors.ScaleComputingError(
-                "{0} isn't uniquely identifyed by {1} in the VM.".format(
-                    object_type, query
-                )
+                f"{object_type} isn't uniquely identifyed by {query} in the VM."
             )
         return filtered_results[0] if filtered_results else None
 
@@ -843,7 +841,7 @@ def update_boot_device_order(module, rest_client, vm, boot_order):
         # uuid is vm's uuid. boot_order is the desired order we want to set to boot devices
         vm.do_shutdown_steps(module, rest_client)
         task_tag = rest_client.update_record(
-            "{0}/{1}".format("/rest/v1/VirDomain", vm.uuid),
+            f"/rest/v1/VirDomain/{vm.uuid}",
             dict(bootDevices=boot_order),
             module.check_mode,
         )
@@ -1297,7 +1295,7 @@ def set_vm_params(cls, module, rest_client, vm, param_subset: List[str]):
 
         if changed:
             payload = ManageVMParams._build_payload(module, rest_client)
-            endpoint = "{0}/{1}".format("/rest/v1/VirDomain", vm.uuid)
+            endpoint = f"/rest/v1/VirDomain/{vm.uuid}"
             task_tag = rest_client.update_record(endpoint, payload, module.check_mode)
             TaskTag.wait_task(rest_client, task_tag)
 
@@ -1396,7 +1394,7 @@ def iso_image_management(module, rest_client, iso, uuid, attach):
         # If false, it means you're detaching an image.
         payload = iso.attach_iso_payload() if attach else iso.detach_iso_payload()
         task_tag = rest_client.update_record(
-            "{0}/{1}".format("/rest/v1/VirDomainBlockDevice", uuid),
+            f"/rest/v1/VirDomainBlockDevice/{uuid}",
             payload,
             module.check_mode,
         )
@@ -1412,7 +1410,7 @@ def _update_block_device(
         if existing_disk.needs_reboot("update", desired_disk):
             vm.do_shutdown_steps(module, rest_client)
         task_tag = rest_client.update_record(
-            "{0}/{1}".format("/rest/v1/VirDomainBlockDevice", existing_disk.uuid),
+            f"/rest/v1/VirDomainBlockDevice/{existing_disk.uuid}",
             payload,
             module.check_mode,
         )
@@ -1446,9 +1444,7 @@ def _delete_not_used_disks(cls, module, rest_client, vm, changed, disk_key):
                 if existing_disk.needs_reboot("delete"):
                     vm.do_shutdown_steps(module, rest_client)
                 task_tag = rest_client.delete_record(
-                    "{0}/{1}".format(
-                        "/rest/v1/VirDomainBlockDevice", existing_disk.uuid
-                    ),
+                    f"/rest/v1/VirDomainBlockDevice/{existing_disk.uuid}",
                     module.check_mode,
                 )
                 try:
@@ -1468,9 +1464,7 @@ def _delete_not_used_disks(cls, module, rest_client, vm, changed, disk_key):
                     # shutdown and retry remove
                     vm.do_shutdown_steps(module, rest_client)
                     task_tag = rest_client.delete_record(
-                        "{0}/{1}".format(
-                            "/rest/v1/VirDomainBlockDevice", existing_disk.uuid
-                        ),
+                        f"/rest/v1/VirDomainBlockDevice/{existing_disk.uuid}",
                         module.check_mode,
                     )
                     TaskTag.wait_task(rest_client, task_tag, module.check_mode)
@@ -1507,7 +1501,7 @@ def _force_remove_all_disks(module, rest_client, vm, disks_before):
         # Delete all disks
         for existing_disk in vm.disks:
             task_tag = rest_client.delete_record(
-                "{0}/{1}".format("/rest/v1/VirDomainBlockDevice", existing_disk.uuid),
+                f"/rest/v1/VirDomainBlockDevice/{existing_disk.uuid}",
                 module.check_mode,
             )
             TaskTag.wait_task(rest_client, task_tag, module.check_mode)

plugins/modules/dns_config.py

@@ -230,8 +230,8 @@ def modify_dns_config(
     # update_record method uses method PATCH,
     # create_record method uses method POST.
     # [ NOTE: PUT method is not allowed on DNS Config ]
-    task_tag = getattr(rest_client, "{0}_record".format(action))(
-        endpoint="{0}/{1}".format("/rest/v1/DNSConfig", dns_config.uuid),
+    task_tag = getattr(rest_client, f"{action}_record")(
+        endpoint=f"/rest/v1/DNSConfig/{dns_config.uuid}",
         payload=dict(searchDomains=new_search_domains, serverIPs=new_dns_servers),
         check_mode=module.check_mode,
     )

plugins/modules/iso.py

@@ -201,7 +201,7 @@ def ensure_present(module, rest_client):
         file_size = os.stat(module.params["source"]).st_size
         with open(module.params["source"], "rb") as source_file:
             rest_client.put_record(
-                endpoint="/rest/v1/ISO/%s/data" % iso_uuid,
+                endpoint=f"/rest/v1/ISO/{iso_uuid}/data",
                 payload=None,
                 check_mode=module.check_mode,
                 timeout=ISO_TIMEOUT_TIME,
@@ -221,7 +221,7 @@ def ensure_present(module, rest_client):
 
     # Now the ISO image is ready for insertion. Updating readyForInsert to True.
     task_tag_update = rest_client.update_record(
-        endpoint="{0}/{1}".format("/rest/v1/ISO", iso_uuid),
+        endpoint=f"/rest/v1/ISO/{iso_uuid}",
         payload=dict(readyForInsert=True),
         check_mode=module.check_mode,
     )
@@ -234,7 +234,7 @@ def ensure_absent(module, rest_client):
     iso_image = ISO.get_by_name(module.params, rest_client)
     if iso_image:
         task_tag_delete = rest_client.delete_record(
-            endpoint="{0}/{1}".format("/rest/v1/ISO", iso_image.uuid),
+            endpoint=f"/rest/v1/ISO/{iso_image.uuid}",
             check_mode=module.check_mode,
         )
         TaskTag.wait_task(rest_client, task_tag_delete)

plugins/modules/smtp.py

@@ -277,7 +277,7 @@ def modify_smtp_config(module: AnsibleModule, rest_client: RestClient) -> Tuple[
     # Set the task tag
     # update_record -> PATCH
     update_task_tag = rest_client.update_record(
-        endpoint="{0}/{1}".format("/rest/v1/AlertSMTPConfig", smtp.uuid),
+        endpoint=f"/rest/v1/AlertSMTPConfig/{smtp.uuid}",
         payload=payload,
         check_mode=module.check_mode,
     )