compshare-cli 0.1.0__py3-none-any.whl

compshare_cli/commands/storage.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, Optional
+
+import typer
+
+from compshare_cli.api import call, invoke
+from compshare_cli.commands.common import confirm, request, runtime
+from compshare_cli.i18n import tr
+from compshare_cli.location import locate_disk, locate_instance, region_from_zone, supported_regions
+from compshare_cli.output import Renderer
+from compshare_cli.parsing import compact, disk_gib
+
+app = typer.Typer(help="Manage disks and cloud storage.", no_args_is_help=True)
+disk_app = typer.Typer(help="Manage instance disks.", no_args_is_help=True)
+us3_app = typer.Typer(help="Manage US3 attachments.", no_args_is_help=True)
+app.add_typer(disk_app, name="disk")
+app.add_typer(us3_app, name="us3")
+
+
+def _disk_rows(response: Dict[str, Any]) -> Iterable[Dict[str, Any]]:
+    for instance in response.get("UHostSet", []):
+        for disk in instance.get("DiskSet", []):
+            row = dict(disk)
+            row["UHostId"] = instance.get("UHostId")
+            row["Region"] = instance.get("Region")
+            size = row.get("Size")
+            row["SizeDisplay"] = f"{size}GiB" if isinstance(size, int) else size
+            yield row
+
+
+@disk_app.command("list")
+def list_disks(
+    ctx: typer.Context,
+    instance: Optional[str] = typer.Option(None, "--instance", help="Filter by instance ID."),
+    region: Optional[str] = typer.Option(None, "--region", help="Filter by region."),
+) -> None:
+    """List disks reported by one or all instances."""
+    state = runtime(ctx)
+    if instance:
+        resolved_region, _, host = locate_instance(
+            state,
+            instance,
+            preferred_region=region,
+        )
+        response: Dict[str, Any] = {
+            "UHostSet": [{**host, "Region": resolved_region}],
+            "RegionSet": [resolved_region],
+        }
+    else:
+        regions = [region] if region else supported_regions(state)
+        response = {"UHostSet": [], "RegionSet": regions}
+        for current_region in regions:
+            current = call(
+                state,
+                "DescribeCompShareInstance",
+                {"Region": current_region, "Limit": 100, "Offset": 0},
+            )
+            response["UHostSet"].extend(
+                {**host, "Region": current_region} for host in current.get("UHostSet", [])
+            )
+    Renderer(state.json_output).data(
+        response,
+        rows=_disk_rows(response),
+        columns=(
+            ("UDiskId", "DISK ID"),
+            ("Name", "NAME"),
+            ("SizeDisplay", "SIZE"),
+            ("Type", "TYPE"),
+            ("IsBoot", "BOOT"),
+            ("Device", "DEVICE"),
+            ("UHostId", "INSTANCE"),
+            ("Region", "REGION"),
+        ),
+    )
+
+
+@disk_app.command("create")
+def create_disk(
+    ctx: typer.Context,
+    instance: str = typer.Option(..., "--instance", help="Target instance ID."),
+    size: str = typer.Option(..., help="Disk size, for example 100GiB."),
+    name: str = typer.Option(..., help="Disk name."),
+    disk_type: str = typer.Option("SSDDataDisk", "--type", help="Disk type."),
+    charge: str = typer.Option("Month", help="Billing type."),
+    quantity: int = typer.Option(1, min=1, help="Billing duration for prepaid modes."),
+    coupon: Optional[str] = typer.Option(None, help="Coupon ID."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    """Create a disk and attach it to an instance."""
+    confirm(
+        tr(
+            "Create {size} disk {name} and attach it to {instance}?",
+            size=size,
+            name=name,
+            instance=instance,
+        ),
+        yes,
+    )
+    state = runtime(ctx)
+    region, zone, _ = locate_instance(state, instance)
+    params = request(ctx, zone=True, region_value=region, zone_value=zone)
+    params.update(
+        compact(
+            {
+                "UHostId": instance,
+                "Size": disk_gib(size),
+                "DiskType": disk_type,
+                "Name": name,
+                "ChargeType": charge,
+                "Quantity": quantity,
+                "CouponId": coupon,
+            }
+        )
+    )
+    invoke(
+        state,
+        "CreateAndAttachCompshareDisk",
+        params,
+        success=tr("Created and attached disk {name}", name=name),
+    )
+
+
+@disk_app.command("attach", help="Attach an existing disk to an instance.")
+def attach_disk(
+    ctx: typer.Context,
+    disk: str,
+    instance: str = typer.Option(..., "--instance", help="Target instance ID."),
+    disk_type: Optional[str] = typer.Option(None, "--type", help="Data disk type."),
+) -> None:
+    state = runtime(ctx)
+    region, zone, _ = locate_instance(state, instance)
+    params = request(ctx, zone=True, region_value=region, zone_value=zone)
+    params.update(compact({"UHostId": instance, "UDiskId": disk, "DataDiskType": disk_type}))
+    invoke(
+        state,
+        "AttachCompshareDisk",
+        params,
+        success=tr("Attached {disk} to {instance}", disk=disk, instance=instance),
+    )
+
+
+@disk_app.command("detach", help="Detach a disk from an instance.")
+def detach_disk(
+    ctx: typer.Context,
+    disk: str,
+    instance: str = typer.Option(..., "--instance", help="Attached instance ID."),
+    device: str = typer.Option(..., help="Device path, for example /dev/vdb."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    confirm(
+        tr(
+            "Detach disk {disk} from {instance}? Ensure it is unmounted first.",
+            disk=disk,
+            instance=instance,
+        ),
+        yes,
+    )
+    state = runtime(ctx)
+    region, zone, _ = locate_instance(state, instance)
+    params = request(ctx, zone=True, region_value=region, zone_value=zone)
+    params.update(
+        {
+            "UHostId": instance,
+            "UDiskId": disk,
+            "Device": device,
+        }
+    )
+    invoke(
+        state,
+        "DetachCompshareDisk",
+        params,
+        success=tr("Detached disk {disk}", disk=disk),
+    )
+
+
+@disk_app.command("price", help="Query a disk expansion price.")
+def disk_price(
+    ctx: typer.Context,
+    disk: str,
+    instance: str = typer.Option(..., "--instance", help="Attached instance ID."),
+    size: str = typer.Option(..., help="Target disk size, for example 200GiB."),
+    backup: Optional[str] = typer.Option(None, help="Backup mode: NONE, DATAARK or SNAPSHOT."),
+) -> None:
+    state = runtime(ctx)
+    region, zone, _ = locate_instance(state, instance)
+    params = request(ctx, zone=True, region_value=region, zone_value=zone)
+    params.update(
+        compact(
+            {
+                "UHostId": instance,
+                "DiskId": disk,
+                "DiskSpace": disk_gib(size),
+                "BackupMode": backup,
+            }
+        )
+    )
+    invoke(state, "GetCompShareAttachedDiskUpgradePrice", params)
+
+
+@disk_app.command("resize", help="Resize a disk.")
+def resize_disk(
+    ctx: typer.Context,
+    disk: str,
+    size: str = typer.Option(..., help="Target disk size, for example 200GiB."),
+    instance: Optional[str] = typer.Option(None, "--instance", help="Attached instance ID."),
+    zone: Optional[str] = typer.Option(None, "--zone", help="Availability zone."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    confirm(tr("Resize disk {disk} to {size}? Disks cannot be shrunk.", disk=disk, size=size), yes)
+    state = runtime(ctx)
+    if instance:
+        region, resolved_zone, _ = locate_instance(state, instance)
+    elif zone:
+        region, resolved_zone = region_from_zone(zone), zone
+    else:
+        region, resolved_zone, host, _ = locate_disk(state, disk)
+        instance = str(host.get("UHostId")) if host else None
+    params = request(
+        ctx,
+        zone=True,
+        region_value=region,
+        zone_value=resolved_zone,
+    )
+    params.update(compact({"UDiskId": disk, "UHostId": instance, "Size": disk_gib(size)}))
+    invoke(
+        state,
+        "ResizeCompShareDisk",
+        params,
+        success=tr("Resized disk {disk}", disk=disk),
+    )
+
+
+@disk_app.command("delete", help="Permanently delete a disk.")
+def delete_disk(
+    ctx: typer.Context,
+    disk: str,
+    zone: Optional[str] = typer.Option(None, "--zone", help="Availability zone."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    confirm(tr("Permanently delete disk {disk} and all its data?", disk=disk), yes)
+    state = runtime(ctx)
+    if zone:
+        region, resolved_zone = region_from_zone(zone), zone
+    else:
+        region, resolved_zone, _, _ = locate_disk(state, disk)
+    params = request(
+        ctx,
+        zone=True,
+        region_value=region,
+        zone_value=resolved_zone,
+    )
+    params["UDiskId"] = disk
+    invoke(
+        state,
+        "DeleteCompshareDisk",
+        params,
+        success=tr("Deleted disk {disk}", disk=disk),
+    )
+
+
+@us3_app.command("attach", help="Attach US3 object storage to an instance.")
+def attach_us3(
+    ctx: typer.Context,
+    instance: str = typer.Option(..., "--instance", help="Target running instance ID."),
+) -> None:
+    state = runtime(ctx)
+    region, zone, _ = locate_instance(state, instance)
+    params = request(ctx, zone=True, region_value=region, zone_value=zone)
+    params["UHostId"] = instance
+    invoke(
+        state,
+        "AttachUS3",
+        params,
+        success=tr("Attached US3 to {instance}", instance=instance),
+    )

compshare_cli/config.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import json
+import os
+import stat
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from compshare_cli.errors import ConfigError
+
+DEFAULT_PROFILE = "default"
+DEFAULT_REGION = "cn-wlcb"
+DEFAULT_ZONE = "cn-wlcb-01"
+DEFAULT_BASE_URL = "https://api.compshare.cn"
+
+
+def config_path() -> Path:
+    override = os.environ.get("COMPSHARE_CONFIG_FILE")
+    if override:
+        return Path(override).expanduser()
+    root = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+    return root / "compshare" / "config.json"
+
+
+@dataclass(frozen=True)
+class Profile:
+    public_key: str
+    private_key: str
+
+    def sdk_config(self, region: str) -> Dict[str, Any]:
+        return {
+            "public_key": self.public_key,
+            "private_key": self.private_key,
+            "region": region,
+            "base_url": DEFAULT_BASE_URL,
+        }
+
+
+class ConfigStore:
+    def __init__(self, path: Optional[Path] = None) -> None:
+        self.path = path or config_path()
+
+    def _read(self) -> Dict[str, Any]:
+        if not self.path.exists():
+            return {"current_profile": DEFAULT_PROFILE, "profiles": {}}
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as exc:
+            raise ConfigError(f"无法读取配置文件 {self.path}: {exc}") from exc
+        if not isinstance(data, dict) or not isinstance(data.get("profiles", {}), dict):
+            raise ConfigError(f"配置文件格式无效: {self.path}")
+        return data
+
+    def save_profile(self, name: str, profile: Profile, *, activate: bool = True) -> None:
+        data = self._read()
+        profiles = data.setdefault("profiles", {})
+        profiles[name] = {key: value for key, value in asdict(profile).items() if value is not None}
+        if activate:
+            data["current_profile"] = name
+        self._write(data)
+
+    def list_profiles(self) -> List[str]:
+        return sorted(self._read().get("profiles", {}))
+
+    def current_profile(self) -> str:
+        return str(self._read().get("current_profile", DEFAULT_PROFILE))
+
+    def use_profile(self, name: str) -> None:
+        data = self._read()
+        if name not in data.get("profiles", {}):
+            raise ConfigError(f"Credential profile does not exist: {name}")
+        data["current_profile"] = name
+        self._write(data)
+
+    def delete_profile(self, name: str) -> None:
+        data = self._read()
+        profiles = data.get("profiles", {})
+        if name not in profiles:
+            raise ConfigError(f"Credential profile does not exist: {name}")
+        del profiles[name]
+        if data.get("current_profile") == name:
+            data["current_profile"] = next(iter(sorted(profiles)), DEFAULT_PROFILE)
+        self._write(data)
+
+    def load_language(self) -> Optional[str]:
+        value = self._read().get("language")
+        return str(value) if value else None
+
+    def save_language(self, language: str) -> None:
+        data = self._read()
+        data["language"] = language
+        self._write(data)
+
+    def _write(self, data: Dict[str, Any]) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        os.chmod(self.path.parent, stat.S_IRWXU)
+        temporary = self.path.with_suffix(".tmp")
+        temporary.write_text(
+            json.dumps(data, ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+        )
+        os.chmod(temporary, stat.S_IRUSR | stat.S_IWUSR)
+        temporary.replace(self.path)
+        os.chmod(self.path, stat.S_IRUSR | stat.S_IWUSR)
+
+    def load_profile(self, name: Optional[str] = None) -> Profile:
+        data = self._read()
+        selected = (
+            name
+            or os.environ.get("COMPSHARE_PROFILE")
+            or data.get("current_profile", DEFAULT_PROFILE)
+        )
+        raw = data.get("profiles", {}).get(selected, {})
+
+        public_key = os.environ.get("COMPSHARE_PUBLIC_KEY") or raw.get("public_key")
+        private_key = os.environ.get("COMPSHARE_PRIVATE_KEY") or raw.get("private_key")
+        if not public_key or not private_key:
+            raise ConfigError(
+                "尚未配置 API 密钥。请运行 `compshare config --name NAME`，或设置 "
+                "COMPSHARE_PUBLIC_KEY 和 COMPSHARE_PRIVATE_KEY。"
+            )
+
+        return Profile(
+            public_key=str(public_key),
+            private_key=str(private_key),
+        )

compshare_cli/errors.py

@@ -0,0 +1,10 @@
+class CLIError(Exception):
+    """A user-facing command-line error."""
+
+
+class ConfigError(CLIError):
+    """Raised when CLI configuration is missing or invalid."""
+
+
+class UsageError(CLIError):
+    """Raised when a combination of command options is invalid."""