syneto_api 0.1.0__tar.gz

syneto_api-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: syneto-api
+Version: 0.1.0
+Summary: Syneto Client API library
+License: Proprietary
+Author: Your Name
+Author-email: you@example.com
+Requires-Python: >=3.6,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Requires-Dist: python-dotenv (>=0.16.0,<0.17.0)
+Requires-Dist: requests[secure] (>=2.25.1,<3.0.0)

syneto_api-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "syneto_api"
+version = "0.1.0"
+description = "Syneto Client API library"
+authors = ["Your Name <you@example.com>"]
+license = "Proprietary"
+
+[tool.poetry.dependencies]
+python = "^3.6"
+python-dotenv = "^0.16.0"
+requests = {extras = ["secure"], version = "^2.25.1"}
+
+[tool.poetry.dev-dependencies]
+pytest = "^6.2.2"
+ipdb = "^0.13.7"
+
+[build-system]
+requires = ["poetry>=0.12"]
+build-backend = "poetry.masonry.api"

syneto_api-0.1.0/setup.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+
+package_dir = \
+{'': 'src'}
+
+packages = \
+['syneto_api']
+
+package_data = \
+{'': ['*']}
+
+install_requires = \
+['python-dotenv>=0.16.0,<0.17.0', 'requests[secure]>=2.25.1,<3.0.0']
+
+setup_kwargs = {
+    'name': 'syneto-api',
+    'version': '0.1.0',
+    'description': 'Syneto Client API library',
+    'long_description': None,
+    'author': 'Your Name',
+    'author_email': 'you@example.com',
+    'maintainer': None,
+    'maintainer_email': None,
+    'url': None,
+    'package_dir': package_dir,
+    'packages': packages,
+    'package_data': package_data,
+    'install_requires': install_requires,
+    'python_requires': '>=3.6,<4.0',
+}
+
+
+setup(**setup_kwargs)

syneto_api-0.1.0/src/syneto_api/__init__.py

@@ -0,0 +1,4 @@
+from .auth_api import Authentication
+from .virt_api import Virtualization
+from .storage_api import Storage
+from .protection_api import Protection

syneto_api-0.1.0/src/syneto_api/api_client.py

