gcore 0.1.0a1__py3-none-any.whl

gcore/types/cloud/load_balancer.py

@@ -0,0 +1,144 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+
+from .tag import Tag
+from .logging import Logging
+from ..._models import BaseModel
+from .floating_ip import FloatingIP
+from .ddos_profile import DDOSProfile
+from .interface_ip_family import InterfaceIPFamily
+from .provisioning_status import ProvisioningStatus
+from .load_balancer_statistics import LoadBalancerStatistics
+from .load_balancer_instance_role import LoadBalancerInstanceRole
+from .load_balancer_operating_status import LoadBalancerOperatingStatus
+from .load_balancer_member_connectivity import LoadBalancerMemberConnectivity
+
+__all__ = ["LoadBalancer", "AdditionalVip", "Flavor", "Listener", "VrrpIP"]
+
+
+class AdditionalVip(BaseModel):
+    ip_address: str
+    """IP address"""
+
+    subnet_id: str
+    """Subnet UUID"""
+
+
+class Flavor(BaseModel):
+    flavor_id: str
+    """Flavor ID is the same as name"""
+
+    flavor_name: str
+    """Flavor name"""
+
+    ram: int
+    """RAM size in MiB"""
+
+    vcpus: int
+    """Virtual CPU count. For bare metal flavors, it's a physical CPU count"""
+
+
+class Listener(BaseModel):
+    id: str
+    """Listener ID"""
+
+
+class VrrpIP(BaseModel):
+    ip_address: str
+    """IP address"""
+
+    role: LoadBalancerInstanceRole
+    """LoadBalancer instance role to which VRRP IP belong"""
+
+    subnet_id: str
+    """Subnet UUID"""
+
+
+class LoadBalancer(BaseModel):
+    id: str
+    """Load balancer ID"""
+
+    created_at: datetime
+    """Datetime when the load balancer was created"""
+
+    name: str
+    """Load balancer name"""
+
+    operating_status: LoadBalancerOperatingStatus
+    """Load balancer operating status"""
+
+    project_id: int
+    """Project ID"""
+
+    provisioning_status: ProvisioningStatus
+    """Load balancer lifecycle status"""
+
+    region: str
+    """Region name"""
+
+    region_id: int
+    """Region ID"""
+
+    tags_v2: List[Tag]
+    """List of key-value tags associated with the resource.
+
+    A tag is a key-value pair that can be associated with a resource, enabling
+    efficient filtering and grouping for better organization and management. Some
+    tags are read-only and cannot be modified by the user. Tags are also integrated
+    with cost reports, allowing cost data to be filtered based on tag keys or
+    values.
+    """
+
+    additional_vips: Optional[List[AdditionalVip]] = None
+    """List of additional IP addresses"""
+
+    creator_task_id: Optional[str] = None
+    """Task that created this entity"""
+
+    ddos_profile: Optional[DDOSProfile] = None
+    """Loadbalancer advanced DDoS protection profile."""
+
+    flavor: Optional[Flavor] = None
+    """Load balancer flavor (if not default)"""
+
+    floating_ips: Optional[List[FloatingIP]] = None
+    """List of assigned floating IPs"""
+
+    listeners: Optional[List[Listener]] = None
+    """Load balancer listeners"""
+
+    logging: Optional[Logging] = None
+    """Logging configuration"""
+
+    preferred_connectivity: Optional[LoadBalancerMemberConnectivity] = None
+    """
+    Preferred option to establish connectivity between load balancer and its pools
+    members
+    """
+
+    stats: Optional[LoadBalancerStatistics] = None
+    """Statistics of load balancer."""
+
+    task_id: Optional[str] = None
+    """The UUID of the active task that currently holds a lock on the resource.
+
+    This lock prevents concurrent modifications to ensure consistency. If `null`,
+    the resource is not locked.
+    """
+
+    updated_at: Optional[datetime] = None
+    """Datetime when the load balancer was last updated"""
+
+    vip_address: Optional[str] = None
+    """Load balancer IP address"""
+
+    vip_ip_family: Optional[InterfaceIPFamily] = None
+    """Load balancer IP family"""
+
+    vip_port_id: Optional[str] = None
+    """The ID of the Virtual IP (VIP) port."""
+
+    vrrp_ips: Optional[List[VrrpIP]] = None
+    """List of VRRP IP addresses"""

