mirror of
https://github.com/ansible-collections/hetzner.hcloud.git
synced 2026-02-04 08:01:49 +00:00
118 lines
3.4 KiB
Python
118 lines
3.4 KiB
Python
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING, TypedDict
|
|
|
|
from ..core import BaseDomain, DomainIdentityMixin
|
|
|
|
if TYPE_CHECKING:
|
|
from ..actions import BoundAction
|
|
from ..locations import BoundLocation
|
|
from ..rdns import DNSPtr
|
|
from ..servers import BoundServer
|
|
from .client import BoundFloatingIP
|
|
|
|
|
|
__all__ = [
|
|
"FloatingIP",
|
|
"FloatingIPProtection",
|
|
"CreateFloatingIPResponse",
|
|
]
|
|
|
|
|
|
class FloatingIP(BaseDomain, DomainIdentityMixin):
|
|
"""Floating IP Domain
|
|
|
|
:param id: int
|
|
ID of the Floating IP
|
|
:param description: str, None
|
|
Description of the Floating IP
|
|
:param ip: str
|
|
IP address of the Floating IP
|
|
:param type: str
|
|
Type of Floating IP. Choices: `ipv4`, `ipv6`
|
|
:param server: :class:`BoundServer <hcloud.servers.client.BoundServer>`, None
|
|
Server the Floating IP is assigned to, None if it is not assigned at all
|
|
:param dns_ptr: List[Dict]
|
|
Array of reverse DNS entries
|
|
:param home_location: :class:`BoundLocation <hcloud.locations.client.BoundLocation>`
|
|
Location the Floating IP was created in. Routing is optimized for this location.
|
|
:param blocked: boolean
|
|
Whether the IP is blocked
|
|
:param protection: dict
|
|
Protection configuration for the Floating IP
|
|
:param labels: dict
|
|
User-defined labels (key-value pairs)
|
|
:param created: datetime
|
|
Point in time when the Floating IP was created
|
|
:param name: str
|
|
Name of the Floating IP
|
|
"""
|
|
|
|
__api_properties__ = (
|
|
"id",
|
|
"type",
|
|
"description",
|
|
"ip",
|
|
"server",
|
|
"dns_ptr",
|
|
"home_location",
|
|
"blocked",
|
|
"protection",
|
|
"labels",
|
|
"name",
|
|
"created",
|
|
)
|
|
__slots__ = __api_properties__
|
|
|
|
def __init__(
|
|
self,
|
|
id: int | None = None,
|
|
type: str | None = None,
|
|
description: str | None = None,
|
|
ip: str | None = None,
|
|
server: BoundServer | None = None,
|
|
dns_ptr: list[DNSPtr] | None = None,
|
|
home_location: BoundLocation | None = None,
|
|
blocked: bool | None = None,
|
|
protection: FloatingIPProtection | None = None,
|
|
labels: dict[str, str] | None = None,
|
|
created: str | None = None,
|
|
name: str | None = None,
|
|
):
|
|
self.id = id
|
|
self.type = type
|
|
self.description = description
|
|
self.ip = ip
|
|
self.server = server
|
|
self.dns_ptr = dns_ptr
|
|
self.home_location = home_location
|
|
self.blocked = blocked
|
|
self.protection = protection
|
|
self.labels = labels
|
|
self.created = self._parse_datetime(created)
|
|
self.name = name
|
|
|
|
|
|
class FloatingIPProtection(TypedDict):
|
|
delete: bool
|
|
|
|
|
|
class CreateFloatingIPResponse(BaseDomain):
|
|
"""Create Floating IP Response Domain
|
|
|
|
:param floating_ip: :class:`BoundFloatingIP <hcloud.floating_ips.client.BoundFloatingIP>`
|
|
The Floating IP which was created
|
|
:param action: :class:`BoundAction <hcloud.actions.client.BoundAction>`
|
|
The Action which shows the progress of the Floating IP Creation
|
|
"""
|
|
|
|
__api_properties__ = ("floating_ip", "action")
|
|
__slots__ = __api_properties__
|
|
|
|
def __init__(
|
|
self,
|
|
floating_ip: BoundFloatingIP,
|
|
action: BoundAction | None,
|
|
):
|
|
self.floating_ip = floating_ip
|
|
self.action = action
|