gcore 0.1.0a1__py3-none-any.whl

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

gcore/types/cloud/load_balancer_listener_detail.py

@@ -0,0 +1,97 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+from .provisioning_status import ProvisioningStatus
+from .lb_listener_protocol import LbListenerProtocol
+from .load_balancer_statistics import LoadBalancerStatistics
+from .load_balancer_operating_status import LoadBalancerOperatingStatus
+
+__all__ = ["LoadBalancerListenerDetail", "UserList"]
+
+
+class UserList(BaseModel):
+    encrypted_password: str
+    """Encrypted password to auth via Basic Authentication"""
+
+    username: str
+    """Username to auth via Basic Authentication"""
+
+
+class LoadBalancerListenerDetail(BaseModel):
+    id: str
+    """Load balancer listener ID"""
+
+    connection_limit: int
+    """Limit of simultaneous connections"""
+
+    insert_headers: object
+    """Dictionary of additional header insertion into HTTP headers.
+
+    Only used with HTTP and TERMINATED_HTTPS protocols.
+    """
+
+    name: str
+    """Load balancer listener name"""
+
+    operating_status: LoadBalancerOperatingStatus
+    """Listener operating status"""
+
+    protocol: LbListenerProtocol
+    """Load balancer protocol"""
+
+    protocol_port: int
+    """Protocol port"""
+
+    provisioning_status: ProvisioningStatus
+    """Listener lifecycle status"""
+
+    allowed_cidrs: Optional[List[str]] = None
+    """Network CIDRs from which service will be accessible"""
+
+    creator_task_id: Optional[str] = None
+    """Task that created this entity"""
+
+    loadbalancer_id: Optional[str] = None
+    """Load balancer ID"""
+
+    pool_count: Optional[int] = None
+    """Number of pools (for UI)"""
+
+    secret_id: Optional[str] = None
+    """
+    ID of the secret where PKCS12 file is stored for TERMINATED_HTTPS or PROMETHEUS
+    load balancer
+    """
+
+    sni_secret_id: Optional[List[str]] = None
+    """
+    List of secret's ID containing PKCS12 format certificate/key bundles for
+    TERMINATED_HTTPS or PROMETHEUS listeners
+    """
+
+    stats: Optional[LoadBalancerStatistics] = None
+    """Statistics of the load balancer.
+
+    It is available only in get functions by a flag.
+    """
+
+    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.
+    """
+
+    timeout_client_data: Optional[int] = None
+    """Frontend client inactivity timeout in milliseconds"""
+
+    timeout_member_connect: Optional[int] = None
+    """Backend member connection timeout in milliseconds"""
+
+    timeout_member_data: Optional[int] = None
+    """Backend member inactivity timeout in milliseconds"""
+
+    user_list: Optional[List[UserList]] = None
+    """Load balancer listener users list"""

gcore/types/cloud/load_balancer_listener_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_listener_detail import LoadBalancerListenerDetail
+
+__all__ = ["LoadBalancerListenerList"]
+
+
+class LoadBalancerListenerList(BaseModel):
+    count: int
+    """Number of objects"""
+
+    results: List[LoadBalancerListenerDetail]
+    """Objects"""

gcore/types/cloud/load_balancer_member_connectivity.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__ = ["LoadBalancerMemberConnectivity"]
+
+LoadBalancerMemberConnectivity: TypeAlias = Literal["L2", "L3"]

gcore/types/cloud/load_balancer_metrics.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from pydantic import Field as FieldInfo
+
+from ..._models import BaseModel
+
+__all__ = ["LoadBalancerMetrics"]
+
+
+class LoadBalancerMetrics(BaseModel):
+    cpu_util: Optional[float] = None
+    """CPU utilization, % (max 100% for multi-core)"""
+
+    memory_util: Optional[float] = None
+    """RAM utilization, %"""
+
+    network_bps_egress: Optional[float] = FieldInfo(alias="network_Bps_egress", default=None)
+    """Network out, bytes per second"""
+
+    network_bps_ingress: Optional[float] = FieldInfo(alias="network_Bps_ingress", default=None)
+    """Network in, bytes per second"""
+
+    network_pps_egress: Optional[float] = None
+    """Network out, packets per second"""
+
+    network_pps_ingress: Optional[float] = None
+    """Network in, packets per second"""
+
+    time: Optional[str] = None
+    """Timestamp"""

gcore/types/cloud/load_balancer_metrics_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_metrics import LoadBalancerMetrics
+
+__all__ = ["LoadBalancerMetricsList"]
+
+
+class LoadBalancerMetricsList(BaseModel):
+    count: int
+    """Number of objects"""
+
+    results: List[LoadBalancerMetrics]
+    """Objects"""

gcore/types/cloud/load_balancer_operating_status.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__ = ["LoadBalancerOperatingStatus"]
+
+LoadBalancerOperatingStatus: TypeAlias = Literal["DEGRADED", "DRAINING", "ERROR", "NO_MONITOR", "OFFLINE", "ONLINE"]

gcore/types/cloud/load_balancer_pool.py

@@ -0,0 +1,87 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from .member import Member
+from ..._models import BaseModel
+from .lb_algorithm import LbAlgorithm
+from .health_monitor import HealthMonitor
+from .lb_pool_protocol import LbPoolProtocol
+from .provisioning_status import ProvisioningStatus
+from .session_persistence import SessionPersistence
+from .load_balancer_operating_status import LoadBalancerOperatingStatus
+
+__all__ = ["LoadBalancerPool", "Listener", "Loadbalancer"]
+
+
+class Listener(BaseModel):
+    id: str
+    """Resource ID"""
+
+
+class Loadbalancer(BaseModel):
+    id: str
+    """Resource ID"""
+
+
+class LoadBalancerPool(BaseModel):
+    id: str
+    """Pool ID"""
+
+    ca_secret_id: Optional[str] = None
+    """Secret ID of CA certificate bundle"""
+
+    crl_secret_id: Optional[str] = None
+    """Secret ID of CA revocation list file"""
+
+    lb_algorithm: LbAlgorithm
+    """Load balancer algorithm"""
+
+    listeners: List[Listener]
+    """Listeners IDs"""
+
+    loadbalancers: List[Loadbalancer]
+    """Load balancers IDs"""
+
+    members: List[Member]
+    """Pool members"""
+
+    name: str
+    """Pool name"""
+
+    operating_status: LoadBalancerOperatingStatus
+    """Pool operating status"""
+
+    protocol: LbPoolProtocol
+    """Protocol"""
+
+    provisioning_status: ProvisioningStatus
+    """Pool lifecycle status"""
+
+    secret_id: Optional[str] = None
+    """Secret ID for TLS client authentication to the member servers"""
+
+    session_persistence: Optional[SessionPersistence] = None
+    """Session persistence parameters"""
+
+    timeout_client_data: Optional[int] = None
+    """Frontend client inactivity timeout in milliseconds"""
+
+    timeout_member_connect: Optional[int] = None
+    """Backend member connection timeout in milliseconds"""
+
+    timeout_member_data: Optional[int] = None
+    """Backend member inactivity timeout in milliseconds"""
+
+    creator_task_id: Optional[str] = None
+    """Task that created this entity"""
+
+    healthmonitor: Optional[HealthMonitor] = None
+    """Health monitor parameters"""
+
+    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_pool_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_pool import LoadBalancerPool
+
+__all__ = ["LoadBalancerPoolList"]
+
+
+class LoadBalancerPoolList(BaseModel):
+    count: int
+    """Number of objects"""
+
+    results: List[LoadBalancerPool]
+    """Objects"""

gcore/types/cloud/load_balancer_resize_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 Required, TypedDict
+
+__all__ = ["LoadBalancerResizeParams"]
+
+
+class LoadBalancerResizeParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    flavor: Required[str]
+    """Name of the desired flavor to resize to."""

gcore/types/cloud/load_balancer_statistics.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["LoadBalancerStatistics"]
+
+
+class LoadBalancerStatistics(BaseModel):
+    active_connections: int
+    """Currently active connections"""
+
+    bytes_in: int
+    """Total bytes received"""
+
+    bytes_out: int
+    """Total bytes sent"""
+
+    request_errors: int
+    """Total requests that were unable to be fulfilled"""
+
+    total_connections: int
+    """Total connections handled"""

gcore/types/cloud/load_balancer_status.py

@@ -0,0 +1,38 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from .tag import Tag
+from ..._models import BaseModel
+from .listener_status import ListenerStatus
+from .provisioning_status import ProvisioningStatus
+from .load_balancer_operating_status import LoadBalancerOperatingStatus
+
+__all__ = ["LoadBalancerStatus"]
+
+
+class LoadBalancerStatus(BaseModel):
+    id: str
+    """UUID of the entity"""
+
+    listeners: List[ListenerStatus]
+    """Listeners of the Load Balancer"""
+
+    name: str
+    """Name of the load balancer"""
+
+    operating_status: LoadBalancerOperatingStatus
+    """Operating status of the entity"""
+
+    provisioning_status: ProvisioningStatus
+    """Provisioning status of the entity"""
+
+    tags: Optional[List[Tag]] = None
+    """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.
+    """

gcore/types/cloud/load_balancer_status_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_status import LoadBalancerStatus
+
+__all__ = ["LoadBalancerStatusList"]
+
+
+class LoadBalancerStatusList(BaseModel):
+    count: int
+    """Number of objects"""
+
+    results: List[LoadBalancerStatus]
+    """Objects"""

gcore/types/cloud/load_balancer_update_params.py

@@ -0,0 +1,43 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+from .laas_index_retention_policy_param import LaasIndexRetentionPolicyParam
+from .load_balancer_member_connectivity import LoadBalancerMemberConnectivity
+
+__all__ = ["LoadBalancerUpdateParams", "Logging"]
+
+
+class LoadBalancerUpdateParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    logging: Logging
+    """Logging configuration"""
+
+    name: str
+    """Name."""
+
+    preferred_connectivity: LoadBalancerMemberConnectivity
+    """
+    Preferred option to establish connectivity between load balancer and its pools
+    members
+    """
+
+
+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_balancers/__init__.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .pool_list_params import PoolListParams as PoolListParams
+from .flavor_list_params import FlavorListParams as FlavorListParams
+from .metric_list_params import MetricListParams as MetricListParams
+from .pool_create_params import PoolCreateParams as PoolCreateParams
+from .pool_update_params import PoolUpdateParams as PoolUpdateParams
+from .listener_get_params import ListenerGetParams as ListenerGetParams
+from .listener_list_params import ListenerListParams as ListenerListParams
+from .listener_create_params import ListenerCreateParams as ListenerCreateParams
+from .listener_update_params import ListenerUpdateParams as ListenerUpdateParams
+from .l7_policy_create_params import L7PolicyCreateParams as L7PolicyCreateParams
+from .l7_policy_replace_params import L7PolicyReplaceParams as L7PolicyReplaceParams

gcore/types/cloud/load_balancers/flavor_list_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__ = ["FlavorListParams"]
+
+
+class FlavorListParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    include_prices: bool
+    """Set to true if the response should include flavor prices"""

gcore/types/cloud/load_balancers/l7_policies/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .rule_create_params import RuleCreateParams as RuleCreateParams
+from .rule_replace_params import RuleReplaceParams as RuleReplaceParams

gcore/types/cloud/load_balancers/l7_policies/rule_create_params.py

@@ -0,0 +1,50 @@
+# 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 Literal, Required, TypedDict
+
+__all__ = ["RuleCreateParams"]
+
+
+class RuleCreateParams(TypedDict, total=False):
+    project_id: int
+
+    region_id: int
+
+    compare_type: Required[Literal["CONTAINS", "ENDS_WITH", "EQUAL_TO", "REGEX", "STARTS_WITH"]]
+    """The comparison type for the L7 rule"""
+
+    type: Required[
+        Literal[
+            "COOKIE",
+            "FILE_TYPE",
+            "HEADER",
+            "HOST_NAME",
+            "PATH",
+            "SSL_CONN_HAS_CERT",
+            "SSL_DN_FIELD",
+            "SSL_VERIFY_RESULT",
+        ]
+    ]
+    """The L7 rule type"""
+
+    value: Required[str]
+    """The value to use for the comparison. For example, the file type to compare"""
+
+    invert: bool
+    """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: str
+    """The key to use for the comparison.
+
+    For example, the name of the cookie to evaluate.
+    """
+
+    tags: List[str]
+    """A list of simple strings assigned to the l7 rule"""