gcore/types/cloud/load_balancer_create_params.py

@@ -0,0 +1,327 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Iterable, Optional
+from typing_extensions import Literal, Required, TypeAlias, TypedDict
+
+from .http_method import HTTPMethod
+from .lb_algorithm import LbAlgorithm
+from .lb_pool_protocol import LbPoolProtocol
+from .interface_ip_family import InterfaceIPFamily
+from .lb_listener_protocol import LbListenerProtocol
+from .tag_update_map_param import TagUpdateMapParam
+from .lb_health_monitor_type import LbHealthMonitorType
+from .lb_session_persistence_type import LbSessionPersistenceType
+from .laas_index_retention_policy_param import LaasIndexRetentionPolicyParam
+from .load_balancer_member_connectivity import LoadBalancerMemberConnectivity
+
+__all__ = [
+    "LoadBalancerCreateParams",
+    "FloatingIP",
+    "FloatingIPNewInstanceFloatingIPInterfaceSerializer",
+    "FloatingIPExistingInstanceFloatingIPInterfaceSerializer",
+    "Listener",
+    "ListenerPool",
+    "ListenerPoolHealthmonitor",
+    "ListenerPoolMember",
+    "ListenerPoolSessionPersistence",
+    "ListenerUserList",
+    "Logging",
+]
+
+
+class LoadBalancerCreateParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    flavor: str
+    """Load balancer flavor name"""
+
+    floating_ip: FloatingIP
+    """Floating IP configuration for assignment"""
+
+    listeners: Iterable[Listener]
+    """Load balancer listeners.
+
+    Maximum 50 per LB (excluding Prometheus endpoint listener).
+    """
+
+    logging: Logging
+    """Logging configuration"""
+
+    name: str
+    """Load balancer name"""
+
+    name_template: str
+    """Load balancer name which will be changed by template."""
+
+    preferred_connectivity: LoadBalancerMemberConnectivity
+    """
+    Preferred option to establish connectivity between load balancer and its pools
+    members. L2 provides best performance, L3 provides less IPs usage. It is taking
+    effect only if instance_id + ip_address is provided, not subnet_id + ip_address,
+    because we're considering this as intentional subnet_id specification.
+    """
+
+    tags: TagUpdateMapParam
+    """Key-value tags to associate with the resource.
+
+    A tag is a key-value pair that can be associated with a resource, enabling
+    efficient filtering and grouping for better organization and management. Some
+    tags are read-only and cannot be modified by the user. Tags are also integrated
+    with cost reports, allowing cost data to be filtered based on tag keys or
+    values.
+    """
+
+    vip_ip_family: InterfaceIPFamily
+    """
+    IP family for load balancer subnet auto-selection if vip_network_id is specified
+    """
+
+    vip_network_id: str
+    """Network ID for load balancer.
+
+    If not specified, default external network will be used. Mutually exclusive with
+    vip_port_id
+    """
+
+    vip_port_id: str
+    """Existing Reserved Fixed IP port ID for load balancer.
+
+    Mutually exclusive with vip_network_id
+    """
+
+    vip_subnet_id: str
+    """Subnet ID for load balancer.
+
+    If not specified, any subnet from vip_network_id will be selected. Ignored when
+    vip_network_id is not specified.
+    """
+
+
+class FloatingIPNewInstanceFloatingIPInterfaceSerializer(TypedDict, total=False):
+    source: Required[Literal["new"]]
+    """A new floating IP will be created and attached to the instance.
+
+    A floating IP is a public IP that makes the instance accessible from the
+    internet, even if it only has a private IP. It works like SNAT, allowing
+    outgoing and incoming traffic.
+    """
+
+
+class FloatingIPExistingInstanceFloatingIPInterfaceSerializer(TypedDict, total=False):
+    existing_floating_id: Required[str]
+    """
+    An existing available floating IP id must be specified if the source is set to
+    `existing`
+    """
+
+    source: Required[Literal["existing"]]
+    """An existing available floating IP will be attached to the instance.
+
+    A floating IP is a public IP that makes the instance accessible from the
+    internet, even if it only has a private IP. It works like SNAT, allowing
+    outgoing and incoming traffic.
+    """
+
+
+FloatingIP: TypeAlias = Union[
+    FloatingIPNewInstanceFloatingIPInterfaceSerializer, FloatingIPExistingInstanceFloatingIPInterfaceSerializer
+]
+
+
+class ListenerPoolHealthmonitor(TypedDict, total=False):
+    delay: Required[int]
+    """The time, in seconds, between sending probes to members"""
+
+    max_retries: Required[int]
+    """Number of successes before the member is switched to ONLINE state"""
+
+    timeout: Required[int]
+    """The maximum time to connect. Must be less than the delay value"""
+
+    type: Required[LbHealthMonitorType]
+    """Health monitor type. Once health monitor is created, cannot be changed."""
+
+    expected_codes: Optional[str]
+    """Can only be used together with `HTTP` or `HTTPS` health monitor type."""
+
+    http_method: Optional[HTTPMethod]
+    """HTTP method.
+
+    Can only be used together with `HTTP` or `HTTPS` health monitor type.
+    """
+
+    max_retries_down: Optional[int]
+    """Number of failures before the member is switched to ERROR state."""
+
+    url_path: Optional[str]
+    """URL Path.
+
+    Defaults to '/'. Can only be used together with `HTTP` or `HTTPS` health monitor
+    type.
+    """
+
+
+class ListenerPoolMember(TypedDict, total=False):
+    address: Required[str]
+    """Member IP address"""
+
+    protocol_port: Required[int]
+    """Member IP port"""
+
+    admin_state_up: Optional[bool]
+    """true if enabled. Defaults to true"""
+
+    instance_id: Optional[str]
+    """Either subnet_id or instance_id should be provided"""
+
+    monitor_address: Optional[str]
+    """An alternate IP address used for health monitoring of a backend member.
+
+    Default is null which monitors the member address.
+    """
+
+    monitor_port: Optional[int]
+    """An alternate protocol port used for health monitoring of a backend member.
+
+    Default is null which monitors the member protocol_port.
+    """
+
+    subnet_id: Optional[str]
+    """Either subnet_id or instance_id should be provided"""
+
+    weight: Optional[int]
+    """Member weight. Valid values: 0 to 256, defaults to 1"""
+
+
+class ListenerPoolSessionPersistence(TypedDict, total=False):
+    type: Required[LbSessionPersistenceType]
+    """Session persistence type"""
+
+    cookie_name: Optional[str]
+    """Should be set if app cookie or http cookie is used"""
+
+    persistence_granularity: Optional[str]
+    """Subnet mask if source_ip is used. For UDP ports only"""
+
+    persistence_timeout: Optional[int]
+    """Session persistence timeout. For UDP ports only"""
+
+
+class ListenerPool(TypedDict, total=False):
+    lb_algorithm: Required[LbAlgorithm]
+    """Load balancer algorithm"""
+
+    name: Required[str]
+    """Pool name"""
+
+    protocol: Required[LbPoolProtocol]
+    """Protocol"""
+
+    ca_secret_id: Optional[str]
+    """Secret ID of CA certificate bundle"""
+
+    crl_secret_id: Optional[str]
+    """Secret ID of CA revocation list file"""
+
+    healthmonitor: Optional[ListenerPoolHealthmonitor]
+    """Health monitor details"""
+
+    listener_id: Optional[str]
+    """Listener ID"""
+
+    loadbalancer_id: Optional[str]
+    """Loadbalancer ID"""
+
+    members: Optional[Iterable[ListenerPoolMember]]
+    """Pool members"""
+
+    secret_id: Optional[str]
+    """Secret ID for TLS client authentication to the member servers"""
+
+    session_persistence: Optional[ListenerPoolSessionPersistence]
+    """Session persistence details"""
+
+    timeout_client_data: Optional[int]
+    """Frontend client inactivity timeout in milliseconds"""
+
+    timeout_member_connect: Optional[int]
+    """Backend member connection timeout in milliseconds"""
+
+    timeout_member_data: Optional[int]
+    """Backend member inactivity timeout in milliseconds"""
+
+
+class ListenerUserList(TypedDict, total=False):
+    encrypted_password: Required[str]
+    """Encrypted password to auth via Basic Authentication"""
+
+    username: Required[str]
+    """Username to auth via Basic Authentication"""
+
+
+class Listener(TypedDict, total=False):
+    name: Required[str]
+    """Load balancer listener name"""
+
+    protocol: Required[LbListenerProtocol]
+    """Load balancer listener protocol"""
+
+    protocol_port: Required[int]
+    """Protocol port"""
+
+    allowed_cidrs: Optional[List[str]]
+    """Network CIDRs from which service will be accessible"""
+
+    connection_limit: int
+    """Limit of the simultaneous connections"""
+
+    insert_x_forwarded: bool
+    """Add headers X-Forwarded-For, X-Forwarded-Port, X-Forwarded-Proto to requests.
+
+    Only used with HTTP or TERMINATED_HTTPS protocols.
+    """
+
+    pools: Iterable[ListenerPool]
+    """Member pools"""
+
+    secret_id: str
+    """
+    ID of the secret where PKCS12 file is stored for TERMINATED_HTTPS or PROMETHEUS
+    listener
+    """
+
+    sni_secret_id: List[str]
+    """
+    List of secrets IDs containing PKCS12 format certificate/key bundles for
+    TERMINATED_HTTPS or PROMETHEUS listeners
+    """
+
+    timeout_client_data: Optional[int]
+    """Frontend client inactivity timeout in milliseconds"""
+
+    timeout_member_connect: Optional[int]
+    """Backend member connection timeout in milliseconds"""
+
+    timeout_member_data: Optional[int]
+    """Backend member inactivity timeout in milliseconds"""
+
+    user_list: Iterable[ListenerUserList]
+    """Load balancer listener list of username and encrypted password items"""
+
+
+class Logging(TypedDict, total=False):
+    destination_region_id: Optional[int]
+    """Destination region id to which the logs will be written"""
+
+    enabled: bool
+    """Enable/disable forwarding logs to LaaS"""
+
+    retention_policy: Optional[LaasIndexRetentionPolicyParam]
+    """The logs retention policy"""
+
+    topic_name: Optional[str]
+    """The topic name to which the logs will be written"""

