stackit-loadbalancer 0.0.1a1__py3-none-any.whl

stackit/loadbalancer/configuration.py

@@ -0,0 +1,111 @@
+# coding: utf-8
+
+"""
+    Load Balancer API
+
+    This API offers an interface to provision and manage load balancing servers in your STACKIT project. It also has the possibility of pooling target servers for load balancing purposes.  For each load balancer provided, two VMs are deployed in your OpenStack project subject to a fee.
+
+    The version of the OpenAPI document: 1.7.2
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+
+class HostConfiguration:
+    def __init__(
+        self,
+        region=None,
+        server_index=None,
+        server_variables=None,
+        server_operation_index=None,
+        server_operation_variables=None,
+        ignore_operation_servers=False,
+    ) -> None:
+        """Constructor"""
+        self._base_path = "https://load-balancer.api.eu01.stackit.cloud"
+        """Default Base url
+        """
+        self.server_index = 0 if server_index is None else server_index
+        self.server_operation_index = server_operation_index or {}
+        """Default server index
+        """
+        self.server_variables = server_variables or {}
+        if region:
+            self.server_variables["region"] = "{}.".format(region)
+        self.server_operation_variables = server_operation_variables or {}
+        """Default server variables
+        """
+        self.ignore_operation_servers = ignore_operation_servers
+        """Ignore operation servers
+        """
+
+    def get_host_settings(self):
+        """Gets an array of host settings
+
+        :return: An array of host settings
+        """
+        return [
+            {
+                "url": "https://load-balancer.api.{region}stackit.cloud",
+                "description": "No description provided",
+                "variables": {
+                    "region": {
+                        "description": "No description provided",
+                        "default_value": "eu01.",
+                        "enum_values": ["eu01."],
+                    }
+                },
+            }
+        ]
+
+    def get_host_from_settings(self, index, variables=None, servers=None):
+        """Gets host URL based on the index and variables
+        :param index: array index of the host settings
+        :param variables: hash of variable and the corresponding value
+        :param servers: an array of host settings or None
+        :return: URL based on host settings
+        """
+        if index is None:
+            return self._base_path
+
+        variables = {} if variables is None else variables
+        servers = self.get_host_settings() if servers is None else servers
+
+        try:
+            server = servers[index]
+        except IndexError:
+            raise ValueError(
+                "Invalid index {0} when selecting the host settings. "
+                "Must be less than {1}".format(index, len(servers))
+            )
+
+        url = server["url"]
+
+        # go through variables and replace placeholders
+        for variable_name, variable in server.get("variables", {}).items():
+            used_value = variables.get(variable_name, variable["default_value"])
+
+            if "enum_values" in variable and used_value not in variable["enum_values"]:
+                given_value = variables[variable_name].replace(".", "")
+                valid_values = [v.replace(".", "") for v in variable["enum_values"]]
+                raise ValueError(
+                    "The variable `{0}` in the host URL has invalid value '{1}'. Must be '{2}'.".format(
+                        variable_name, given_value, valid_values
+                    )
+                )
+
+            url = url.replace("{" + variable_name + "}", used_value)
+
+        return url
+
+    @property
+    def host(self):
+        """Return generated host."""
+        return self.get_host_from_settings(self.server_index, variables=self.server_variables)
+
+    @host.setter
+    def host(self, value):
+        """Fix base path."""
+        self._base_path = value
+        self.server_index = None

stackit/loadbalancer/exceptions.py

@@ -0,0 +1,198 @@
+# coding: utf-8
+
+"""
+    Load Balancer API
+
+    This API offers an interface to provision and manage load balancing servers in your STACKIT project. It also has the possibility of pooling target servers for load balancing purposes.  For each load balancer provided, two VMs are deployed in your OpenStack project subject to a fee.
+
+    The version of the OpenAPI document: 1.7.2
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from typing import Any, Optional
+
+from typing_extensions import Self
+
+
+class OpenApiException(Exception):
+    """The base exception class for all OpenAPIExceptions"""
+
+
+class ApiTypeError(OpenApiException, TypeError):
+    def __init__(self, msg, path_to_item=None, valid_classes=None, key_type=None) -> None:
+        """Raises an exception for TypeErrors
+
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (list): a list of keys an indices to get to the
+                                 current_item
+                                 None if unset
+            valid_classes (tuple): the primitive classes that current item
+                                   should be an instance of
+                                   None if unset
+            key_type (bool): False if our value is a value in a dict
+                             True if it is a key in a dict
+                             False if our item is an item in a list
+                             None if unset
+        """
+        self.path_to_item = path_to_item
+        self.valid_classes = valid_classes
+        self.key_type = key_type
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiTypeError, self).__init__(full_msg)
+
+
+class ApiValueError(OpenApiException, ValueError):
+    def __init__(self, msg, path_to_item=None) -> None:
+        """
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (list) the path to the exception in the
+                received_data dict. None if unset
+        """
+
+        self.path_to_item = path_to_item
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiValueError, self).__init__(full_msg)
+
+
+class ApiAttributeError(OpenApiException, AttributeError):
+    def __init__(self, msg, path_to_item=None) -> None:
+        """
+        Raised when an attribute reference or assignment fails.
+
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (None/list) the path to the exception in the
+                received_data dict
+        """
+        self.path_to_item = path_to_item
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiAttributeError, self).__init__(full_msg)
+
+
+class ApiKeyError(OpenApiException, KeyError):
+    def __init__(self, msg, path_to_item=None) -> None:
+        """
+        Args:
+            msg (str): the exception message
+
+        Keyword Args:
+            path_to_item (None/list) the path to the exception in the
+                received_data dict
+        """
+        self.path_to_item = path_to_item
+        full_msg = msg
+        if path_to_item:
+            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+        super(ApiKeyError, self).__init__(full_msg)
+
+
+class ApiException(OpenApiException):
+
+    def __init__(
+        self,
+        status=None,
+        reason=None,
+        http_resp=None,
+        *,
+        body: Optional[str] = None,
+        data: Optional[Any] = None,
+    ) -> None:
+        self.status = status
+        self.reason = reason
+        self.body = body
+        self.data = data
+        self.headers = None
+
+        if http_resp:
+            if self.status is None:
+                self.status = http_resp.status
+            if self.reason is None:
+                self.reason = http_resp.reason
+            if self.body is None:
+                try:
+                    self.body = http_resp.data.decode("utf-8")
+                except Exception:  # noqa: S110
+                    pass
+            self.headers = http_resp.getheaders()
+
+    @classmethod
+    def from_response(
+        cls,
+        *,
+        http_resp,
+        body: Optional[str],
+        data: Optional[Any],
+    ) -> Self:
+        if http_resp.status == 400:
+            raise BadRequestException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 401:
+            raise UnauthorizedException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 403:
+            raise ForbiddenException(http_resp=http_resp, body=body, data=data)
+
+        if http_resp.status == 404:
+            raise NotFoundException(http_resp=http_resp, body=body, data=data)
+
+        if 500 <= http_resp.status <= 599:
+            raise ServiceException(http_resp=http_resp, body=body, data=data)
+        raise ApiException(http_resp=http_resp, body=body, data=data)
+
+    def __str__(self):
+        """Custom error messages for exception"""
+        error_message = "({0})\n" "Reason: {1}\n".format(self.status, self.reason)
+        if self.headers:
+            error_message += "HTTP response headers: {0}\n".format(self.headers)
+
+        if self.data or self.body:
+            error_message += "HTTP response body: {0}\n".format(self.data or self.body)
+
+        return error_message
+
+
+class BadRequestException(ApiException):
+    pass
+
+
+class NotFoundException(ApiException):
+    pass
+
+
+class UnauthorizedException(ApiException):
+    pass
+
+
+class ForbiddenException(ApiException):
+    pass
+
+
+class ServiceException(ApiException):
+    pass
+
+
+def render_path(path_to_item):
+    """Returns a string representation of a path"""
+    result = ""
+    for pth in path_to_item:
+        if isinstance(pth, int):
+            result += "[{0}]".format(pth)
+        else:
+            result += "['{0}']".format(pth)
+    return result