@@ -0,0 +1,177 @@
+import os
+import requests
+import urllib.parse
+import logging
+
+from .settings import get_env_flag
+
+logger = logging.getLogger(__name__)
+
+
+def make_url(url_base, *path_args, query_args: dict = None, **path_kwargs):
+    path_args = [urllib.parse.quote(v, safe="") for v in path_args]
+    path_kwargs = {k: urllib.parse.quote(v, safe="") for k, v in path_kwargs.items()}
+    path = url_base.format(*path_args, **path_kwargs)
+
+    if query_args is None or len(query_args) == 0:
+        return path
+    query_string = urllib.parse.urlencode(
+        query_args, doseq=True, quote_via=urllib.parse.quote
+    )
+    return f"{path}?{query_string}"
+
+
+class APIException(Exception):
+    def __init__(
+        self, url: str, status_code: int = 0, request_body: dict = None, response=None
+    ):
+        self.url = url
+        self.status_code = status_code
+        self.request_body = request_body
+        self.response = response
+        message = f"API Error: {self.url}"
+        if self.status_code and self.response is not None:
+            message = (
+                f"API {self.url} returned HTTP {self.status_code}: {self.response.text}"
+            )
+        super().__init__(message)
+
+
+class APIClientBase:
+    SUCCESS_CODES = {
+        "GET": [200],
+        "POST": [200, 201, 202],
+        "PUT": [200, 202],
+        "PATCH": [200, 202],
+        "DELETE": [200, 204],
+    }
+
+    def __init__(self, url_base=None, default_protocol="http", insecure_ssl=None):
+        self.url_base = url_base
+        protocols = ["http://", "https://"]
+        if not any(self.url_base.lower().startswith(p) for p in protocols):
+            self.url_base = f"{default_protocol}://{self.url_base}"
+
+        self.url_base = self.url_base.rstrip("/")
+
+        self.headers = {}
+        self._verify_ssl_cert = True
+        if insecure_ssl is not None:
+            self.set_insecure_ssl(insecure_ssl)
+        elif get_env_flag("ALLOW_INSECURE_SSL"):
+            self.set_insecure_ssl(True)
+
+    def _request(
+        self,
+        method: str,
+        relative_url: str,
+        *args,
+        query_args: dict = None,
+        body: dict = None,
+        success_codes: list = None,
+        **kwargs,
+    ):
+        relative_url = relative_url.lstrip("/")
+        url = make_url(
+            self.url_base + "/" + relative_url, *args, query_args=query_args, **kwargs
+        )
+        logger.debug(f"Calling {method} {url}")
+
+        if not success_codes:
+            success_codes = APIClientBase.SUCCESS_CODES[method]
+
+        method_func = self._get_method_func(method)
+        method_args = {"verify": self._verify_ssl_cert}
+        if self.headers is not None and len(self.headers) > 0:
+            method_args["headers"] = self.headers
+
+        if body is not None:
+            method_args["json"] = body
+
+        try:
+            response = method_func(url, timeout=20, **method_args)
+            if response.status_code in success_codes:
+                logger.debug("Received {response.status_code} from {method} {url}")
+                return response.json()
+
+            logger.info("Received {response.status_code} from {method} {url}")
+            raise APIException(
+                url=url,
+                status_code=response.status_code,
+                request_body=body,
+                response=response,
+            )
+
+        except APIException as e:
+            raise
+
+        except TypeError:
+            raise
+
+        except Exception as e:
+            logger.warning(f"Failed {method} request to {url}: {str(e)}")
+            raise APIException(url=url, request_body=body,) from e
+
+    def _get_method_func(self, method):
+        requests_methods = {
+            "GET": requests.get,
+            "POST": requests.post,
+            "PUT": requests.put,
+            "PATCH": requests.patch,
+            "DELETE": requests.delete,
+        }
+        return requests_methods[method]
+
+    def get_request(
+        self,
+        relative_url: str,
+        *url_path_args,
+        query_args: dict = None,
+        success_codes: list = None,
+        **url_path_kwargs,
+    ):
+        return self._request(
+            "GET",
+            relative_url,
+            *url_path_args,
+            query_args=query_args,
+            success_codes=success_codes,
+            **url_path_kwargs,
+        )
+
+    def delete_request(self, *args, **kwargs):
+        # Same args as get_request
+        return self._request("DELETE", *args, **kwargs)
+
+    def post_request(
+        self,
+        relative_url: str,
+        *url_path_args,
+        query_args: dict = None,
+        body: dict = None,
+        success_codes: list = None,
+        **url_path_kwargs,
+    ):
+        return self._request(
+            "POST",
+            relative_url,
+            *url_path_args,
+            query_args=query_args,
+            body=body,
+            success_codes=success_codes,
+            **url_path_kwargs,
+        )
+
+    def put_request(self, *args, **kwargs):
+        # Same args as post_request
+        return self._request("PUT", *args, **kwargs)
+
+    def patch_request(self, *args, **kwargs):
+        # Same args as post_request
+        return self._request("PATCH", *args, **kwargs)
+
+    def set_insecure_ssl(self, insecure=True):
+        self._verify_ssl_cert = not insecure
+
+    def set_auth_jwt(self, jwt):
+        self.headers["Authorization"] = f"Bearer {jwt}"

syneto_api-0.1.0/src/syneto_api/auth_api.py

@@ -0,0 +1,11 @@
+import os
+from .api_client import APIClientBase
+
+
+class Authentication(APIClientBase):
+    def __init__(self, url_base=None, **kwargs):
+        super().__init__(url_base or os.environ.get("AUTH_SERVICE", ""), **kwargs)
+
+    def login(self, username: str, password: str):
+        body = {"username": username, "password": password}
+        return self.post_request("/login", body=body)

syneto_api-0.1.0/src/syneto_api/protection_api.py