gcore/types/cloud/load_balancer_failover_params.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["LoadBalancerFailoverParams"]
+
+
+class LoadBalancerFailoverParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    force: bool
+    """Validate current load balancer status before failover or not."""

gcore/types/cloud/load_balancer_flavor_detail.py

@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from ..._models import BaseModel
+from .flavor_hardware_description import FlavorHardwareDescription
+
+__all__ = ["LoadBalancerFlavorDetail", "HardwareDescription"]
+
+HardwareDescription: TypeAlias = Union[FlavorHardwareDescription, object]
+
+
+class LoadBalancerFlavorDetail(BaseModel):
+    flavor_id: str
+    """Flavor ID is the same as name"""
+
+    flavor_name: str
+    """Flavor name"""
+
+    hardware_description: HardwareDescription
+    """Additional hardware description."""
+
+    ram: int
+    """RAM size in MiB"""
+
+    vcpus: int
+    """Virtual CPU count. For bare metal flavors, it's a physical CPU count"""
+
+    currency_code: Optional[str] = None
+    """Currency code. Shown if the include_prices query parameter if set to true"""
+
+    price_per_hour: Optional[float] = None
+    """Price per hour. Shown if the include_prices query parameter if set to true"""
+
+    price_per_month: Optional[float] = None
+    """Price per month. Shown if the include_prices query parameter if set to true"""
+
+    price_status: Optional[Literal["error", "hide", "show"]] = None
+    """Price status for the UI"""

