twc-cli 2.4.1__py3-none-any.whl → 2.6.0__py3-none-any.whl

twc/commands/floating_ip.py

@@ -0,0 +1,296 @@
+"""Manage floating IPs."""
+
+import sys
+from typing import Optional, List
+from pathlib import Path
+from uuid import UUID
+
+import typer
+from requests import Response
+
+from twc import fmt
+from twc.api import TimewebCloud, ResourceType
+from twc.apiwrap import create_client
+from twc.typerx import TyperAlias
+from .common import (
+    verbose_option,
+    config_option,
+    profile_option,
+    yes_option,
+    output_format_option,
+    load_from_config_callback,
+)
+
+
+floating_ip = TyperAlias(help=__doc__)
+
+
+def get_floating_ip_id(client: TimewebCloud, ip_addr: str) -> Optional[str]:
+    ips = client.get_floating_ips().json()["ips"]
+    for ip in ips:
+        if ip["ip"] == ip_addr:
+            return ip["id"]
+    return None
+
+
+# ------------------------------------------------------------- #
+# $ twc floating-ip list                                        #
+# ------------------------------------------------------------- #
+
+
+def _print_floating_ips(response: Response):
+    table = fmt.Table()
+    table.header(["IP", "PTR", "ZONE", "ANTI_DDOS", "USED_ON"])
+    ips = response.json()["ips"]
+    for ip in ips:
+        used = None
+        if ip["resource_type"]:
+            used = f"{ip['resource_type']}:{ip['resource_id']}"
+        table.row(
+            [
+                ip["ip"],
+                ip["ptr"],
+                ip["availability_zone"],
+                ip["is_ddos_guard"],
+                used,
+            ]
+        )
+    table.print()
+
+
+@floating_ip.command("list", "ls")
+def floating_ip_list(
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    output_format: Optional[str] = output_format_option,
+):
+    """List floating IPs."""
+    client = create_client(config, profile)
+    response = client.get_floating_ips()
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=_print_floating_ips,
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc floating-ip get                                         #
+# ------------------------------------------------------------- #
+
+
+def _print_floating_ip(response: Response):
+    table = fmt.Table()
+    table.header(["IP", "PTR", "ZONE", "ANTI_DDOS", "USED_ON"])
+    ip = response.json()["ip"]
+    used = None
+    if ip["resource_type"]:
+        used = f"{ip['resource_type']}:{ip['resource_id']}"
+    table.row(
+        [
+            ip["ip"],
+            ip["ptr"],
+            ip["availability_zone"],
+            ip["is_ddos_guard"],
+            used,
+        ]
+    )
+    table.print()
+
+
+@floating_ip.command("get")
+def floating_ip_get(
+    ip: str,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    output_format: Optional[str] = output_format_option,
+):
+    """Get floating IP."""
+    client = create_client(config, profile)
+    try:
+        _ = UUID(ip)
+    except ValueError:
+        ip = get_floating_ip_id(client, ip)
+    response = client.get_floating_ip(ip)
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=_print_floating_ip,
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc floating-ip create                                      #
+# ------------------------------------------------------------- #
+
+
+@floating_ip.command("create")
+def floating_ip_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: str = typer.Option(
+        ...,
+        metavar="ZONE",
+        envvar="TWC_AVAILABILITY_ZONE",
+        show_envvar=False,
+        callback=load_from_config_callback,
+        help="Availability zone.",
+    ),
+    ddos_protection: bool = typer.Option(
+        False,
+        "--ddos-protection",
+        show_default=True,
+        help="Request IP-address with L3/L4 DDoS protection.",
+    ),
+):
+    """Create new floating IP."""
+    client = create_client(config, profile)
+    response = client.create_floating_ip(
+        availability_zone=availability_zone,
+        ddos_protection=ddos_protection,
+    )
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=lambda response: print(response.json()["ip"]["ip"]),
+    )
+
+
+# ------------------------------------------------------------- #
+# $ twc floating-ip remove                                      #
+# ------------------------------------------------------------- #
+
+
+@floating_ip.command("remove", "rm")
+def floating_ip_remove(
+    floating_ips: List[str] = typer.Argument(..., metavar="IP..."),
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    yes: Optional[bool] = yes_option,
+):
+    """Remove floating IPs."""
+    if not yes:
+        typer.confirm("This action cannot be undone, continue?", abort=True)
+
+    client = create_client(config, profile)
+    for ip in floating_ips:
+        try:
+            _ = UUID(ip)
+        except ValueError:
+            ip = get_floating_ip_id(client, ip)
+        response = client.delete_floating_ip(ip)
+        if response.status_code == 204:
+            print(ip)
+        else:
+            sys.exit(fmt.printer(response))
+
+
+# ------------------------------------------------------------- #
+# $ twc floating-ip attach                                      #
+# ------------------------------------------------------------- #
+
+
+@floating_ip.command("attach")
+def floating_ip_attach(
+    ip: str,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    server: Optional[int] = typer.Option(
+        None, help="Attach IP to Cloud Server."
+    ),
+    balancer: Optional[int] = typer.Option(
+        None, help="Attach IP to Load Balancer."
+    ),
+    database: Optional[int] = typer.Option(
+        None, help="Attach IP to managed database cluster."
+    ),
+):
+    """Attach floating IP to service."""
+    client = create_client(config, profile)
+    try:
+        _ = UUID(ip)
+    except ValueError:
+        ip = get_floating_ip_id(client, ip)
+    resource_type = resource_id = None
+    if server:
+        resource_type = ResourceType.SERVER
+        resource_id = server
+    if balancer:
+        resource_type = ResourceType.BALANCER
+        resource_id = balancer
+    if database:
+        resource_type = ResourceType.DATABASE
+        resource_id = database
+    response = client.attach_floating_ip(
+        ip,
+        resource_type=resource_type,
+        resource_id=resource_id,
+    )
+    if not resource_type or not resource_id:
+        sys.exit(
+            "Error: Please set one of options: ['--server', '--balancer', '--database']"
+        )
+    if response.status_code == 204:
+        print(resource_id)
+    else:
+        sys.exit(fmt.printer(response))
+
+
+# ------------------------------------------------------------- #
+# $ twc floating-ip detach                                      #
+# ------------------------------------------------------------- #
+
+
+@floating_ip.command("detach")
+def floating_ip_detach(
+    ip: str,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+):
+    """Detach floating IP from service."""
+    client = create_client(config, profile)
+    try:
+        _ = UUID(ip)
+    except ValueError:
+        ip = get_floating_ip_id(client, ip)
+    response = client.detach_floating_ip(ip)
+    if response.status_code == 204:
+        print(ip)
+    else:
+        sys.exit(fmt.printer(response))
+
+
+# ------------------------------------------------------------- #
+# $ twc floating-ip set                                         #
+# ------------------------------------------------------------- #
+
+
+@floating_ip.command("set")
+def floating_ip_set(
+    ip: str,
+    verbose: Optional[bool] = verbose_option,
+    config: Optional[Path] = config_option,
+    profile: Optional[str] = profile_option,
+    output_format: Optional[str] = output_format_option,
+    comment: Optional[str] = typer.Option(None, help="Set comment."),
+    ptr: Optional[str] = typer.Option(None, help="Set reverse DNS pointer."),
+):
+    """Set floating IP parameters."""
+    client = create_client(config, profile)
+    try:
+        _ = UUID(ip)
+    except ValueError:
+        ip = get_floating_ip_id(client, ip)
+    response = client.update_floating_ip(ip, comment=comment, ptr=ptr)
+    fmt.printer(
+        response,
+        output_format=output_format,
+        func=lambda response: print(response.json()["ip"]["ip"]),
+    )