stackit/loadbalancer/models/__init__.py

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+# flake8: noqa
+"""
+    Load Balancer API
+
+    This API offers an interface to provision and manage load balancing servers in your STACKIT project. It also has the possibility of pooling target servers for load balancing purposes.  For each load balancer provided, two VMs are deployed in your OpenStack project subject to a fee.
+
+    The version of the OpenAPI document: 1.7.2
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+
+# import models into model package
+from stackit.loadbalancer.models.active_health_check import ActiveHealthCheck
+from stackit.loadbalancer.models.create_credentials_payload import (
+    CreateCredentialsPayload,
+)
+from stackit.loadbalancer.models.create_credentials_response import (
+    CreateCredentialsResponse,
+)
+from stackit.loadbalancer.models.create_load_balancer_payload import (
+    CreateLoadBalancerPayload,
+)
+from stackit.loadbalancer.models.credentials_response import CredentialsResponse
+from stackit.loadbalancer.models.get_credentials_response import GetCredentialsResponse
+from stackit.loadbalancer.models.get_quota_response import GetQuotaResponse
+from stackit.loadbalancer.models.get_service_status_response import (
+    GetServiceStatusResponse,
+)
+from stackit.loadbalancer.models.google_protobuf_any import GoogleProtobufAny
+from stackit.loadbalancer.models.list_credentials_response import (
+    ListCredentialsResponse,
+)
+from stackit.loadbalancer.models.list_load_balancers_response import (
+    ListLoadBalancersResponse,
+)
+from stackit.loadbalancer.models.list_plans_response import ListPlansResponse
+from stackit.loadbalancer.models.listener import Listener
+from stackit.loadbalancer.models.load_balancer import LoadBalancer
+from stackit.loadbalancer.models.load_balancer_error import LoadBalancerError
+from stackit.loadbalancer.models.load_balancer_options import LoadBalancerOptions
+from stackit.loadbalancer.models.loadbalancer_option_access_control import (
+    LoadbalancerOptionAccessControl,
+)
+from stackit.loadbalancer.models.loadbalancer_option_logs import LoadbalancerOptionLogs
+from stackit.loadbalancer.models.loadbalancer_option_metrics import (
+    LoadbalancerOptionMetrics,
+)
+from stackit.loadbalancer.models.loadbalancer_option_observability import (
+    LoadbalancerOptionObservability,
+)
+from stackit.loadbalancer.models.network import Network
+from stackit.loadbalancer.models.options_tcp import OptionsTCP
+from stackit.loadbalancer.models.options_udp import OptionsUDP
+from stackit.loadbalancer.models.plan_details import PlanDetails
+from stackit.loadbalancer.models.server_name_indicator import ServerNameIndicator
+from stackit.loadbalancer.models.session_persistence import SessionPersistence
+from stackit.loadbalancer.models.status import Status
+from stackit.loadbalancer.models.target import Target
+from stackit.loadbalancer.models.target_pool import TargetPool
+from stackit.loadbalancer.models.update_credentials_payload import (
+    UpdateCredentialsPayload,
+)
+from stackit.loadbalancer.models.update_credentials_response import (
+    UpdateCredentialsResponse,
+)
+from stackit.loadbalancer.models.update_load_balancer_payload import (
+    UpdateLoadBalancerPayload,
+)
+from stackit.loadbalancer.models.update_target_pool_payload import (
+    UpdateTargetPoolPayload,
+)

stackit/loadbalancer/models/active_health_check.py

@@ -0,0 +1,142 @@
+# coding: utf-8
+
+"""
+    Load Balancer API
+
+    This API offers an interface to provision and manage load balancing servers in your STACKIT project. It also has the possibility of pooling target servers for load balancing purposes.  For each load balancer provided, two VMs are deployed in your OpenStack project subject to a fee.
+
+    The version of the OpenAPI document: 1.7.2
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+import re
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, field_validator
+from typing_extensions import Annotated, Self
+
+
+class ActiveHealthCheck(BaseModel):
+    """
+    ActiveHealthCheck
+    """
+
+    healthy_threshold: Optional[StrictInt] = Field(
+        default=None, description="Healthy threshold of the health checking", alias="healthyThreshold"
+    )
+    interval: Optional[Annotated[str, Field(strict=True)]] = Field(
+        default=None, description="Interval duration of health checking in seconds"
+    )
+    interval_jitter: Optional[Annotated[str, Field(strict=True)]] = Field(
+        default=None,
+        description="Interval duration threshold of the health checking in seconds",
+        alias="intervalJitter",
+    )
+    timeout: Optional[Annotated[str, Field(strict=True)]] = Field(
+        default=None, description="Active health checking timeout duration in seconds"
+    )
+    unhealthy_threshold: Optional[StrictInt] = Field(
+        default=None, description="Unhealthy threshold of the health checking", alias="unhealthyThreshold"
+    )
+    __properties: ClassVar[List[str]] = [
+        "healthyThreshold",
+        "interval",
+        "intervalJitter",
+        "timeout",
+        "unhealthyThreshold",
+    ]
+
+    @field_validator("interval")
+    def interval_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^-?(?:0|[1-9][0-9]{0,11})(?:\.[0-9]{1,9})?s$", value):
+            raise ValueError(r"must validate the regular expression /^-?(?:0|[1-9][0-9]{0,11})(?:\.[0-9]{1,9})?s$/")
+        return value
+
+    @field_validator("interval_jitter")
+    def interval_jitter_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^-?(?:0|[1-9][0-9]{0,11})(?:\.[0-9]{1,9})?s$", value):
+            raise ValueError(r"must validate the regular expression /^-?(?:0|[1-9][0-9]{0,11})(?:\.[0-9]{1,9})?s$/")
+        return value
+
+    @field_validator("timeout")
+    def timeout_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^-?(?:0|[1-9][0-9]{0,11})(?:\.[0-9]{1,9})?s$", value):
+            raise ValueError(r"must validate the regular expression /^-?(?:0|[1-9][0-9]{0,11})(?:\.[0-9]{1,9})?s$/")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ActiveHealthCheck from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ActiveHealthCheck from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "healthyThreshold": obj.get("healthyThreshold"),
+                "interval": obj.get("interval"),
+                "intervalJitter": obj.get("intervalJitter"),
+                "timeout": obj.get("timeout"),
+                "unhealthyThreshold": obj.get("unhealthyThreshold"),
+            }
+        )
+        return _obj

