osc_sdk_python 0.39.2__py3-none-any.whl

osc_sdk_python/outscale_gateway.py

@@ -0,0 +1,322 @@
+import os
+import sys
+from .call import Call
+from .limiter import RateLimiter
+import ruamel.yaml
+from .version import get_version
+import warnings
+from datetime import timedelta
+
+type_mapping = {"boolean": "bool", "string": "str", "integer": "int", "array": "list"}
+
+# Logs Output Options
+LOG_NONE = 0
+LOG_STDERR = 1
+LOG_STDIO = 2
+LOG_MEMORY = 4
+
+# what to Log
+LOG_ALL = 0
+LOG_KEEP_ONLY_LAST_REQ = 1
+
+# Default
+DEFAULT_LIMITER_WINDOW = timedelta(seconds=1)  # 1 second
+DEFAULT_LIMITER_MAX_REQUESTS = 5  # 5 requests / sec
+
+
+class ActionNotExists(NotImplementedError):
+    pass
+
+
+class ParameterNotValid(NotImplementedError):
+    pass
+
+
+class ParameterIsRequired(NotImplementedError):
+    pass
+
+
+class ParameterHasWrongType(NotImplementedError):
+    pass
+
+
+class Logger:
+    string = ""
+    type = LOG_NONE
+    what = LOG_ALL
+
+    def config(self, type=None, what=None):
+        if type is not None:
+            self.type = type
+        if what is not None:
+            self.what = what
+
+    def str(self):
+        if self.type == LOG_MEMORY:
+            return self.string
+        return None
+
+    def do_log(self, s):
+        if self.type & LOG_MEMORY:
+            if self.what == LOG_KEEP_ONLY_LAST_REQ:
+                self.string = s
+            else:
+                self.string = self.string + "\n" + s
+
+        if self.type & LOG_STDIO:
+            print(s)
+        if self.type & LOG_STDERR:
+            print(s, file=sys.stderr)
+
+
+class BaseAPI:
+    def __init__(self, spec, **kwargs):
+        self._load_gateway_structure(spec)
+        self._load_errors()
+        self.log = Logger()
+        self.limiter = RateLimiter(DEFAULT_LIMITER_WINDOW, DEFAULT_LIMITER_MAX_REQUESTS)
+        self.call = Call(
+            logger=self.log,
+            version=self.endpoint_api_version,
+            limiter=self.limiter,
+            **kwargs,
+        )
+
+    def update_credentials(self, **kwargs):
+        warnings.warn(
+            "update_credentials in deprecated. Use update_profile instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.update_profile(**kwargs)
+
+    def update_profile(self, **kwargs):
+        """
+        destroy and create a new credential map use for each call.
+        so you can change your ak/sk, region without having to recreate the whole Gateway
+        as the object is recreate, you can't expect to keep parameter from the old configuration
+        example: just updating the password, without renter the login will fail
+        """
+        self.call.update_profile(**kwargs)
+
+    def access_key(self):
+        return self.call.profile.access_key
+
+    def secret_key(self):
+        return self.call.profile.secret_key
+
+    def region(self):
+        return self.call.profile.region
+
+    def email(self):
+        warnings.warn(
+            "email in deprecated. Use login instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.login()
+
+    def login(self):
+        return self.call.profile.login
+
+    def password(self):
+        return self.call.profile.password
+
+    def _convert(self, input_file):
+        structure = {}
+        try:
+            with open(input_file, "r") as fi:
+                yaml = ruamel.yaml.YAML(typ="safe")
+                content = yaml.load(fi.read())
+        except Exception as err:
+            print("Problem reading {}:{}".format(input_file, str(err)))
+        self.api_version = content["info"]["version"]
+        self.endpoint_api_version = content["servers"][0]["url"].split("/")[-1]
+        for action, params in content["components"]["schemas"].items():
+            if action.endswith("Request"):
+                action_name = action.split("Request")[0]
+                structure[action_name] = {}
+                for propertie_name, properties in params["properties"].items():
+                    if propertie_name == "DryRun":
+                        continue
+                    if "type" not in properties.keys():
+                        action_type = None
+                    else:
+                        action_type = type_mapping[properties["type"]]
+                    structure[action_name][propertie_name] = {
+                        "type": action_type,
+                        "required": False,
+                    }
+
+                if "required" in params.keys():
+                    for required in params["required"]:
+                        structure[action_name][required]["required"] = True
+        return structure
+
+    def _load_gateway_structure(self, spec):
+        self.gateway_structure = self._convert(spec)
+
+    def _load_errors(self):
+        dir_path = os.path.join(os.path.dirname(__file__))
+        yaml_file = os.path.abspath("{}/resources/gateway_errors.yaml".format(dir_path))
+        with open(yaml_file, "r") as yam:
+            yaml = ruamel.yaml.YAML(typ="safe")
+            self.gateway_errors = yaml.load(yam.read())
+
+    def _check_parameters_type(self, action_structure, input_structure):
+        for i_param, i_value in input_structure.items():
+            if (
+                i_param != "Filters"
+                and action_structure[i_param]["type"] is not None
+                and action_structure[i_param]["type"] != i_value.__class__.__name__
+            ):
+                raise ParameterHasWrongType(
+                    "{} is <{}> instead of <{}>".format(
+                        i_param,
+                        i_value.__class__.__name__,
+                        action_structure[i_param]["type"],
+                    )
+                )
+
+    def _check_parameters_required(self, action_structure, input_structure):
+        action_mandatory_params = [
+            param for param in action_structure if action_structure[param]["required"]
+        ]
+        difference = set(action_mandatory_params).difference(
+            set(input_structure.keys())
+        )
+        if difference:
+            raise ParameterIsRequired(
+                "Missing {}. Required parameters are {}".format(
+                    ", ".join(list(difference)), ", ".join(action_mandatory_params)
+                )
+            )
+
+    def _check_parameters_valid(self, action_name, params):
+        structure_parameters = self.gateway_structure[action_name].keys()
+        input_parameters = set(params)
+        different_parameters = list(
+            input_parameters.difference(set(structure_parameters))
+        )
+        if different_parameters:
+            raise ParameterNotValid(
+                """{}. Available parameters on sdk: {} api: {} are: {}.""".format(
+                    ", ".join(different_parameters),
+                    get_version(),
+                    self.api_version,
+                    ", ".join(structure_parameters),
+                )
+            )
+
+    def _check(self, action_name, **params):
+        if action_name not in self.gateway_structure:
+            raise ActionNotExists(
+                "Action {} does not exists for python sdk: {} with api: {}".format(
+                    action_name, get_version(), self.api_version
+                )
+            )
+        self._check_parameters_valid(action_name, params)
+        self._check_parameters_required(self.gateway_structure[action_name], params)
+        self._check_parameters_type(self.gateway_structure[action_name], params)
+
+    @staticmethod
+    def _remove_none_parameters(**params):
+        """
+        Remove parameters having None as value
+        to perform CreateVolumes(Iops=None, Size=10)
+        """
+        return {key: value for key, value in params.items() if value is not None}
+
+    def _get_action(self, action_name):
+        def action(**kwargs):
+            kwargs = self._remove_none_parameters(**kwargs)
+            self._check(action_name, **kwargs)
+            result = self.call.api(action_name, **kwargs)
+            return result
+
+        return action
+
+    def __getattr__(self, attr):
+        return self._get_action(attr)
+
+    def __dir__(self):
+        return self.gateway_structure.keys()
+
+    def raw(self, action_name, **kwargs):
+        return self.call.api(action_name, **kwargs)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.call.close()
+
+
+class OutscaleGateway(BaseAPI):
+    def __init__(self, **kwargs):
+        super().__init__(
+            os.path.join(os.path.dirname(__file__), "resources/outscale.yaml"), **kwargs
+        )
+
+
+def test():
+    a = OutscaleGateway()
+    a.CreateVms(
+        ImageId="ami-xx",
+        BlockDeviceMappings=[{"/dev/sda1": {"Size": 10}}],
+        SecurityGroupIds=["sg-aaa", "sg-bbb"],
+    )
+    try:
+        a.CreateVms(
+            ImageId="ami-xx",
+            BlockDeviceMappings=[{"/dev/sda1": {"Size": 10}}],
+            SecurityGroupIds=["sg-aaa", "sg-bbb"],
+            Wrong="wrong",
+        )
+    except ParameterNotValid:
+        pass
+    else:
+        raise AssertionError()
+    try:
+        a.CreateVms(
+            BlockDeviceMappings=[{"/dev/sda1": {"Size": 10}}],
+            SecurityGroupIds=["sg-aaa", "sg-bbb"],
+        )
+    except ParameterIsRequired:
+        pass
+    else:
+        raise AssertionError()
+    try:
+        a.CreateVms(
+            ImageId=["ami-xxx"],
+            BlockDeviceMappings=[{"/dev/sda1": {"Size": 10}}],
+            SecurityGroupIds=["sg-aaa", "sg-bbb"],
+        )
+    except ParameterHasWrongType:
+        pass
+    else:
+        raise AssertionError()
+    try:
+        a.CreateVms(
+            ImageId="ami-xxx",
+            BlockDeviceMappings=[{"/dev/sda1": {"Size": 10}}],
+            SecurityGroupIds="wrong",
+        )
+    except ParameterHasWrongType:
+        pass
+    else:
+        raise AssertionError()
+    try:
+        a.CreateVms(
+            ImageId=["ami-wrong"],
+            BlockDeviceMappings=[{"/dev/sda1": {"Size": 10}}],
+            SecurityGroupIds="wrong",
+        )
+    except ParameterHasWrongType:
+        pass
+    else:
+        raise AssertionError()
+
+
+if __name__ == "__main__":
+    test()

osc_sdk_python/problem.py

@@ -0,0 +1,100 @@
+import json
+
+
+class ProblemDecoder(json.JSONDecoder):
+    def decode(self, s):
+        data = super().decode(s)
+        if isinstance(data, dict):
+            return self._make_problem(data)
+        return data
+
+    def _make_problem(self, data):
+        type_ = data.pop("type", None)
+        status = data.pop("status", None)
+        title = data.pop("title", None)
+        detail = data.pop("detail", None)
+        instance = data.pop("instance", None)
+        return Problem(type_, status, title, detail, instance, **data)
+
+
+class Problem(Exception):
+    def __init__(self, type_, status, title, detail, instance, **kwargs):
+        self._type = type_ or "about:blank"
+        self.status = status
+        self.title = title
+        self.detail = detail
+        self.instance = instance
+        self.extras = kwargs
+
+        for k in self.extras:
+            if k in ["type", "status", "title", "detail", "instance"]:
+                raise ValueError(f"Reserved key '{k}' used in Problem extra arguments.")
+
+    def __str__(self):
+        return self.title
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}<type={self._type}; status={self.status}; title={self.title}>"
+
+    def msg(self):
+        msg = (
+            f"type = {self._type}, "
+            f"status = {self.status}, "
+            f"title = {self.title}, "
+            f"detail = {self.detail}, "
+            f"instance = {self.instance}, "
+            f"extras = {self.extras}"
+        )
+        return msg
+
+    @property
+    def type(self):
+        return self._type
+
+
+class LegacyProblemDecoder(json.JSONDecoder):
+    def decode(self, s):
+        data = super().decode(s)
+        if isinstance(data, dict):
+            return self._make_legacy_problem(data)
+        return data
+
+    def _make_legacy_problem(self, data):
+        request_id = None
+        error_code = None
+        code_type = None
+
+        if "__type" in data:
+            error_code = data.get("__type")
+        else:
+            request_id = (data.get("ResponseContext") or {}).get("RequestId")
+            errors = data.get("Errors")
+            if errors:
+                error = errors[0]
+                error_code = error.get("Code")
+                reason = error.get("Type")
+                if error.get("Details"):
+                    code_type = reason
+                else:
+                    code_type = None
+        return LegacyProblem(None, error_code, code_type, request_id, None)
+
+
+class LegacyProblem(Exception):
+    def __init__(self, status, error_code, code_type, request_id, url):
+        self.status = status
+        self.error_code = error_code
+        self.code_type = code_type
+        self.request_id = request_id
+        self.url = url
+
+    def msg(self):
+        msg = (
+            f"status = {self.status}, "
+            f"code = {self.error_code}, "
+            f"{'code_type = ' if self.code_type is not None else ''}"
+            f"{self.code_type + ', ' if self.code_type is not None else ''}"
+            f"request_id = {self.request_id}, "
+            f"url = {self.url}"
+        )
+        return msg

osc_sdk_python/requester.py

@@ -0,0 +1,29 @@
+from .retry import Retry
+
+
+class Requester:
+    def __init__(self, session, auth, endpoint, **kwargs):
+        self.session = session
+        self.auth = auth
+        self.endpoint = endpoint
+        self.request_kwargs = kwargs
+
+    def send(self, uri, payload):
+        headers = None
+        if self.auth.is_basic_auth_configured():
+            headers = self.auth.get_basic_auth_header()
+        else:
+            headers = self.auth.forge_headers_signed(uri, payload)
+
+        if self.auth.x509_client_cert is not None:
+            cert_file = self.auth.x509_client_cert
+        else:
+            cert_file = None
+
+        retry_kwargs = self.request_kwargs.copy()
+        retry_kwargs.update(
+            {"data": payload, "headers": headers, "verify": True, "cert": cert_file}
+        )
+
+        response = Retry(self.session, "post", self.endpoint, **retry_kwargs)
+        return response.execute().json()