twc/commands/image.py

@@ -262,13 +262,16 @@ def image_upload(
     client = create_client(config, profile)
     if re.match(r"https?://", file):
         debug(f"Upload URL: {file}")
-        response = client.create_image(
-            upload_url=file,
-            name=name,
-            description=desc,
-            os_type=os_type,
-            location=region,
-        )
+    else:
+        sys.exit(f"Invalid link: {file}")
+
+    response = client.create_image(
+        upload_url=file,
+        name=name,
+        description=desc,
+        os_type=os_type,
+        location=region,
+    )
 
     # FUTURE: Implement file upload from local disk
 

twc/commands/project.py

@@ -295,11 +295,10 @@ def project_resource_move(
     if bucket:
         for bucket_id in bucket:
             if not bucket_id.isdigit():
-                bucket_name = bucket_id
                 bucket_id = resolve_bucket_id(client, bucket_id)
             response = client.add_bucket_to_project(bucket_id, project_id)
             if response.status_code == 200:
-                print(bucket_name)
+                print(bucket_id)
             else:
                 sys.exit(fmt.printer(response))
     if cluster:

twc/commands/server.py

@@ -7,7 +7,7 @@ from logging import debug
 from typing import Optional, List, Union
 from pathlib import Path
 from datetime import date, datetime
-from ipaddress import IPv4Address, IPv6Address
+from ipaddress import IPv4Address, IPv6Address, IPv4Network
 
 import typer
 from click import UsageError
@@ -28,7 +28,6 @@ from twc.api import (
     BackupAction,
 )
 from twc.vars import (
-    REGIONS_WITH_CONFIGURATOR,
     REGIONS_WITH_IPV6,
     CONTROL_PANEL_URL,
 )
@@ -40,6 +39,7 @@ from .common import (
     yes_option,
     output_format_option,
     region_option,
+    zone_option,
     load_from_config_callback,
 )
 
@@ -48,7 +48,7 @@ server = TyperAlias(help=__doc__)
 server_ip = TyperAlias(help="Manage public IPs.")
 server_disk = TyperAlias(help="Manage Cloud Server disks.")
 server_backup = TyperAlias(help="Manage Cloud Server disk backups.")
-server.add_typer(server_ip, name="ip")
+server.add_typer(server_ip, name="ip", deprecated=True)
 server.add_typer(server_disk, name="disk")
 server.add_typer(server_backup, name="backup")
 
@@ -80,10 +80,9 @@ def print_servers(
         ]
     )
     for srv in servers:
+        main_ipv4 = None
         for network in srv["networks"]:
             if network["type"] == "public":
-                if not network["ips"]:
-                    main_ipv4 = None
                 for addr in network["ips"]:
                     if addr["type"] == "ipv4" and addr["is_main"]:
                         main_ipv4 = addr["ip"]
@@ -139,10 +138,9 @@ def print_server(response: Response):
             "IPV4",
         ]
     )
