stackit-vpn 0.1.0__py3-none-any.whl

src/stackit/vpn/models/tunnel_status.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr, field_validator
+from typing_extensions import Self
+
+from stackit.vpn.models.phase1_status import Phase1Status
+from stackit.vpn.models.phase2_status import Phase2Status
+
+
+class TunnelStatus(BaseModel):
+    """
+    Describes the status of the VPN itself.
+    """  # noqa: E501
+
+    established: Optional[StrictBool] = None
+    name: Optional[StrictStr] = None
+    phase1: Optional[Phase1Status] = None
+    phase2: Optional[Phase2Status] = None
+    __properties: ClassVar[List[str]] = ["established", "name", "phase1", "phase2"]
+
+    @field_validator("name")
+    def name_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(["tunnel1", "tunnel2"]):
+            raise ValueError("must be one of enum values ('tunnel1', 'tunnel2')")
+        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 TunnelStatus 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of phase1
+        if self.phase1:
+            _dict["phase1"] = self.phase1.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of phase2
+        if self.phase2:
+            _dict["phase2"] = self.phase2.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TunnelStatus from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "established": obj.get("established"),
+                "name": obj.get("name"),
+                "phase1": Phase1Status.from_dict(obj["phase1"]) if obj.get("phase1") is not None else None,
+                "phase2": Phase2Status.from_dict(obj["phase2"]) if obj.get("phase2") is not None else None,
+            }
+        )
+        return _obj

src/stackit/vpn/models/update_gateway_connection_payload.py

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, field_validator
+from typing_extensions import Annotated, Self
+
+from stackit.vpn.models.tunnel_configuration import TunnelConfiguration
+
+
+class UpdateGatewayConnectionPayload(BaseModel):
+    """
+    UpdateGatewayConnectionPayload
+    """  # noqa: E501
+
+    display_name: Annotated[str, Field(strict=True)] = Field(
+        description="A user-friendly name for the connection.", alias="displayName"
+    )
+    enabled: Optional[StrictBool] = Field(
+        default=None, description="This flag decides whether this connection should be enabled or disabled"
+    )
+    local_subnets: Optional[
+        Annotated[List[Annotated[str, Field(strict=True)]], Field(min_length=1, max_length=100)]
+    ] = Field(
+        default=None,
+        description="Optional. Defaults to 0.0.0.0/0 for Route-based VPN configurations. Mandatory for Policy-based.",
+        alias="localSubnets",
+    )
+    remote_subnets: Optional[
+        Annotated[List[Annotated[str, Field(strict=True)]], Field(min_length=1, max_length=100)]
+    ] = Field(
+        default=None,
+        description="Optional. Defaults to 0.0.0.0/0 for Route-based VPN configurations. Mandatory for Policy-based.",
+        alias="remoteSubnets",
+    )
+    static_routes: Optional[List[Annotated[str, Field(strict=True)]]] = Field(
+        default=None, description="Optional. Use this for route-based VPN.", alias="staticRoutes"
+    )
+    tunnel1: TunnelConfiguration
+    tunnel2: TunnelConfiguration
+    __properties: ClassVar[List[str]] = [
+        "displayName",
+        "enabled",
+        "localSubnets",
+        "remoteSubnets",
+        "staticRoutes",
+        "tunnel1",
+        "tunnel2",
+    ]
+
+    @field_validator("display_name")
+    def display_name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/")
+        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 UpdateGatewayConnectionPayload 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of tunnel1
+        if self.tunnel1:
+            _dict["tunnel1"] = self.tunnel1.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of tunnel2
+        if self.tunnel2:
+            _dict["tunnel2"] = self.tunnel2.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UpdateGatewayConnectionPayload 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"),
+                "enabled": obj.get("enabled"),
+                "localSubnets": obj.get("localSubnets"),
+                "remoteSubnets": obj.get("remoteSubnets"),
+                "staticRoutes": obj.get("staticRoutes"),
+                "tunnel1": TunnelConfiguration.from_dict(obj["tunnel1"]) if obj.get("tunnel1") is not None else None,
+                "tunnel2": TunnelConfiguration.from_dict(obj["tunnel2"]) if obj.get("tunnel2") is not None else None,
+            }
+        )
+        return _obj

src/stackit/vpn/models/update_vpn_gateway_payload.py

