gcore 0.1.0__py3-none-any.whl

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"""

gcore/types/cloud/load_balancer_l7_rule.py

@@ -0,0 +1,72 @@
+# 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
+
+__all__ = ["LoadBalancerL7Rule"]
+
+
+class LoadBalancerL7Rule(BaseModel):
+    id: Optional[str] = None
+    """L7Rule ID"""
+
+    compare_type: Optional[Literal["CONTAINS", "ENDS_WITH", "EQUAL_TO", "REGEX", "STARTS_WITH"]] = None
+    """The comparison type for the L7 rule"""
+
+    invert: Optional[bool] = None
+    """When true the logic of the rule is inverted.
+
+    For example, with invert true, 'equal to' would become 'not equal to'. Default
+    is false.
+    """
+
+    key: Optional[str] = None
+    """The key to use for the comparison.
+
+    For example, the name of the cookie to evaluate.
+    """
+
+    operating_status: Optional[Literal["DEGRADED", "DRAINING", "ERROR", "NO_MONITOR", "OFFLINE", "ONLINE"]] = None
+    """L7 policy operating status"""
+
+    project_id: Optional[int] = None
+    """Project ID"""
+
+    provisioning_status: Optional[
+        Literal["ACTIVE", "DELETED", "ERROR", "PENDING_CREATE", "PENDING_DELETE", "PENDING_UPDATE"]
+    ] = None
+
+    region: Optional[str] = None
+    """Region name"""
+
+    region_id: Optional[int] = None
+    """Region ID"""
+
+    tags: Optional[List[str]] = None
+    """A list of simple strings assigned to the l7 rule"""
+
+    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.
+    """
+
+    type: Optional[
+        Literal[
+            "COOKIE",
+            "FILE_TYPE",
+            "HEADER",
+            "HOST_NAME",
+            "PATH",
+            "SSL_CONN_HAS_CERT",
+            "SSL_DN_FIELD",
+            "SSL_VERIFY_RESULT",
+        ]
+    ] = None
+    """The L7 rule type"""
+
+    value: Optional[str] = None
+    """The value to use for the comparison. For example, the file type to compare."""

gcore/types/cloud/load_balancer_l7_rule_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_rule import LoadBalancerL7Rule
+
+__all__ = ["LoadBalancerL7RuleList"]
+
+
+class LoadBalancerL7RuleList(BaseModel):
+    count: Optional[int] = None
+    """Number of objects"""
+
+    results: Optional[List[LoadBalancerL7Rule]] = None
+    """Objects"""

gcore/types/cloud/load_balancer_list_params.py

@@ -0,0 +1,53 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import TypedDict
+
+__all__ = ["LoadBalancerListParams"]
+
+
+class LoadBalancerListParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    assigned_floating: bool
+    """With or without assigned floating IP"""
+
+    limit: int
+    """Limit the number of returned limit request entities."""
+
+    logging_enabled: bool
+    """With or without logging"""
+
+    name: str
+    """Filter by name"""
+
+    offset: int
+    """Offset value is used to exclude the first set of records from the result."""
+
+    order_by: str
+    """
+    Ordering Load Balancer list result by name, created_at, updated_at,
+    operating_status, provisioning_status, vip_address, vip_ip_family and flavor
+    fields of the load balancer and directions (name.asc), default is
+    "created_at.asc"
+    """
+
+    show_stats: bool
+    """Show statistics"""
+
+    tag_key: List[str]
+    """Filter by tag keys."""
+
+    tag_key_value: str
+    """Filter by tag key-value pairs.
+
+    Must be a valid JSON string. curl -G --data-urlencode "tag_key_value={"key":
+    "value"}" --url "http://localhost:1111/v1/loadbalancers/1/1"
+    """
+
+    with_ddos: bool
+    """Show Advanced DDoS protection profile, if exists"""