stackit/loadbalancer/models/create_credentials_payload.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    Load Balancer API
+
+    This API offers an interface to provision and manage load balancing servers in your STACKIT project. It also has the possibility of pooling target servers for load balancing purposes.  For each load balancer provided, two VMs are deployed in your OpenStack project subject to a fee.
+
+    The version of the OpenAPI document: 1.7.2
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+import re
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing_extensions import Annotated, Self
+
+
+class CreateCredentialsPayload(BaseModel):
+    """
+    CreateCredentialsPayload
+    """
+
+    display_name: Optional[Annotated[str, Field(strict=True)]] = Field(
+        default=None, description="Credential name", alias="displayName"
+    )
+    password: Optional[StrictStr] = Field(
+        default=None,
+        description="A valid password used for an existing ARGUS instance, which is used during basic auth.",
+    )
+    username: Optional[StrictStr] = Field(
+        default=None,
+        description="A valid username used for an existing ARGUS instance, which is used during basic auth.",
+    )
+    __properties: ClassVar[List[str]] = ["displayName", "password", "username"]
+
+    @field_validator("display_name")
+    def display_name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        if not re.match(r"^[0-9a-z](?:(?:[0-9a-z]|-){0,251}[0-9a-z])?$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9a-z](?:(?:[0-9a-z]|-){0,251}[0-9a-z])?$/")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CreateCredentialsPayload from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateCredentialsPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {"displayName": obj.get("displayName"), "password": obj.get("password"), "username": obj.get("username")}
+        )
+        return _obj