+    main_ipv4 = None
     for network in srv["networks"]:
         if network["type"] == "public":
-            if not network["ips"]:
-                main_ipv4 = None
             for addr in network["ips"]:
                 if addr["type"] == "ipv4" and addr["is_main"]:
                     main_ipv4 = addr["ip"]
@@ -509,11 +507,14 @@ def server_create(
     ssh_keys: Optional[List[str]] = typer.Option(
         None, "--ssh-key", help="SSH-key file, name or ID. Can be multiple."
     ),
+    user_data: Optional[typer.FileText] = typer.Option(
+        None, help="user-data file for cloud-init."
+    ),
     ddos_protection: bool = typer.Option(
         False,
         "--ddos-protection",
         show_default=True,
-        help="Enable DDoS-Guard.",
+        help="Request public IPv4 with L3/L4 DDoS protection.",
     ),
     local_network: Optional[bool] = typer.Option(
         # is_local_network paramenter is deprecated!
@@ -524,6 +525,15 @@ def server_create(
         hidden=True,
     ),
     network: 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."
+    ),
     nat_mode: ServerNATMode = typer.Option(
         None,
         "--nat-mode",
@@ -531,6 +541,7 @@ def server_create(
         help="Apply NAT mode.",
     ),
     region: Optional[str] = region_option,
+    availability_zone: Optional[str] = zone_option,
     project_id: int = typer.Option(
         None,
         envvar="TWC_PROJECT",
@@ -541,17 +552,14 @@ def server_create(
 ):
     """Create Cloud Server."""
     client = create_client(config, profile)
-
-    if nat_mode:
-        if not network:
-            sys.exit("Error: Pass '--network' option first.")
-
     payload = {
         "name": name,
         "comment": comment,
         "avatar_id": avatar_id,
         "software_id": software_id,
         "is_ddos_guard": ddos_protection,
+        "availability_zone": availability_zone,
+        "network": {},
         **(
             {"is_local_network": local_network}
             if local_network is not None
@@ -559,8 +567,44 @@ def server_create(
         ),
     }
 
+    # Check availability zone
+    usable_zones = ServiceRegion.get_zones(region)
+    if availability_zone is not None and availability_zone not in usable_zones:
+        sys.exit(
+            f"Error: Wrong availability zone, usable zones are: {usable_zones}"
+        )
+
+    # 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}
+        payload["network"]["id"] = network
+        if private_ip:
+            net = IPv4Network(
+                client.get_vpc(network).json()["vpc"]["subnet_v4"]
+            )
+            if IPv4Address(private_ip) > IPv4Address(
+                int(net.network_address) + 4
+            ):
+                payload["network"]["ip"] = private_ip
+            else:
+                # First 3 addresses is reserved for networks OVN based networks
+                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:
+        # New public IPv4 address will be automatically requested with
+        # correct availability zone. This is official dirty hack.
+        if no_public_ip is False:
+            payload["network"]["floating_ip"] = "create_ip"
 
     # Set server configuration parameters
     if preset_id and (cpu or ram or disk):
@@ -609,6 +653,10 @@ def server_create(
             ssh_keys_ids.append(process_ssh_key(client, key))
     payload["ssh_keys_ids"] = ssh_keys_ids
 
+    # Set cloud-init user-data
+    if user_data:
+        payload["cloud_init"] = user_data.read()
+
     # Check project_id before creating server
     if project_id:
         if not project_id in [
@@ -738,12 +786,6 @@ def server_resize(
     # Return error if user tries to switch from preset to configurator in
     # location where configurator is unavailable.
     if cpu or ram or disk:
-        if old_state["location"] not in REGIONS_WITH_CONFIGURATOR:
-            sys.exit(
-                "Error: Can not change configuration in location "
-                + f"'{old_state['location']}'. Change preset_id instead."
-            )
-
         # Get original server configurator_id
         configurator_id = old_state["configurator_id"]
         configurator = None
@@ -775,6 +817,7 @@ def server_resize(
         payload["configuration"] = {}
 
         # Get original size of primary disk
+        primary_disk_size = 0
         for old_disk in old_state["disks"]:
             if old_disk["is_system"]:  # is True
                 primary_disk_size = old_disk["size"]
@@ -963,13 +1006,19 @@ def server_remove(
     config: Optional[Path] = config_option,
     profile: Optional[str] = profile_option,
     yes: Optional[bool] = yes_option,
+    keep_public_ip: Optional[bool] = typer.Option(
+        False,
+        "--keep-public-ip",
+        help="Do not remove public IP attached to server. [default: false]",
+    ),
 ):
-    """Clone Cloud Server."""
+    """Remove Cloud Server."""
     if not yes:
         typer.confirm("This action cannot be undone. Continue?", abort=True)
 
     client = create_client(config, profile)
     for server_id in server_ids:
+        server_data = client.get_server(server_id).json()["server"]
         response = client.delete_server(server_id)
         if response.status_code == 200:
             del_hash = response.json()["server_delete"]["hash"]
@@ -981,6 +1030,11 @@ def server_remove(
             print(server_id)
         else:
             sys.exit(fmt.printer(response))
+        if keep_public_ip is False:
+            for network in server_data["networks"]:
+                for ip in network["ips"]:
+                    if ip.get("id") is not None:
+                        client.delete_floating_ip(ip["id"])
 
 
 # ------------------------------------------------------------- #

twc/commands/storage.py

@@ -5,7 +5,6 @@ Cloud specific API methods instead. Use third party S3 clients to manage
 objects e.g. s3cmd, rclone, etc.
 """
 
-
 import sys
 from logging import debug
 from typing import Optional, List
@@ -19,7 +18,6 @@ from twc import fmt
 from twc.typerx import TyperAlias
 from twc.apiwrap import create_client
 from twc.api import TimewebCloud, ServiceRegion, BucketType
-from twc.vars import S3_ENDPOINT
 from .common import (
     verbose_option,
     config_option,
@@ -614,10 +612,16 @@ def storage_genconfig(
         "rclone": RCLONE_CONFIG_TEMPLATE.strip(),
     }
 
+    endpoint = "s3.timeweb.cloud"
+    if not access_key.isupper():
+        # Legacy object storage service have lowercase usernames only.
+        # New storage, on the contrary, always has keys in uppercase.
+        endpoint = "s3.timeweb.com"
+
     file_content = templates[s3_client].format(
         access_key=access_key,
         secret_key=secret_key,
-        endpoint=S3_ENDPOINT,
+        endpoint=endpoint,
     )
 
     if save_to:

twc/commands/vpc.py

@@ -13,9 +13,10 @@ import typer
 from requests import Response
 
 from twc import fmt
+from twc.api import ServiceRegion
 from twc.typerx import TyperAlias
 from twc.apiwrap import create_client
-from twc.vars import REGIONS_WITH_LAN
+from twc.vars import REGIONS_WITH_LAN, ZONES_WITH_LAN
 from .common import (
     verbose_option,
     config_option,
@@ -24,6 +25,7 @@ from .common import (
     output_format_option,
     filter_option,
     region_option,
+    zone_option,
 )
 
 
@@ -31,9 +33,11 @@ vpc = TyperAlias(help=__doc__)
 vpc_port = TyperAlias(help="Manage network ports.")
 vpc.add_typer(vpc_port, name="port", aliases=["ports"])
 
-ALLOWED_SUBNETS = [IPv4Network("10.0.0.0/16"), IPv4Network("192.168.0.0/16")]
-MAX_PREFIXLEN = 16
-MIN_PREFIXLEN = 32
+ALLOWED_SUBNETS = [
+    IPv4Network("10.0.0.0/8"),
+    IPv4Network("192.168.0.0/16"),
+    IPv4Network("172.16.0.0/12"),
+]
 
 
 # ------------------------------------------------------------- #
@@ -46,12 +50,13 @@ def print_networks(response: Response, filters: Optional[str] = None):
     if filters:
         nets = fmt.filter_list(nets, filters)
     table = fmt.Table()
-    table.header(["ID", "REGION", "SUBNET"])
+    table.header(["ID", "REGION", "ZONE", "SUBNET"])
     for net in nets:
         table.row(
             [
                 net["id"],
                 net["location"],
+                net["availability_zone"],
                 net["subnet_v4"],
             ]
         )
@@ -99,8 +104,6 @@ def validate_network(value):
                 f"Error: Network {value} is not subnet of: "
                 f"{[n.with_prefixlen for n in ALLOWED_SUBNETS]}"
             )
-        if network.prefixlen in range(MIN_PREFIXLEN, MAX_PREFIXLEN + 1):
-            sys.exit("Error: Minimum network prefix is 32, maximum is 16.")
     return value
 
 
@@ -108,7 +111,7 @@ def validate_network(value):
 def vpc_create(
     subnet: str = typer.Argument(
         ...,
-        metavar="IP_NETWORK",
+        metavar="NETWORK_SUBNET",
         callback=validate_network,
         help="IPv4 network CIDR.",
     ),
@@ -119,13 +122,23 @@ def vpc_create(
     name: str = typer.Option(None, help="Network display name."),
     desc: Optional[str] = typer.Option(None, help="Description."),
     region: Optional[str] = region_option,
+    availability_zone: Optional[str] = zone_option,
 ):
     """Create network."""
     client = create_client(config, profile)
     if region not in REGIONS_WITH_LAN:
         sys.exit(
             f"Error: Cannot create network in location '{region}'. "
-            f"Available regions is {REGIONS_WITH_LAN}"
+            f"Available regions are: {REGIONS_WITH_LAN}"
+        )
+    usable_zones = set(ZONES_WITH_LAN).intersection(
+        set(ServiceRegion.get_zones(region))
+    )
+    if availability_zone is not None and availability_zone not in usable_zones:
+        sys.exit(
+            f"Error: Cannot create network in region '{region}' with "
+            f"availability zone '{availability_zone}'. "
+            f"Usable zones are: {list(usable_zones)}"
         )
     if not name:
         name = subnet
@@ -134,6 +147,7 @@ def vpc_create(
         description=desc,
         subnet=subnet,
         location=region,
+        availability_zone=availability_zone,
     )
     fmt.printer(
         response,

twc/fmt.py

@@ -31,7 +31,7 @@ class Table:
 
     """
 
-    def __init__(self, whitespace: str = "\t"):
+    def __init__(self, whitespace: str = "  "):
         self.__rows = []
         self.__whitespace = whitespace