gcore/types/cloud/load_balancer_flavor_list.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..._models import BaseModel
+from .load_balancer_flavor_detail import LoadBalancerFlavorDetail
+
+__all__ = ["LoadBalancerFlavorList"]
+
+
+class LoadBalancerFlavorList(BaseModel):
+    count: int
+    """Number of objects"""
+
+    results: List[LoadBalancerFlavorDetail]
+    """Objects"""

gcore/types/cloud/load_balancer_get_params.py

@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["LoadBalancerGetParams"]
+
+
+class LoadBalancerGetParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    show_stats: bool
+    """Show statistics"""
+
+    with_ddos: bool
+    """Show DDoS profile"""

gcore/types/cloud/load_balancer_instance_role.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["LoadBalancerInstanceRole"]
+
+LoadBalancerInstanceRole: TypeAlias = Literal["BACKUP", "MASTER", "STANDALONE"]

gcore/types/cloud/load_balancer_l7_policy.py

@@ -0,0 +1,86 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .load_balancer_l7_rule import LoadBalancerL7Rule
+
+__all__ = ["LoadBalancerL7Policy"]
+
+
+class LoadBalancerL7Policy(BaseModel):
+    id: Optional[str] = None
+    """ID"""
+
+    action: Optional[Literal["REDIRECT_PREFIX", "REDIRECT_TO_POOL", "REDIRECT_TO_URL", "REJECT"]] = None
+    """Action"""
+
+    listener_id: Optional[str] = None
+    """Listener ID"""
+
+    name: Optional[str] = None
+    """Human-readable name of the policy"""
+
+    operating_status: Optional[Literal["DEGRADED", "DRAINING", "ERROR", "NO_MONITOR", "OFFLINE", "ONLINE"]] = None
+    """L7 policy operating status"""
+
+    position: Optional[int] = None
+    """The position of this policy on the listener. Positions start at 1."""
+
+    project_id: Optional[int] = None
+    """Project ID"""
+
+    provisioning_status: Optional[
+        Literal["ACTIVE", "DELETED", "ERROR", "PENDING_CREATE", "PENDING_DELETE", "PENDING_UPDATE"]
+    ] = None
+
+    redirect_http_code: Optional[int] = None
+    """
+    Requests matching this policy will be redirected to the specified URL or Prefix
+    URL with the HTTP response code. Valid if action is REDIRECT_TO_URL or
+    REDIRECT_PREFIX. Valid options are 301, 302, 303, 307, or 308. Default is 302.
+    """
+
+    redirect_pool_id: Optional[str] = None
+    """Requests matching this policy will be redirected to the pool with this ID.
+
+    Only valid if action is REDIRECT_TO_POOL.
+    """
+
+    redirect_prefix: Optional[str] = None
+    """Requests matching this policy will be redirected to this Prefix URL.
+
+    Only valid if action is REDIRECT_PREFIX.
+    """
+
+    redirect_url: Optional[str] = None
+    """Requests matching this policy will be redirected to this URL.
+
+    Only valid if action is REDIRECT_TO_URL.
+    """
+
+    region: Optional[str] = None
+    """Region name"""
+
+    region_id: Optional[int] = None
+    """Region ID"""
+
+    rules: Optional[List[LoadBalancerL7Rule]] = None
+    """Rules.
+
+    All the rules associated with a given policy are logically ANDed together. A
+    request must match all the policy’s rules to match the policy.If you need to
+    express a logical OR operation between rules, then do this by creating multiple
+    policies with the same action.
+    """
+
+    tags: Optional[List[str]] = None
+    """A list of simple strings assigned to the resource."""
+
+    task_id: Optional[str] = None
+    """The UUID of the active task that currently holds a lock on the resource.
+
+    This lock prevents concurrent modifications to ensure consistency. If `null`,
+    the resource is not locked.
+    """

gcore/types/cloud/load_balancer_l7_policy_list.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+from .load_balancer_l7_policy import LoadBalancerL7Policy
+
+__all__ = ["LoadBalancerL7PolicyList"]
+
+
+class LoadBalancerL7PolicyList(BaseModel):
+    count: Optional[int] = None
+    """Number of objects"""
+
+    results: Optional[List[LoadBalancerL7Policy]] = None
+    """Objects"""