@@ -0,0 +1,124 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+import re  # noqa: F401
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing_extensions import Annotated, Self
+
+from stackit.vpn.models.bgp_gateway_config import BGPGatewayConfig
+from stackit.vpn.models.create_vpn_gateway_payload_availability_zones import (
+    CreateVPNGatewayPayloadAvailabilityZones,
+)
+from stackit.vpn.models.routing_type import RoutingType
+
+
+class UpdateVPNGatewayPayload(BaseModel):
+    """
+    UpdateVPNGatewayPayload
+    """  # noqa: E501
+
+    availability_zones: CreateVPNGatewayPayloadAvailabilityZones = Field(alias="availabilityZones")
+    bgp: Optional[BGPGatewayConfig] = None
+    display_name: Annotated[str, Field(strict=True)] = Field(
+        description="A user-friendly name for the VPN gateway.", alias="displayName"
+    )
+    labels: Optional[Dict[str, Annotated[str, Field(strict=True, max_length=63)]]] = Field(
+        default=None,
+        description="Map of custom labels. Key and values must be a string with max 63 chars, start/end with alphanumeric. The key of a label follows the same rules as the `LabelValue` except that it cannot be empty. ",
+    )
+    plan_id: StrictStr = Field(description="The service plan identifier.", alias="planId")
+    routing_type: RoutingType = Field(alias="routingType")
+    __properties: ClassVar[List[str]] = ["availabilityZones", "bgp", "displayName", "labels", "planId", "routingType"]
+
+    @field_validator("display_name")
+    def display_name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/")
+        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 UpdateVPNGatewayPayload 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of availability_zones
+        if self.availability_zones:
+            _dict["availabilityZones"] = self.availability_zones.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of bgp
+        if self.bgp:
+            _dict["bgp"] = self.bgp.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of UpdateVPNGatewayPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "availabilityZones": (
+                    CreateVPNGatewayPayloadAvailabilityZones.from_dict(obj["availabilityZones"])
+                    if obj.get("availabilityZones") is not None
+                    else None
+                ),
+                "bgp": BGPGatewayConfig.from_dict(obj["bgp"]) if obj.get("bgp") is not None else None,
+                "displayName": obj.get("displayName"),
+                "labels": obj.get("labels"),
+                "planId": obj.get("planId"),
+                "routingType": obj.get("routingType"),
+            }
+        )
+        return _obj

src/stackit/vpn/models/vpn_tunnels.py

@@ -0,0 +1,114 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing_extensions import Self
+
+from stackit.vpn.models.bgp_status import BGPStatus
+from stackit.vpn.models.gateway_status import GatewayStatus
+
+
+class VPNTunnels(BaseModel):
+    """
+    Status of the underlying tunnel instances.
+    """  # noqa: E501
+
+    bgp_status: Optional[BGPStatus] = Field(default=None, alias="bgpStatus")
+    instance_state: Optional[GatewayStatus] = Field(default=None, alias="instanceState")
+    name: Optional[StrictStr] = None
+    public_ip: Optional[StrictStr] = Field(
+        default=None, description="The public IPv4 address of this endpoint.", alias="publicIP"
+    )
+    __properties: ClassVar[List[str]] = ["bgpStatus", "instanceState", "name", "publicIP"]
+
+    @field_validator("name")
+    def name_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(["tunnel1", "tunnel2"]):
+            raise ValueError("must be one of enum values ('tunnel1', 'tunnel2')")
+        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 VPNTunnels 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,
+        )
+        # override the default output from pydantic by calling `to_dict()` of bgp_status
+        if self.bgp_status:
+            _dict["bgpStatus"] = self.bgp_status.to_dict()
+        # set to None if bgp_status (nullable) is None
+        # and model_fields_set contains the field
+        if self.bgp_status is None and "bgp_status" in self.model_fields_set:
+            _dict["bgpStatus"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of VPNTunnels from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "bgpStatus": BGPStatus.from_dict(obj["bgpStatus"]) if obj.get("bgpStatus") is not None else None,
+                "instanceState": obj.get("instanceState"),
+                "name": obj.get("name"),
+                "publicIP": obj.get("publicIP"),
+            }
+        )
+        return _obj

src/stackit/vpn/rest.py

