M3 - Virtual disk - US02 - US03 - Create / Delete / List (#153)

Add virtual_disk module

Fixes #165

Author: domendobnikar

changelogs/fragments/virtual_disk_module.yml

@@ -0,0 +1,3 @@
+---
+major_changes:
+  - Added virtual_disk module. (https://github.com/ScaleComputing/HyperCoreAnsibleCollection/pull/153)

plugins/module_utils/client.py

@@ -11,10 +11,16 @@
 import json
 import ssl
 from typing import Any, Optional, Union
+from io import BufferedReader
 
 from ansible.module_utils.urls import Request, basic_auth_header
 
-from .errors import AuthError, ScaleComputingError, UnexpectedAPIResponse
+from .errors import (
+    AuthError,
+    ScaleComputingError,
+    UnexpectedAPIResponse,
+    ApiResponseNotJson,
+)
 from ..module_utils.typed_classes import TypedClusterInstance
 
 from ansible.module_utils.six.moves.urllib.error import HTTPError, URLError
@@ -47,9 +53,7 @@ def json(self) -> Any:
             try:
                 self._json = json.loads(self.data)
             except ValueError:
-                raise ScaleComputingError(
-                    "Received invalid JSON response: {0}".format(self.data)
-                )
+                raise ApiResponseNotJson(self.data)
         return self._json
 
 
@@ -100,7 +104,7 @@ def _request(
         self,
         method: str,
         path: str,
-        data: Optional[Union[dict[Any, Any], bytes, str]] = None,
+        data: Optional[Union[dict[Any, Any], bytes, str, BufferedReader]] = None,
         headers: Optional[dict[Any, Any]] = None,
         timeout: Optional[float] = None,
     ) -> Response:
@@ -135,13 +139,13 @@ def _request(
                 and isinstance(e.args, tuple)
                 and type(e.args[0]) == ConnectionRefusedError
             ):
-                raise ConnectionRefusedError(e)
+                raise ConnectionRefusedError(e.reason)
             elif (
                 e.args
                 and isinstance(e.args, tuple)
                 and type(e.args[0]) == ConnectionResetError
             ):
-                raise ConnectionResetError(e)
+                raise ConnectionResetError(e.reason)
             elif (
                 e.args
                 and isinstance(e.args, tuple)
@@ -159,7 +163,7 @@ def request(
         query: Optional[dict[Any, Any]] = None,
         data: Optional[dict[Any, Any]] = None,
         headers: Optional[dict[Any, Any]] = None,
-        binary_data: Optional[bytes] = None,
+        binary_data: Optional[Union[bytes, BufferedReader]] = None,
         timeout: Optional[float] = None,
     ) -> Response:
         # Make sure we only have one kind of payload
@@ -184,6 +188,7 @@ def request(
                 timeout=timeout,
             )
         elif binary_data is not None:
+            headers["Content-type"] = "application/octet-stream"
             return self._request(
                 method, url, data=binary_data, headers=headers, timeout=timeout
             )
@@ -227,10 +232,10 @@ def patch(
     def put(
         self,
         path: str,
-        data: dict[Any, Any],
+        data: Optional[dict[Any, Any]],
         query: Optional[dict[Any, Any]] = None,
         timeout: Optional[float] = None,
-        binary_data: Optional[bytes] = None,
+        binary_data: Optional[Union[bytes, BufferedReader]] = None,
         headers: Optional[dict[Any, Any]] = None,
     ) -> Request:
         resp = self.request(

plugins/module_utils/errors.py

@@ -99,3 +99,9 @@ class SupportTunnelError(ScaleComputingError):
     def __init__(self, data: Union[str, Exception]):
         self.message = "{0}".format(data)
         super(SupportTunnelError, self).__init__(self.message)
+
+
+class ApiResponseNotJson(ScaleComputingError):
+    def __init__(self, data: Union[str, Exception]):
+        self.message = f"From API expected json got {data}."
+        super(ApiResponseNotJson, self).__init__(self.message)

plugins/module_utils/hypercore_version.py

@@ -11,9 +11,9 @@
 import operator
 import re
 from functools import total_ordering
+from ansible.module_utils.basic import AnsibleModule
 from typing import List
 from ..module_utils.utils import PayloadMapper
-from ansible.module_utils.basic import AnsibleModule
 from ..module_utils.rest_client import RestClient
 from ..module_utils.typed_classes import (
     TypedUpdateToAnsible,

plugins/module_utils/rest_client.py

@@ -13,7 +13,9 @@
 
 __metaclass__ = type
 
-from typing import Any, Optional
+from typing import Any, Optional, Union
+from io import BufferedReader
+import json
 
 
 def _query(original: Optional[dict[Any, Any]] = None) -> dict[Any, Any]:
@@ -112,14 +114,13 @@ def delete_record(
     def put_record(
         self,
         endpoint: str,
-        payload: dict[Any, Any],
+        payload: Optional[dict[Any, Any]],
         check_mode: bool,
         query: Optional[dict[Any, Any]] = None,
         timeout: Optional[float] = None,
-        binary_data: Optional[bytes] = None,
+        binary_data: Optional[Union[bytes, BufferedReader]] = None,
         headers: Optional[dict[Any, Any]] = None,
     ) -> TypedTaskTag:
-        # Method put doesn't support check mode # IT ACTUALLY DOES
         if check_mode:
             return utils.MOCKED_TASK_TAG
         try:
@@ -133,7 +134,8 @@ def put_record(
             ).json
         except TimeoutError as e:
             raise errors.ScaleComputingError(f"Request timed out: {e}")
-
+        except (json.JSONDecodeError, json.decoder.JSONDecodeError) as e:
+            raise json.JSONDecodeError(e.msg, e.doc, e.pos)
         return response
 
 

plugins/module_utils/task_tag.py

@@ -5,6 +5,7 @@
 
 
 from __future__ import absolute_import, division, print_function
+from __future__ import annotations
 
 __metaclass__ = type
 
@@ -13,15 +14,21 @@
 from ..module_utils import errors
 from ..module_utils.rest_client import RestClient
 from ..module_utils.typed_classes import TypedTaskTag
+from typing import Optional, Dict, Any
 
 
 class TaskTag:
     @classmethod
     def wait_task(
-        cls, rest_client: RestClient, task: TypedTaskTag, check_mode: bool = False
-    ):
+        cls,
+        rest_client: RestClient,
+        task: Optional[TypedTaskTag],
+        check_mode: bool = False,
+    ) -> None:
         if check_mode:
             return
+        if task is None:
+            return
         if type(task) != dict:
             raise errors.ScaleComputingError("task should be dictionary.")
         if "taskTag" not in task.keys():
@@ -50,14 +57,18 @@ def wait_task(
             sleep(1)
 
     @staticmethod
-    def get_task_status(rest_client, task):
+    def get_task_status(
+        rest_client: RestClient, task: Optional[TypedTaskTag]
+    ) -> Optional[Dict[Any, Any]]:
+        if not task:
+            return None
         if type(task) != dict:
             raise errors.ScaleComputingError("task should be dictionary.")
         if "taskTag" not in task.keys():
             raise errors.ScaleComputingError("taskTag is not in task dictionary.")
         if not task["taskTag"]:
-            return
-        task_status = rest_client.get_record(
+            return None
+        task_status: Optional[Dict[Any, Any]] = rest_client.get_record(
             "{0}/{1}".format("/rest/v1/TaskTag", task["taskTag"]), query={}
         )
-        return task_status if task_status else {}
+        return task_status if task_status else None

plugins/module_utils/typed_classes.py

@@ -133,6 +133,7 @@ class TypedDiff(TypedDict):
         TypedCertificateToAnsible,
         TypedSyslogServerToAnsible,
         TypedUpdateToAnsible,
+        TypedVirtualDiskToAnsible,
         None,
         dict[None, None],
     ]
@@ -144,6 +145,7 @@ class TypedDiff(TypedDict):
         TypedClusterToAnsible,
         TypedCertificateToAnsible,
         TypedSyslogServerToAnsible,
+        TypedVirtualDiskToAnsible,
         None,
         dict[None, None],
     ]

plugins/module_utils/utils.py

@@ -18,6 +18,7 @@
     TypedRegistrationToAnsible,
     TypedOidcToAnsible,
     TypedCertificateToAnsible,
+    TypedVirtualDiskToAnsible,
 )
 
 
@@ -132,10 +133,18 @@ def filter_results(results, filter_data) -> list[Any]:
 
 def is_changed(
     before: Union[
-        TypedCertificateToAnsible, TypedOidcToAnsible, TypedRegistrationToAnsible, None
+        TypedCertificateToAnsible,
+        TypedOidcToAnsible,
+        TypedRegistrationToAnsible,
+        TypedVirtualDiskToAnsible,
+        None,
     ],
     after: Union[
-        TypedCertificateToAnsible, TypedOidcToAnsible, TypedRegistrationToAnsible, None
+        TypedCertificateToAnsible,
+        TypedOidcToAnsible,
+        TypedRegistrationToAnsible,
+        TypedVirtualDiskToAnsible,
+        None,
     ],
 ) -> bool:
     return not before == after

plugins/module_utils/virtual_disk.py

@@ -8,14 +8,19 @@
 
 __metaclass__ = type
 
+from ansible.module_utils.basic import AnsibleModule
 from ..module_utils.typed_classes import (
     TypedVirtualDiskFromAnsible,
     TypedVirtualDiskToAnsible,
+    TypedTaskTag,
 )
 from typing import Dict, List, Any, Optional
 
 from .rest_client import RestClient
 from ..module_utils.utils import PayloadMapper
+from ..module_utils import errors
+
+REQUEST_TIMEOUT_TIME = 3600
 
 
 class VirtualDisk(PayloadMapper):
@@ -43,21 +48,20 @@ def from_ansible(cls, ansible_data: TypedVirtualDiskFromAnsible) -> VirtualDisk:
 
     @classmethod
     def from_hypercore(cls, hypercore_data: Dict[Any, Any]) -> VirtualDisk:
-        return cls(
-            name=hypercore_data["name"],
-            uuid=hypercore_data["uuid"],
-            block_size=hypercore_data["blockSize"],
-            size=hypercore_data["capacityBytes"],
-            # allocated_size=hypercore_data["totalAllocationBytes"],
-            replication_factor=hypercore_data["replicationFactor"],
-        )
+        try:
+            return cls(
+                name=hypercore_data["name"],
+                uuid=hypercore_data["uuid"],
+                block_size=hypercore_data["blockSize"],
+                size=hypercore_data["capacityBytes"],
+                # allocated_size=hypercore_data["totalAllocationBytes"],
+                replication_factor=hypercore_data["replicationFactor"],
+            )
+        except KeyError as e:
+            raise errors.MissingValueHypercore(e)
 
     def to_hypercore(self) -> Dict[Any, Any]:
         raise NotImplementedError()
-        # return dict(
-        #     searchDomains=self.search_domains,
-        #     serverIPs=self.server_ips,
-        # )
 
     def to_ansible(self) -> TypedVirtualDiskToAnsible:
         return dict(
@@ -93,14 +97,79 @@ def __eq__(self, other: object) -> bool:
     #     virtual_disk = VirtualDisk.from_hypercore(hypercore_dict)
     #     return virtual_disk
 
+    @classmethod
+    def get_by_name(
+        cls, rest_client: RestClient, name: str, must_exist: bool = False
+    ) -> Optional[VirtualDisk]:
+        result = rest_client.list_records("/rest/v1/VirtualDisk", query=dict(name=name))
+        if not isinstance(result, list):
+            raise errors.ScaleComputingError(
+                "Virtual disk API return value is not a list."
+            )
+        elif must_exist and (not result or not result[0]):
+            raise errors.ScaleComputingError(
+                f"Virtual disk with name {name} does not exist."
+            )
+        elif not result or not result[0]:
+            return None
+        elif len(result) > 1:
+            raise errors.ScaleComputingError(
+                f"Virtual disk {name} has multiple instances and is not unique."
+            )
+        return cls.from_hypercore(result[0])
+
     @classmethod
     def get_state(
         cls, rest_client: RestClient, query: Dict[Any, Any]
     ) -> List[TypedVirtualDiskToAnsible]:
         state = [
-            VirtualDisk.from_hypercore(hypercore_data=hypercore_dict).to_ansible()
+            cls.from_hypercore(hypercore_data=hypercore_dict).to_ansible()
             for hypercore_dict in rest_client.list_records(
                 "/rest/v1/VirtualDisk", query
             )
         ]
         return state
+
+    # Uploads a disk file (qcow2, vmdk, vhd); Hypercore creates virtual disk from uploaded file.
+    # Filename and filesize need to be send as parameters in PUT request.
+    @staticmethod
+    def send_upload_request(
+        rest_client: RestClient, file_size: int, module: AnsibleModule
+    ) -> TypedTaskTag:
+        if (
+            file_size is None
+            or not module.params["name"]
+            or not module.params["source"]
+        ):
+            raise errors.ScaleComputingError(
+                "Missing some virtual disk file values inside upload request."
+            )
+        try:
+            with open(module.params["source"], "rb") as source_file:
+                task = rest_client.put_record(
+                    endpoint="/rest/v1/VirtualDisk/upload",
+                    payload=None,
+                    check_mode=False,
+                    query=dict(filename=module.params["name"], filesize=file_size),
+                    timeout=REQUEST_TIMEOUT_TIME,
+                    binary_data=source_file,
+                    headers={
+                        "Content-Type": "application/octet-stream",
+                        "Accept": "application/json",
+                        "Content-Length": file_size,
+                    },
+                )
+        except FileNotFoundError:
+            raise errors.ScaleComputingError(
+                f"Disk file {module.params['source']} not found."
+            )
+        return task
+
+    def send_delete_request(self, rest_client: RestClient) -> TypedTaskTag:
+        if not self.uuid:
+            raise errors.ScaleComputingError(
+                "Missing virtual disk UUID inside delete request."
+            )
+        return rest_client.delete_record(
+            f"/rest/v1/VirtualDisk/{self.uuid}", check_mode=False
+        )