@@ -0,0 +1,37 @@
+import os
+from .api_client import APIClientBase
+
+
+class Protection(APIClientBase):
+    def __init__(self, url_base=None, **kwargs):
+        super().__init__(url_base or os.environ.get("PROTECTION_SERVICE", ""), **kwargs)
+
+    def get_policies(self):
+        return self.get_request("/policies/")
+
+    def get_protected_vms(self):
+        return self.get_request("/vms/")
+
+    def get_jobs(self):
+        return self.get_request("/jobs/")
+
+    def get_job(self, id):
+        return self.get_request("/jobs/{}", id)
+
+    def patch_job(self, id, payload):
+        return self.patch_request("/jobs/", query_args={"id": id}, body=payload)
+
+    def remove_job(self, id):
+        return self.delete_request("/jobs/", query_args={"id": id})
+
+    def create_external_vm_protection_job(self, config):
+        body = {"config": config}
+        return self.post_request("/jobs/protect-external-vm", body=body)
+
+    def create_local_vm_protection_job(self, config):
+        body = {"config": config}
+        return self.post_request("/jobs/protect-local-vm", body=body)
+
+    def create_local_vm_replication_job(self, config):
+        body = {"config": config}
+        return self.post_request("/jobs/replicate-local-vm", body=body)

syneto_api-0.1.0/src/syneto_api/settings.py

@@ -0,0 +1,39 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+bool_values = {"true": True, "yes": True, "false": False, "no": False}
+
+
+def get_env_flag(env_key: str) -> bool:
+    """
+    Returns the parsed value of the given env. var (assumed of boolean type).
+    The values "True" and "Yes" (case-insensitive) are parsed as True while
+    everything else (including non-existent env. var) parses as False.
+    """
+    env_value = os.environ.get(env_key, "")
+    return bool_values.get(env_value.lower()) == True
+
+
+def get_env_int(env_key, default=0) -> int:
+    """
+    Returns the parsed value of the given env. var (assumed of integer type).
+    If the env. var does not exist, the given default is returned. If the env. var value
+    fails to parse, a ValueError is raised.
+    """
+    env_value = os.environ.get(env_key, f"{default}")
+    return int(env_value)
+
+
+def get_env_string(env_key, default="") -> str:
+    """
+    Returns the associated os.environ value for the specified value as a string.
+    """
+    env_value = os.environ.get(env_key, f"{default}")
+    return env_value
+
+
+def get_root_path():
+    root_path_env = os.environ.get("ROOT_PATH", "") or ""
+    return "/" + root_path_env.strip("/")

syneto_api-0.1.0/src/syneto_api/storage_api.py