@@ -0,0 +1,164 @@
+# coding: utf-8
+
+"""
+    STACKIT VPN API
+
+    Provision and manage STACKIT VPN gateways.  Use this API to establish secure, encrypted IPsec tunnels between your STACKIT Network Area (SNA) and external networks. The service supports the following routing architectures: - Policy-based IPsec - Static route-based IPsec - Dynamic BGP IPsec
+
+    The version of the OpenAPI document: 1beta1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+import io
+import json
+import re
+
+import requests
+from stackit.core.authorization import Authorization
+from stackit.core.configuration import Configuration
+
+from stackit.vpn.exceptions import ApiException, ApiValueError
+
+
+RESTResponseType = requests.Response
+
+
+class RESTResponse(io.IOBase):
+
+    def __init__(self, resp) -> None:
+        self.response = resp
+        self.status = resp.status_code
+        self.reason = resp.reason
+        self.data = None
+
+    def read(self):
+        if self.data is None:
+            self.data = self.response.content
+        return self.data
+
+    @property
+    def headers(self):
+        """Returns a dictionary of response headers."""
+        return self.response.headers
+
+    def getheaders(self):
+        """Returns a dictionary of the response headers; use ``headers`` instead."""
+        return self.response.headers
+
+    def getheader(self, name, default=None):
+        """Returns a given response header; use ``headers.get()`` instead."""
+        return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+    def __init__(self, config: Configuration) -> None:
+        self.session = config.custom_http_session if config.custom_http_session else requests.Session()
+        authorization = Authorization(config)
+        self.session.auth = authorization.auth_method
+
+    def request(self, method, url, headers=None, body=None, post_params=None, _request_timeout=None):
+        """Perform requests.
+
+        :param method: http request method
+        :param url: http request url
+        :param headers: http request headers
+        :param body: request json body, for `application/json`
+        :param post_params: request post parameters,
+                            `application/x-www-form-urlencoded`
+                            and `multipart/form-data`
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        """
+        method = method.upper()
+        if method not in ["GET", "HEAD", "DELETE", "POST", "PUT", "PATCH", "OPTIONS"]:
+            raise ValueError("Method %s not allowed", method)
+
+        if post_params and body:
+            raise ApiValueError("body parameter cannot be used with post_params parameter.")
+
+        post_params = post_params or {}
+        headers = headers or {}
+
+        try:
+            # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
+            if method in ["POST", "PUT", "PATCH", "OPTIONS", "DELETE"]:
+
+                # no content type provided or payload is json
+                content_type = headers.get("Content-Type")
+                if not content_type or re.search("json", content_type, re.IGNORECASE):
+                    request_body = None
+                    if body is not None:
+                        request_body = json.dumps(body)
+                    r = self.session.request(
+                        method,
+                        url,
+                        data=request_body,
+                        headers=headers,
+                        timeout=_request_timeout,
+                    )
+                elif content_type == "application/x-www-form-urlencoded":
+                    r = self.session.request(
+                        method,
+                        url,
+                        params=post_params,
+                        headers=headers,
+                        timeout=_request_timeout,
+                    )
+                elif content_type == "multipart/form-data":
+                    # must del headers['Content-Type'], or the correct
+                    # Content-Type which generated by urllib3 will be
+                    # overwritten.
+                    del headers["Content-Type"]
+                    # Ensures that dict objects are serialized
+                    post_params = [(a, json.dumps(b)) if isinstance(b, dict) else (a, b) for a, b in post_params]
+                    r = self.session.request(
+                        method,
+                        url,
+                        files=post_params,
+                        headers=headers,
+                        timeout=_request_timeout,
+                    )
+                # Pass a `string` parameter directly in the body to support
+                # other content types than JSON when `body` argument is
+                # provided in serialized form.
+                elif isinstance(body, str) or isinstance(body, bytes):
+                    r = self.session.request(
+                        method,
+                        url,
+                        data=body,
+                        headers=headers,
+                        timeout=_request_timeout,
+                    )
+                elif headers["Content-Type"].startswith("text/") and isinstance(body, bool):
+                    request_body = "true" if body else "false"
+                    r = self.session.request(
+                        method,
+                        url,
+                        data=request_body,
+                        headers=headers,
+                        timeout=_request_timeout,
+                    )
+                else:
+                    # Cannot generate the request from given parameters
+                    msg = """Cannot prepare a request message for provided
+                             arguments. Please check that your arguments match
+                             declared content type."""
+                    raise ApiException(status=0, reason=msg)
+            # For `GET`, `HEAD`
+            else:
+                r = self.session.request(
+                    method,
+                    url,
+                    params={},
+                    headers=headers,
+                    timeout=_request_timeout,
+                )
+        except requests.exceptions.SSLError as e:
+            msg = "\n".join([type(e).__name__, str(e)])
+            raise ApiException(status=0, reason=msg)
+
+        return RESTResponse(r)