twc-cli 2.9.2__py3-none-any.whl → 2.10.1__py3-none-any.whl

CHANGELOG.md

@@ -2,6 +2,32 @@
 
 В этом файле описаны все значимые изменения в Timeweb Cloud CLI. В выпусках мы придерживается правил [семантического версионирования](https://semver.org/lang/ru/).
 
+# Версия 2.10.1 (2025.03.25)
+
+## Исправлено
+
+- Исправлена ошибка получения публичного IP при создании кластера СУБД.
+
+# Версия 2.10.0 (2025.03.24)
+
+## Добавлено
+
+- Добавлена поддержка региона `de-1` (зона `fra-1`) для облачных серверов.
+- Добавлены новые опции к команде `twc database create`:
+    - для создания пользователя СУБД: `--user-login`, `--user-password`, `--user-host`, `--user-privileges`, `--user-desc`;
+    - для создания первой базы данных: `--db-name`, `--db-desc`;
+    - для настроек сети в класетере СУБД: `--network-id`, `--private-ip`, `--public-ip`, `--no-public-ip`;
+    - для настройки автоматических бэкапов кластера: `--enable-backups`, `--backup-keep`, `--backup-start-date`, `--backup-interval`, `--backup-day-of-week`.
+- Добавлена новая команда `twc database list-types` для вывода доступных к созданию управляемых баз данных.
+- Добавлена новая команда `twc database backup schedule` позволяющая настроить параметры автоматического резервного копирования кластера.
+- Добавлены новые команды для управления пользователями в кластерах СУБД: `twc database user list`, `twc database user get`, `twc database user create`, `twc database user remove`.
+- Добавлены новые команды для управления базами данных в кластерах СУБД: `twc database instance list`, `twc database instance create`, `twc database instance remove`.
+
+## Изменено
+
+- Опция `--network` команды `twc server create` объявлена устаревшей  и скрыта, добавлена эквивалентная опция `--network-id`.
+- Опции `--login` и `--password` команды `twc database create` объявлены устаревшими и скрыты, вместо них теперь нужно использовать `--user-login` и `--user-password`.
+
 # Версия 2.9.2 (2025.03.10)
 
 ## Исправлено

twc/__version__.py

@@ -12,5 +12,5 @@
 import sys
 
 
-__version__ = "2.9.2"
+__version__ = "2.10.1"
 __pyversion__ = sys.version.replace("\n", "")

twc/api/client.py

@@ -1,5 +1,7 @@
 """Timeweb Cloud API client."""
 
+from __future__ import annotations
+
 from typing import Optional, Union, List
 from uuid import UUID
 from pathlib import Path
@@ -20,7 +22,6 @@ from .types import (
     ServiceRegion,
     ServiceAvailabilityZone,
     ResourceType,
-    DBMS,
     MySQLAuthPlugin,
     LoadBalancerProto,
     LoadBalancerAlgo,
@@ -727,19 +728,27 @@ class TimewebCloud(TimewebCloudBase):
         """Get database presets list."""
         return self._request("GET", f"{self.api_url}/presets/dbs")
 
+    def get_database_types(self):
+        """Get database types."""
+        return self._request("GET", f"{self.api_url}/database-types")
+
+    def get_database_configrators(self):
+        """Get database_configurators."""
+        return self._request(
+            "GET", f"{self.api_url_v1}/configurator/databases"
+        )
+
     def create_database(
         self,
         name: str,
-        dbms: DBMS,
+        dbms: str,
         preset_id: int,
         password: str,
         login: Optional[str] = None,
         hash_type: Optional[MySQLAuthPlugin] = None,
         config_parameters: Optional[dict] = None,
     ):
-        """Create database."""
-        if dbms == "mysql8":
-            dbms = "mysql"
+        """Create database. DEPRECATED."""
         payload = {
             "name": name,
             "type": dbms,
@@ -751,6 +760,42 @@ class TimewebCloud(TimewebCloudBase):
         }
         return self._request("POST", f"{self.api_url}/dbs", json=payload)
 
+    def create_database2(
+        self,
+        name: str,
+        dbms: str,
+        network: Optional[dict[str, str]] = None,
+        preset_id: Optional[int] = None,
+        configurator_id: Optional[int] = None,
+        admin: Optional[dict[str, str]] = None,
+        instance: Optional[dict[str, str]] = None,
+        auto_backups: Optional[dict[str, str]] = None,
+        hash_type: Optional[MySQLAuthPlugin] = None,
+        config_parameters: Optional[dict] = None,
+        project_id: Optional[int] = None,
+    ):
+        """Create database cluster."""
+        payload = {
+            "name": name,
+            "type": dbms,
+            "hash_type": hash_type,
+            **({"network": network} if network else {}),
+            **(
+                {"config_parameters": config_parameters}
+                if config_parameters
+                else {}
+            ),
+            **({"preset_id": preset_id} if preset_id else {}),
+            **(
+                {"configurator_id": configurator_id} if configurator_id else {}
+            ),
+            **({"admin": admin} if admin else {}),
+            **({"auto_backups": auto_backups} if auto_backups else {}),
+            **({"instance": instance} if instance else {}),
+            **({"project_id": project_id} if project_id else {}),
+        }
+        return self._request("POST", f"{self.api_url}/databases", json=payload)
+
     def update_database(
         self,
         db_id: int,
@@ -837,6 +882,110 @@ class TimewebCloud(TimewebCloudBase):
             f"{self.api_url}/dbs/{db_id}/backups/{backup_id}",
         )
 
+    def get_database_autobackup_settings(self, db_id: int):
+        """Get database autobackup settings."""
+        return self._request(
+            "GET",
+            f"{self.api_url}/dbs/{db_id}/auto-backups",
+        )
+
+    def update_database_autobackup_settings(
+        self,
+        db_id: int,
+        is_enabled: Optional[bool] = None,
+        copy_count: Optional[int] = None,
+        creation_start_at: Optional[int] = None,
+        interval: Optional[BackupInterval] = None,
+        day_of_week: Optional[int] = None,
+    ):
+        """Set database autobackup settings."""
+        payload = {
+            **({"is_enabled": is_enabled} if is_enabled is not None else {}),
+            **({"copy_count": copy_count} if copy_count else {}),
+            **(
+                {"creation_start_at": creation_start_at}
+                if creation_start_at
+                else {}
+            ),
+            **({"interval": interval} if interval else {}),
+            **({"day_of_week": day_of_week} if day_of_week else {}),
+        }
+        return self._request(
+            "PATCH",
+            f"{self.api_url}/dbs/{db_id}/auto-backups",
+            json=payload,
+        )
+
+    def create_database_user(
+        self,
+        db_id: int,
+        login: str,
+        password: str,
+        privileges: List[str],
+        host: Optional[str] = None,
+        instance_id: Optional[int] = None,
+        description: Optional[str] = None,
+    ):
+        payload = {
+            "login": login,
+            "password": password,
+            "privileges": privileges,
+        }
+        if host:
+            payload["host"] = host
+        if instance_id:
+            payload["instance_id"] = instance_id
+        if description:
+            payload["description"] = description
+        return self._request(
+            "POST", f"{self.api_url}/databases/{db_id}/admins", json=payload
+        )
+
+    def get_database_users(self, db_id: int):
+        """..."""
+        return self._request(
+            "GET", f"{self.api_url_v1}/databases/{db_id}/admins"
+        )
+
+    def get_database_user(self, db_id: int, user_id: int):
+        """..."""
+        return self._request(
+            "GET", f"{self.api_url_v1}/databases/{db_id}/admins/{user_id}"
+        )
+
+    def delete_database_user(self, db_id: int, user_id: int):
+        """..."""
+        return self._request(
+            "DELETE", f"{self.api_url_v1}/databases/{db_id}/admins/{user_id}"
+        )
+
+    def create_database_instance(
+        self,
+        db_id: int,
+        name: str,
+        description: Optional[str] = None,
+    ):
+        """..."""
+        payload = {"name": name}
+        if description:
+            payload["description"] = description
+        return self._request(
+            "POST", f"{self.api_url}/databases/{db_id}/instances"
+        )
+
+    def get_database_instances(self, db_id: int):
+        """..."""
+        return self._request(
+            "GET", f"{self.api_url}/databases/{db_id}/instances"
+        )
+
+    def delete_database_instance(self, db_id: int, instance_id: int):
+        """..."""
+        return self._request(
+            "DELETE",
+            f"{self.api_url}/databases/{db_id}/instances/{instance_id}",
+        )
+
     # -----------------------------------------------------------------------
     # Object Storage
 

twc/api/types.py

@@ -13,6 +13,7 @@ class ServiceRegion(str, Enum):
     KZ_1 = "kz-1"
     PL_1 = "pl-1"
     NL_1 = "nl-1"
+    DE_1 = "de-1"
 
     @classmethod
     def get_zones(cls, region: str) -> List[str]:
@@ -29,6 +30,8 @@ class ServiceRegion(str, Enum):
             return ["gdn-1"]
         if region == cls.NL_1:
             return ["ams-1"]
+        if region == cls.DE_1:
+            return ["fra-1"]
         return []
 
 
@@ -44,6 +47,7 @@ class ServiceAvailabilityZone(str, Enum):
     ALA_1 = "ala-1"
     GDN_1 = "gdn-1"
     AMS_1 = "ams-1"
+    FRA_1 = "fra-1"
 
     @classmethod
     def get_region(cls, zone: str) -> Optional[str]:
@@ -60,6 +64,8 @@ class ServiceAvailabilityZone(str, Enum):
             return ServiceRegion.PL_1
         if zone == cls.AMS_1:
             return ServiceRegion.NL_1
+        if zone == cls.FRA_1:
+            return ServiceRegion.DE_1
         return None
 
 
@@ -170,16 +176,6 @@ class ResourceType(str, Enum):
     DEDICATED_SERVER = "dedicated"
 
 
-class DBMS(str, Enum):
-    """Available DBMS in Timeweb Cloud managed databases service."""
-
-    MYSQL_5 = "mysql5"
-    MYSQL_8 = "mysql8"
-    POSTGRES = "postgres"
-    REDIS = "redis"
-    MONGODB = "mongodb"
-
-
 class MySQLAuthPlugin(str, Enum):
     """MySQL auth plugin options in Timeweb Cloud managed databases
     service.

twc/commands/database.py

@@ -2,16 +2,20 @@
 
 import re
 import sys
+import textwrap
+from datetime import date, datetime
 from typing import Optional, List
 from pathlib import Path
+from ipaddress import IPv4Address, IPv4Network
 
 import typer
 from requests import Response
 
 from twc import fmt
 from twc.typerx import TyperAlias
-from twc.api import ServiceRegion, DBMS, MySQLAuthPlugin
+from twc.api import ServiceRegion, MySQLAuthPlugin, BackupInterval
 from twc.apiwrap import create_client
+from twc.vars import REGION_ZONE_MAP
 from twc.utils import merge_dicts
 from .common import (
     verbose_option,
@@ -21,12 +25,19 @@ from .common import (
     yes_option,
     output_format_option,
     load_from_config_callback,
+    zone_option,
 )
 
 
 database = TyperAlias(help=__doc__)
 database_backup = TyperAlias(help="Manage database backups.")
 database.add_typer(database_backup, name="backup")
+database_user = TyperAlias(help="Manage database users.")
+database.add_typer(database_user, name="user")
+database_instance = TyperAlias(
+    help="Manage instances in cluster (databases/topics/etc)."
+)
+database.add_typer(database_instance, name="instance", aliases=["db"])
 
 
 # ------------------------------------------------------------- #
@@ -206,6 +217,34 @@ def database_list_presets(
     )
 
 
+# ------------------------------------------------------------- #
+# $ twc database list-types                                     #
+# ------------------------------------------------------------- #
+
+
+@database.command("list-types", "lt")
+def database_list_types(
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    output_format: Optional[str] = output_format_option,
+):
+    """List database configuration presets."""
+    client = create_client(config, profile)
+    response = client.get_database_types().json()
+    table = fmt.Table()
+    table.header(["TYPE", "DATABASE", "VERSION"])
+    for service in response["types"]:
+        table.row(
+            [
+                service["type"],
+                service["name"],
+                service["version"],
+            ]
+        )
+    table.print()
+
+
 # ------------------------------------------------------------- #
 # $ twc database create                                         #
 # ------------------------------------------------------------- #
@@ -228,87 +267,210 @@ def set_params(params: list) -> dict:
     return parameters
 
 
+def dbms_parameters_callback(value: str) -> List[str]:
+    if value:
+        return value.split(",")
+    return []
+
+
 @database.command("create")
 def database_create(
     verbose: Optional[bool] = verbose_option,
     config: Optional[Path] = config_option,
     profile: Optional[str] = profile_option,
     output_format: Optional[str] = output_format_option,
+    availability_zone: Optional[str] = zone_option,
     preset_id: int = typer.Option(..., help="Database configuration preset."),
-    dbms: DBMS = typer.Option(
+    dbms: str = typer.Option(
         ...,
         "--type",
-        case_sensitive=False,
-        help="Database management system.",
+        help="Database management system. See TYPE in `twc database list-types`.",
     ),
     hash_type: Optional[MySQLAuthPlugin] = typer.Option(
         MySQLAuthPlugin.CACHING_SHA2.value,
         case_sensitive=False,
         help="Authentication plugin for MySQL.",
     ),
-    name: str = typer.Option(..., help="Database instance display name."),
+    name: str = typer.Option(..., help="Database cluster display name."),
     params: Optional[List[str]] = typer.Option(
         None,
         "--param",
         metavar="PARAM=VALUE",
-        help="Database parameters, can be multiple.",
+        help="Database config parameters, can be multiple.",
     ),
-    login: Optional[str] = typer.Option(None, help="Database user login."),
-    password: str = typer.Option(
-        ...,
-        prompt="Database user password",
-        confirmation_prompt=True,
-        hide_input=True,
+    login: Optional[str] = typer.Option(
+        # DEPRECATED
+        None,
+        hidden=True,
+        help="Database user login.",
+    ),
+    password: Optional[str] = typer.Option(
+        # DEPRECATED
+        None,
+        hidden=True,
+    ),
+    user_login: Optional[str] = typer.Option(None, help="User login."),
+    user_password: Optional[str] = typer.Option(None, help="User password."),
+    user_host: Optional[str] = typer.Option(
+        "%", help="User host for MySQL, Postgres"
+    ),
+    user_privileges: Optional[str] = typer.Option(
+        [],
+        help="Comma-separated list of user privileges.",
+        callback=dbms_parameters_callback,
+    ),
+    user_desc: Optional[str] = typer.Option(None, help="Comment for user."),
+    db_name: Optional[str] = typer.Option(None, help="Database name."),
+    db_desc: Optional[str] = typer.Option(None, help="Database comment."),
+    network_id: Optional[str] = typer.Option(None, help="Private network ID."),
+    private_ip: Optional[str] = typer.Option(
+        None, help="Private IPv4 address."
+    ),
+    public_ip: Optional[str] = typer.Option(
+        None, help="Public IPv4 address. New address by default."
+    ),
+    no_public_ip: Optional[bool] = typer.Option(
+        False, "--no-public-ip", help="Do not add public IPv4 address."
     ),
     project_id: Optional[int] = typer.Option(
         None,
         envvar="TWC_PROJECT",
         show_envvar=False,
         callback=load_from_config_callback,
-        help="Add database to specific project.",
+        help="Add database cluster to specific project.",
+    ),
+    enable_backups: Optional[bool] = typer.Option(
+        False,
+        "--enable-backups",
+        help="Enable atomatic backups of database cluster.",
+    ),
+    backup_keep: Optional[int] = typer.Option(
+        1,
+        show_default=True,
+        help="Number of backups to keep.",
+    ),
+    backup_start_date: Optional[datetime] = typer.Option(
+        date.today().strftime("%Y-%m-%d"),
+        formats=["%Y-%m-%d"],
+        show_default=False,
+        help="Start date of the first backup creation [default: today].",
+    ),
+    backup_interval: Optional[BackupInterval] = typer.Option(
+        BackupInterval.DAY.value,
+        "--backup-interval",
+        help="Backup interval.",
+    ),
+    backup_day_of_week: Optional[int] = typer.Option(
+        1,
+        min=1,
+        max=7,
+        help="The day of the week on which backups will be created."
+        " NOTE: This option works only with interval 'week'."
+        " First day of week is monday.",
     ),
 ):
-    """Create managed database instance."""
+    """Create managed database cluster."""
     client = create_client(config, profile)
 
-    # Check preset_id
-    for preset in client.get_database_presets().json()["databases_presets"]:
-        if preset["id"] == preset_id:
-            _dbms = re.sub(
-                r"[0-9]+", "", dbms
-            )  # transform 'mysql5' to 'mysql', etc.
-            if not preset["type"].startswith(_dbms):
-                sys.exit(
-                    f"Error: DBMS '{dbms}' doesn't match with preset_id type."
-                )
-
     payload = {
         "dbms": dbms,
         "preset_id": preset_id,
         "name": name,
         "hash_type": hash_type,
-        "login": login,
-        "password": password,
         "config_parameters": {},
+        "network": {},
     }
 
+    if enable_backups:
+        backup_start_date = backup_start_date.strftime("%Y-%m-%dT%H:%M:%SZ")
+        payload["auto_backups"] = {
+            "copy_count": backup_keep,
+            "creation_started_at": backup_start_date,
+            "interval": backup_interval,
+            "day_of_week": backup_day_of_week,
+        }
+
+    if network_id:
+        payload["network"]["id"] = network_id
+        if private_ip:
+            net = IPv4Network(
+                client.get_vpc(network_id).json()["vpc"]["subnet_v4"]
+            )
+            if IPv4Address(private_ip) >= net.network_address + 4:
+                payload["network"]["ip"] = private_ip
+            else:
+                # First 3 addresses is reserved by Timeweb Cloud for gateway and future use.
+                sys.exit(
+                    f"Error: Private address '{private_ip}' is not allowed. "
+                    "IP must be at least the fourth in order in the network."
+                )
+    if public_ip:
+        try:
+            _ = IPv4Address(public_ip)
+            payload["network"]["floating_ip"] = public_ip
+        except ValueError:
+            sys.exit(f"Error: '{public_ip}' is not valid IPv4 address.")
+    else:
+        # Get new public IPv4 address.
+        if no_public_ip is False:
+            zone = None
+            if preset_id and not availability_zone:
+                for preset in client.get_database_presets().json()[
+                    "databases_presets"
+                ]:
+                    if preset["id"] == preset_id:
+                        zone = REGION_ZONE_MAP[preset["location"]]
+            if availability_zone:
+                zone = availability_zone
+            ip = client.create_floating_ip(availability_zone=zone).json()[
+                "ip"
+            ]["ip"]
+            payload["network"]["floating_ip"] = ip
+
+    if login:
+        print(
+            "--login is deprecated use --user-login instead", file=sys.stderr
+        )
+        user_login = login
+
+    if password:
+        print(
+            "--password is deprecated use --user-password instead",
+            file=sys.stderr,
+        )
+        user_password = password
+
+    if user_password and not user_login:
+        sys.exit("Error: --user-login required if --user-password is set.")
+
+    if user_login:
+        if not user_password:
+            user_password = typer.prompt(
+                "Database user password",
+                hide_input=True,
+                confirmation_prompt=True,
+            )
+        payload["admin"] = {
+            "login": user_login,
+            "password": user_password,
+            "host": user_host,
+            "privileges": user_privileges,
+            "description": user_desc or "",
+        }
+
+    if db_name:
+        payload["instance"] = {
+            "name": db_name,
+            "description": db_desc or "",
+        }
+
     if params:
         payload["config_parameters"] = set_params(params)
 
     if project_id:
-        if not project_id in [
-            prj["id"] for prj in client.get_projects().json()["projects"]
-        ]:
-            sys.exit(f"Wrong project ID: Project '{project_id}' not found.")
+        payload["project_id"] = project_id
 
-    response = client.create_database(**payload)
-
-    # Add created DB to project if set
-    if project_id:
-        client.add_database_to_project(
-            response.json()["db"]["id"],
-            project_id,
-        )
+    response = client.create_database2(**payload)
 
     fmt.printer(
         response,
@@ -537,4 +699,344 @@ def database_backup_restore(
 # $ twc database backup schedule                                #
 # ------------------------------------------------------------- #
 
-# FUTURE: Waiting for API endpoint release.
+
+def print_autobackup_settings(response: Response):
+    """Print backup settings info."""
+    table = fmt.Table()
+    settings = response.json()["auto_backups_settings"]
+    translated_keys = {
+        "copy_count": "Keep copies",
+        "creation_start_at": "Backup start date",
+        "is_enabled": "Enabled",
+        "interval": "Interval",
+        "day_of_week": "Day of week",
+    }
+    for key in settings.keys():
+        table.row([translated_keys[key], ":", settings[key]])
+    table.print()
+
+
+@database_backup.command("schedule")
+def database_backup_schedule(
+    db_id: int,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    output_format: Optional[str] = output_format_option,
+    status: bool = typer.Option(
+        False,
+        "--status",
+        help="Display automatic backups status.",
+    ),
+    enable: Optional[bool] = typer.Option(
+        None,
+        "--enable/--disable",
+        show_default=False,
+        help="Enable or disable automatic backups.",
+    ),
+    keep: int = typer.Option(
+        1,
+        show_default=True,
+        help="Number of backups to keep.",
+    ),
+    start_date: datetime = typer.Option(
+        date.today().strftime("%Y-%m-%d"),
+        formats=["%Y-%m-%d"],
+        show_default=False,
+        help="Start date of the first backup creation [default: today].",
+    ),
+    interval: BackupInterval = typer.Option(
+        BackupInterval.DAY.value,
+        "--interval",
+        help="Backup interval.",
+    ),
+    day_of_week: Optional[int] = typer.Option(
+        1,
+        min=1,
+        max=7,
+        help="The day of the week on which backups will be created."
+        " NOTE: This option works only with interval 'week'."
+        " First day of week is monday.",
+    ),
+):
+    """Manage database cluster automatic backup settings."""
+    client = create_client(config, profile)
+
+    if status:
+        response = client.get_database_autobackup_settings(db_id)
+        fmt.printer(
+            response,
+            output_format=output_format,
+            func=print_autobackup_settings,
+        )
+        if response.json()["auto_backups_settings"]["is_enabled"]:
+            sys.exit(0)
+        else:
+            sys.exit(1)
+
+    start_date = start_date.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    response = client.update_database_autobackup_settings(
+        db_id,
+        is_enabled=enable,
+        copy_count=keep,
+        creation_start_at=start_date,
+        interval=interval,
+        day_of_week=day_of_week,
+    )
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=print_autobackup_settings,
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc database user list                                      #
+# ------------------------------------------------------------- #
+
+
+def _print_database_users(response: Response):
+    users = response.json()["admins"]
+    table = fmt.Table()
+    table.header(["ID", "LOGIN", "HOST", "CREATED"])
+    for user in users:
+        table.row(
+            [
+                user["id"],
+                user["login"],
+                user["host"],
+                user["created_at"],
+            ]
+        )
+    table.print()
+
+
+@database_user.command("list", "ls")
+def database_user_list(
+    db_id: int,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    output_format: Optional[str] = output_format_option,
+):
+    """List database users."""
+    client = create_client(config, profile)
+    response = client.get_database_users(db_id)
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=_print_database_users,
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc database user get                                       #
+# ------------------------------------------------------------- #
+
+
+def _print_database_user(response: Response):
+    user = response.json()["admin"]
+    out = textwrap.dedent(
+        f"""
+        Login:       {user['login']}
+        Host:        {user['host']}
+        Created:     {user['created_at']}
+        Description: {user['description']}
+        """
+    ).strip()
+    print(out)
+    print()
+    table = fmt.Table()
+    table.header(["INSTANCE_ID", "PRIVILEGES"])
+    for instance in user["instances"]:
+        table.row(
+            [
+                instance["instance_id"],
+                ", ".join(instance["privileges"]),
+            ]
+        )
+    table.print()
+
+
+@database_user.command("get")
+def database_user_get(
+    db_id: int,
+    user_id: int,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    output_format: Optional[str] = output_format_option,
+):
+    """Get database user."""
+    client = create_client(config, profile)
+    response = client.get_database_user(db_id, user_id)
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=_print_database_user,
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc database user create                                    #
+# ------------------------------------------------------------- #
+
+
+@database_user.command("create")
+def database_user_create(
+    db_id: int,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    output_format: Optional[str] = output_format_option,
+    login: str = typer.Option(..., help="User login."),
+    password: str = typer.Option(
+        ...,
+        prompt=True,
+        hide_input=True,
+        confirmation_prompt=True,
+        help="User password.",
+    ),
+    host: Optional[str] = typer.Option(
+        "%", help="User host for MySQL, Postgres"
+    ),
+    instance_id: Optional[int] = typer.Option(
+        None,
+        help="The specific instance ID to which the privileges will be "
+        "applied. If not specified, the privileges will be applied to "
+        "all available instances.",
+    ),
+    privileges: Optional[str] = typer.Option(
+        [],
+        help="Comma-separated list of user privileges.",
+        callback=dbms_parameters_callback,
+    ),
+    desc: Optional[str] = typer.Option(None, help="Comment for user."),
+):
+    """Create database users."""
+    client = create_client(config, profile)
+    response = client.create_database_user(
+        db_id=db_id,
+        login=login,
+        password=password,
+        privileges=privileges,
+        host=host,
+        instance_id=instance_id,
+        description=desc,
+    )
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=lambda response: print(response.json()["admin"]["id"]),
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc database user remove                                    #
+# ------------------------------------------------------------- #
+
+
+@database_user.command("remove", "rm")
+def database_user_remove(
+    db_id: int,
+    user_id: int,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+):
+    """Delete database user."""
+    client = create_client(config, profile)
+    response = client.get_database_user(db_id, user_id)
+    if response.status_code == 204:
+        print(user_id)
+    else:
+        sys.exit(fmt.printer(response))
+
+
+# ------------------------------------------------------------- #
+# $ twc database instance list                                  #
+# ------------------------------------------------------------- #
+
+
+def _print_database_instances(response: Response):
+    instances = response.json()["instances"]
+    table = fmt.Table()
+    table.header(["ID", "NAME", "CREATED", "DESCRIPTION"])
+    for i in instances:
+        table.row(
+            [
+                i["id"],
+                i["name"],
+                i["created_at"],
+                i["description"],
+            ]
+        )
+    table.print()
+
+
+@database_instance.command("list", "ls")
+def database_instance_list(
+    db_id: int,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    output_format: Optional[str] = output_format_option,
+):
+    """List databases in database cluster."""
+    client = create_client(config, profile)
+    response = client.get_database_instances(db_id)
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=_print_database_instances,
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc database instance create                                #
+# ------------------------------------------------------------- #
+
+
+@database_instance.command("create")
+def database_instance_create(
+    db_id: int,
+    name: str,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    output_format: Optional[str] = output_format_option,
+    desc: Optional[str] = typer.Option(None, help="Comment for database."),
+):
+    """Create database in database cluster."""
+    client = create_client(config, profile)
+    response = client.create_database_instance(
+        db_id, name=name, description=desc
+    )
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=lambda response: print(response.json()["instance"]["id"]),
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc database instance remove                                #
+# ------------------------------------------------------------- #
+
+
+@database_instance.command("remove", "rm")
+def database_instance_remove(
+    db_id: int,
+    instance_id: int,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+):
+    """Delete database from cluster."""
+    client = create_client(config, profile)
+    response = client.get_database_user(db_id, instance_id)
+    if response.status_code == 204:
+        print(instance_id)
+    else:
+        sys.exit(fmt.printer(response))

twc/commands/server.py

@@ -558,7 +558,10 @@ def server_create(
         help="Enable LAN.",
         hidden=True,
     ),
-    network: Optional[str] = typer.Option(None, help="Private network ID."),
+    network: Optional[str] = typer.Option(
+        None, hidden=True, help="Private network ID."
+    ),
+    network_id: Optional[str] = typer.Option(None, help="Private network ID."),
     private_ip: Optional[str] = typer.Option(
         None, help="Private IPv4 address."
     ),
@@ -631,14 +634,21 @@ def server_create(
         )
 
     # Set network parameters
-    if nat_mode or private_ip:
-        if not network:
-            sys.exit("Error: Pass '--network' option first.")
     if network:
-        payload["network"]["id"] = network
+        print(
+            "Option --network is deprecated and will be removed soon, "
+            "use --network-id instead",
+            file=sys.stderr,
+        )
+        network_id = network
+    if nat_mode or private_ip:
+        if not network_id:
+            sys.exit("Error: Pass '--network-id' option first.")
+    if network_id:
+        payload["network"]["id"] = network_id
         if private_ip:
             net = IPv4Network(
-                client.get_vpc(network).json()["vpc"]["subnet_v4"]
+                client.get_vpc(network_id).json()["vpc"]["subnet_v4"]
             )
             if IPv4Address(private_ip) >= net.network_address + 4:
                 payload["network"]["ip"] = private_ip

twc/vars.py

@@ -8,7 +8,25 @@ expand or other infrastructure or product changes occur.
 CONTROL_PANEL_URL = "https://timeweb.cloud/my"
 
 # Location specific parameters. May change later.
-REGIONS_WITH_IPV6 = ["ru-1", "pl-1"]
+REGIONS_WITH_IPV6 = ["ru-1", "ru-3", "pl-1", "nl-1"]
 REGIONS_WITH_IMAGES = ["ru-1", "ru-3", "kz-1", "pl-1", "nl-1"]
-REGIONS_WITH_LAN = ["ru-1", "ru-3", "nl-1", "pl-1"]
-ZONES_WITH_LAN = ["spb-1", "spb-3", "spb-4", "msk-1", "ams-1", "gdn-1"]
+REGIONS_WITH_LAN = ["ru-1", "ru-3", "nl-1", "pl-1", "de-1"]
+ZONES_WITH_LAN = [
+    "spb-1",
+    "spb-3",
+    "spb-4",
+    "msk-1",
+    "ams-1",
+    "gdn-1",
+    "fra-1",
+]
+# The default availability zones per regions.
+REGION_ZONE_MAP = {
+    "ru-1": "spb-3",
+    "ru-2": "nsk-1",
+    "ru-3": "msk-1",
+    "kz-1": "ala-1",
+    "pl-1": "gdn-1",
+    "nl-1": "ams-1",
+    "de-1": "fra-1",
+}

{twc_cli-2.9.2.dist-info → twc_cli-2.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: twc-cli
-Version: 2.9.2
+Version: 2.10.1
 Summary: Timeweb Cloud Command Line Interface.
 Home-page: https://github.com/timeweb-cloud/twc
 License: MIT

{twc_cli-2.9.2.dist-info → twc_cli-2.10.1.dist-info}/RECORD

@@ -1,36 +1,36 @@
-CHANGELOG.md,sha256=G6odXLHGnbFwsRUnDC4rtYwzXmi6hPqexkYvWtPzcC8,27455
+CHANGELOG.md,sha256=Qs4nN5qu8rQUqUgHQoGBQThGm0k5BaTLOx6BE6NiXWY,29824
 COPYING,sha256=fpJLxZS_kHr_659xkpmqEtqHeZp6lQR9CmKCwnYbsmE,1089
 twc/__init__.py,sha256=NwPAMNw3NuHdWGQvWS9_lromVF6VM194oVOipojfJns,113
 twc/__main__.py,sha256=ADHceaQUzgLmvhYHvb5O8urdJWj5IcEHLpTQkSExiD8,2468
-twc/__version__.py,sha256=yafF4nMnva25RWTGjOea_KXYdCgwTKiIyTInObiFNis,442
+twc/__version__.py,sha256=8icMDOUZhpUZ9qC5kE9GWifcKzo2RYQElI1jYfMVJCs,443
 twc/api/__init__.py,sha256=SXew0Fe51M7nRBNQaaLRH4NjnRHkQUn7J26OCkQsftA,128
 twc/api/base.py,sha256=QRefnIgmlbz8n37GLBKeAK1AtzkcNo1IFjZgHDDECJ4,7912
-twc/api/client.py,sha256=NFS8Jz64b-FHGy2QNwtzxyHGK7tanTquhTSJ6IcH3jg,59447
+twc/api/client.py,sha256=T74KLeKHyAxzKHkpdNF-VOkfiAwnu7us61xzPosV5_o,64366
 twc/api/exceptions.py,sha256=UzK3pKRffcXlhnkPy6MDjP_DygVoV17DuZ_mdNbOzts,2369
-twc/api/types.py,sha256=SJCKJsjdk9dFLgABO2c83oIw6ht-ARwPKmHKVZrbiN8,5419
+twc/api/types.py,sha256=uagnD3TPpoJFYUFK6HfHQPlEXs2GLxuJdjhNIbraXwM,5374
 twc/apiwrap.py,sha256=hKrg_o6rLfY32SEnWMc1BSXHnSAh7TGar1JQ90YnG5M,2970
 twc/commands/__init__.py,sha256=a-6fHQQwOj--Z7uBZGZL3z1rvJiOGUMQMRET1UknIYo,430
 twc/commands/account.py,sha256=6q9ri02oFbUUZuqNVXO-uHOX45B4ELJlPjyfVaEL5Qw,5960
 twc/commands/balancer.py,sha256=QAouc74ZT5go11gB1vjjfYtd1luTmWrfpACPwokZ5sU,20278
 twc/commands/common.py,sha256=Wph8cVogUNNvc456SQrASb7mv7G88I8ETwHgISVjLQQ,8282
 twc/commands/config.py,sha256=xHNEZVmM60c9dApLfNsj78sXZk6VsFwPdVIHO9r8xks,8802
-twc/commands/database.py,sha256=2NZ-TyRBkFgfYJyUdZUcfdqSaX7QVdWDU4k_yQNtUvo,16052
+twc/commands/database.py,sha256=NOi5b-DGYgbbN7bPrsJt0wKTJBzrfKUPwltVx8YGsgU,31953
 twc/commands/domain.py,sha256=BIg5k0TDQ-iWnhjuAHaWlZBB0bfaZgqZ2EWZGk3BICA,17154
 twc/commands/firewall.py,sha256=KNolqbi2rsppOZwbs_j3yoZQt-0wKbj1JPGiZdfGxDE,27439
 twc/commands/floating_ip.py,sha256=G9nD5BbHCZcuytbzeneDJWQDhd8c8WRtq9pAfwI9m7E,8747
 twc/commands/image.py,sha256=OviQwegXK55H3TBlroCASVcgj2QUVCTo0ZhF5ug9eT8,8165
 twc/commands/kubernetes.py,sha256=-Cgas1vFVMcrWGinjstuUz3sqX0ZNXv_4mwPwuwKeLE,20870
 twc/commands/project.py,sha256=xnL3kLIumKzrI9EZ6r6m-PGOl3mZ9IhLQua7WZ3Rghg,10499
-twc/commands/server.py,sha256=1Shwy-rTHeingiEl2EErkXIpm5TDWyBYO3fJl794Jos,71982
+twc/commands/server.py,sha256=5yb_pdB5BOoj_UAWdMxiCtuGdRBgcllkStMqyRSlx9k,72315
 twc/commands/ssh_key.py,sha256=NHgTPhAQpDzt-iPHHVo4XqUJvujNqf019N6N9qYZ9Us,7941
 twc/commands/storage.py,sha256=Pztk5iUBp9RtkdOwsfHaZFCnD8GuH6zOPtluawkRmiI,19404
 twc/commands/vpc.py,sha256=SAht6UD17mU0d_AZY6W34VEYs7CqUsS2iDakPFxAFQU,8876
 twc/fmt.py,sha256=nbuYZ8nVabYDwCmZqnL3-c6Tmri4B-R_sTCkG6sdfeI,7171
 twc/typerx.py,sha256=AZ6BgTQvlrZYfKVYd9YqRNQnAR2XuyqImz4rf6di6f4,6737
 twc/utils.py,sha256=uWizyUC4dHLwtk50q4Sub3zOvnVESfHKBbXYwk5t71w,651
-twc/vars.py,sha256=fva3O2leMGtExb1aWiAk6sOV0O8et9_kEyRpYYIZ7CM,543
-twc_cli-2.9.2.dist-info/COPYING,sha256=fpJLxZS_kHr_659xkpmqEtqHeZp6lQR9CmKCwnYbsmE,1089
-twc_cli-2.9.2.dist-info/METADATA,sha256=pMXxcU-bpTlL9FLLun6qRMYsuShrhiZV_as_e7ZVZcs,2652
-twc_cli-2.9.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-twc_cli-2.9.2.dist-info/entry_points.txt,sha256=tmTaVRhm8BkNrXC_9XJMum7O9wFVOvkXcBetxmahWvE,40
-twc_cli-2.9.2.dist-info/RECORD,,
+twc/vars.py,sha256=AHZEwtQ_BQbnP0n7RXJ-qhqeKPQ_FPc8SDgg6osR5uU,822
+twc_cli-2.10.1.dist-info/COPYING,sha256=fpJLxZS_kHr_659xkpmqEtqHeZp6lQR9CmKCwnYbsmE,1089
+twc_cli-2.10.1.dist-info/METADATA,sha256=-BCPh3qtm2gn6edv2ih7nODdb0M0n8k8LMz2sGc5Dbs,2653
+twc_cli-2.10.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+twc_cli-2.10.1.dist-info/entry_points.txt,sha256=tmTaVRhm8BkNrXC_9XJMum7O9wFVOvkXcBetxmahWvE,40
+twc_cli-2.10.1.dist-info/RECORD,,