@@ -0,0 +1,130 @@
+import os
+from .api_client import APIClientBase
+
+
+class Storage(APIClientBase):
+    def __init__(self, url_base=None, **kwargs):
+        super().__init__(url_base or os.environ.get("STORAGE_SERVICE", ""), **kwargs)
+
+    def get_pools(self):
+        return self.get_request("/pools")
+
+    def get_importable_pools(self):
+        return self.get_request("/pools/importable")
+
+    def get_pool(self, pool_name: str):
+        return self.get_request("/pools/{pool_name}", pool_name=pool_name)
+
+    def clear_pool(self, pool_name: str):
+        return self.put_request("/pools/{pool_name}/clear", pool_name=pool_name)
+
+    def upgrade_pool(self, pool_name: str):
+        return self.put_request("/pools/{pool_name}/upgrade", pool_name=pool_name)
+
+    def export_pool(self, pool_name: str):
+        return self.put_request("/pools/{pool_name}/export", pool_name=pool_name)
+
+    def get_pool_periodic_scrub(self, pool_name: str):
+        return self.get_request(
+            "/pools/{pool_name}/scrub/interval", pool_name=pool_name
+        )
+
+    def set_pool_periodic_scrub(self, pool_name: str, interval: str):
+        return self.post_request(
+            "/pools/{pool_name}/scrub/interval",
+            pool_name=pool_name,
+            query_args={"interval": interval},
+        )
+
+    def delete_pool_periodic_scrub(self, pool_name: str):
+        return self.delete_request(
+            "/pools/{pool_name}/scrub/interval", pool_name=pool_name
+        )
+
+    def start_pool_scrub(self, pool_name: str):
+        return self.put_request("/pools/{pool_name}/scrub/start", pool_name=pool_name)
+
+    def stop_pool_scrub(self, pool_name: str):
+        return self.put_request("/pools/{pool_name}/scrub/stop", pool_name=pool_name)
+
+    def get_volumes(self):
+        return self.get_request("/volumes")
+
+    def create_volume(
+        self, pool_name: str, ips: list, volume_type: str = "NFS", quota: str = "none"
+    ):
+        hosts = [{"ipNetwork": ip, "accessType": "rw"} for ip in ips]
+        body = {
+            "type": volume_type,
+            "pool": pool_name,
+            "nfsShareConfig": {"rootAccess": "true", "hosts": hosts},
+            "quota": quota,
+        }
+        return self.post_request("/volumes", body=body,)
+
+    def get_volume(self, volume_id: str):
+        return self.get_request("/volumes/{volume_id}", volume_id=volume_id,)
+
+    def delete_volume(self, volume_id: str):
+        return self.delete_request(
+            "/volumes/{volume_id}", query_args={"volume_id": volume_id},
+        )
+
+    def promote_volume(self, volume_id: str):
+        return self.put_request("/volumes/{volume_id}/promote", volume_id=volume_id)
+
+    def get_volume_meta(self, volume_id: str, key: str):
+        return self.put_request(
+            "/volumes/{volume_id}/meta", volume_id=volume_id, query_args={"key": key}
+        )
+
+    def set_volume_meta(self, volume_id: str, key: str, value: dict):
+        body = {"key": key, "value": value}
+        return self.put_request(
+            "/volumes/{volume_id}/meta", volume_id=volume_id, body=body,
+        )
+
+    def get_volume_snapshots(self, volume_id: str):
+        return self.get_request("/volumes/{volume_id}/snapshots", volume_id=volume_id,)
+
+    def create_volume_snapshot(self, volume_id: str, snapshot_name: str):
+        return self.post_request(
+            "/volumes/{volume_id}/snapshots",
+            volume_id=volume_id,
+            query_args={"snapshot_name": snapshot_name},
+        )
+
+    def get_volume_snapshot(self, volume_id: str, snapshot_name: str):
+        return self.get_request(
+            "/volumes/{volume_id}/snapshots/{snapshot_name}",
+            volume_id=volume_id,
+            snapshot_name=snapshot_name,
+        )
+
+    def remove_volume_snapshot(self, volume_id: str, snapshot_name: str):
+        return self.delete_request(
+            "/volumes/{volume_id}/snapshots",
+            volume_id=volume_id,
+            query_args={"snapshot_name": snapshot_name},
+        )
+
+    def rollback_volume_snapshot(self, volume_id: str, snapshot_name: str):
+        return self.put_request(
+            "/volumes/{volume_id}/snapshots/{snapshot_name}/rollback",
+            volume_id=volume_id,
+            snapshot_name=snapshot_name,
+        )
+
+    def get_volume_snapshot_clones(self, volume_id: str, snapshot_name: str):
+        return self.get_request(
+            "/volumes/{volume_id}/snapshots/{snapshot_name}/clones",
+            volume_id=volume_id,
+            snapshot_name=snapshot_name,
+        )
+
+    def create_volume_snapshot_clone(self, volume_id: str, snapshot_name: str):
+        return self.post_request(
+            "/volumes/{volume_id}/snapshots/{snapshot_name}/clones",
+            volume_id=volume_id,
+            snapshot_name=snapshot_name,
+        )

syneto_api-0.1.0/src/syneto_api/virt_api.py

@@ -0,0 +1,21 @@
+import os
+from .api_client import APIClientBase
+
+
+class Virtualization(APIClientBase):
+    def __init__(self, url_base=None, **kwargs):
+        super().__init__(
+            url_base or os.environ.get("VIRTUALIZATION_SERVICE", ""), **kwargs
+        )
+
+    def get_hypervisors(self):
+        return self.get_request("/hypervisors/")
+
+    def get_vms(self):
+        return self.get_request("/hypervisors/vms")
+
+    def get_hosts(self):
+        return self.get_request("/hypervisors/hosts")
+
+    def get_datastores(self):
+        return self.get_request("/hypervisors/datastores")