sovaria-cli 0.2.0__py3-none-any.whl

apps/cli/src/commands/governance.py

@@ -0,0 +1,491 @@
+"""Nexus governance plane commands (regions, tenants, databases, metrics)."""
+
+from __future__ import annotations
+
+from urllib.parse import quote
+
+import typer
+
+from apps.cli.src.utils.api_client import CLIRequestError, call_api, parse_json_arg
+from apps.cli.src.utils.display import print_json
+
+app = typer.Typer(help="Platform governance: regions, tenants, databases, metrics")
+
+
+def _gov_path(*parts: str) -> str:
+    return "/api/v1/governance/" + "/".join(quote(part, safe="") for part in parts)
+
+
+@app.command("regions")
+def list_regions(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List configured governance regions."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/governance/regions",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("regions-available")
+def regions_available(
+    size: str = typer.Option("micro", "--size", help="Compute size filter"),
+    plan: str | None = typer.Option(None, "--plan", help="Optional plan filter"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List regions with available capacity for provisioning."""
+    params: dict[str, str] = {"size": size}
+    if plan:
+        params["plan"] = plan
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/governance/regions/available",
+            profile=profile,
+            require_scope=False,
+            params=params,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("region-patch")
+def region_patch(
+    region_id: str = typer.Argument(..., help="Region ID"),
+    label: str | None = typer.Option(None, "--label"),
+    status: str | None = typer.Option(None, "--status"),
+    is_default: bool | None = typer.Option(None, "--default/--no-default"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Patch governance region metadata."""
+    body: dict[str, object] = {}
+    if label is not None:
+        body["label"] = label
+    if status is not None:
+        body["status"] = status
+    if is_default is not None:
+        body["is_default"] = is_default
+    if not body:
+        raise typer.BadParameter("Provide at least one of --label, --status, or --default")
+    try:
+        result = call_api(
+            method="PATCH",
+            path=_gov_path("regions", region_id),
+            profile=profile,
+            require_scope=False,
+            body=body,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("tenants")
+def list_tenants(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List registered tenants."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/governance/tenants",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("tenant-get")
+def tenant_get(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch one tenant record."""
+    try:
+        result = call_api(
+            method="GET",
+            path=_gov_path("tenants", org_id),
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("tenant-status")
+def tenant_status(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    status: str = typer.Option(..., "--status", help="active | suspended | deleted"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Update tenant lifecycle status."""
+    try:
+        result = call_api(
+            method="POST",
+            path=_gov_path("tenants", org_id, "status"),
+            profile=profile,
+            require_scope=False,
+            body={"status": status},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("tenant-databases")
+def tenant_databases(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List databases provisioned for a tenant."""
+    try:
+        result = call_api(
+            method="GET",
+            path=_gov_path("tenants", org_id, "databases"),
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("db-provision")
+def db_provision(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    project_id: str = typer.Option(..., "--project", help="Project ID to provision"),
+    tier: str = typer.Option("dedicated", "--tier"),
+    compute_size: str | None = typer.Option(None, "--compute-size"),
+    region: str | None = typer.Option(None, "--region"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Provision a dedicated database for a tenant project."""
+    body: dict[str, object] = {"project_id": project_id, "tier": tier}
+    if compute_size:
+        body["compute_size"] = compute_size
+    if region:
+        body["region"] = region
+    try:
+        result = call_api(
+            method="POST",
+            path=_gov_path("tenants", org_id, "databases", "provision"),
+            profile=profile,
+            require_scope=False,
+            body=body,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("db-connection")
+def db_connection(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    project_id: str = typer.Argument(..., help="Project ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch database connection metadata (password redacted)."""
+    try:
+        result = call_api(
+            method="GET",
+            path=_gov_path("tenants", org_id, "databases", project_id, "connection"),
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("db-connection-reveal")
+def db_connection_reveal(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    project_id: str = typer.Argument(..., help="Project ID"),
+    grant_id: str = typer.Option(..., "--grant-id", help="Active JIT grant ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Reveal database password using an active JIT grant."""
+    try:
+        result = call_api(
+            method="POST",
+            path=_gov_path("tenants", org_id, "databases", project_id, "connection", "reveal"),
+            profile=profile,
+            require_scope=False,
+            body={"grant_id": grant_id},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("db-pause")
+def db_pause(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    project_id: str = typer.Argument(..., help="Project ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Pause a tenant database."""
+    try:
+        result = call_api(
+            method="POST",
+            path=_gov_path("tenants", org_id, "databases", project_id, "pause"),
+            profile=profile,
+            require_scope=False,
+            body={},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("db-resume")
+def db_resume(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    project_id: str = typer.Argument(..., help="Project ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Resume a paused tenant database."""
+    try:
+        result = call_api(
+            method="POST",
+            path=_gov_path("tenants", org_id, "databases", project_id, "resume"),
+            profile=profile,
+            require_scope=False,
+            body={},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("db-resize")
+def db_resize(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    project_id: str = typer.Argument(..., help="Project ID"),
+    compute_size: str = typer.Option(..., "--compute-size", help="Target compute size"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Resize a tenant database compute profile."""
+    try:
+        result = call_api(
+            method="POST",
+            path=_gov_path("tenants", org_id, "databases", project_id, "resize"),
+            profile=profile,
+            require_scope=False,
+            body={"compute_size": compute_size},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("db-backups")
+def db_backups(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    project_id: str = typer.Argument(..., help="Project ID"),
+    limit: int = typer.Option(5, "--limit", min=1, max=100),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List database backups for a tenant project."""
+    try:
+        result = call_api(
+            method="GET",
+            path=_gov_path("tenants", org_id, "databases", project_id, "backups"),
+            profile=profile,
+            require_scope=False,
+            params={"limit": str(limit)},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("db-backup-trigger")
+def db_backup_trigger(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    project_id: str = typer.Argument(..., help="Project ID"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Trigger a manual database backup."""
+    try:
+        result = call_api(
+            method="POST",
+            path=_gov_path("tenants", org_id, "databases", project_id, "backups"),
+            profile=profile,
+            require_scope=False,
+            body={},
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("db-delete")
+def db_delete(
+    org_id: str = typer.Argument(..., help="Organisation / tenant ID"),
+    project_id: str = typer.Argument(..., help="Project ID"),
+    snapshot: bool = typer.Option(True, "--snapshot/--no-snapshot"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Delete a tenant database (optionally after snapshot)."""
+    if not yes and not typer.confirm(f"Delete database for project '{project_id}'?"):
+        raise typer.Exit(0)
+    params = {"snapshot": "true" if snapshot else "false"}
+    try:
+        result = call_api(
+            method="DELETE",
+            path=_gov_path("tenants", org_id, "databases", project_id),
+            profile=profile,
+            require_scope=False,
+            params=params,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("admin-databases")
+def admin_databases(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List all tenant databases (platform admin)."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/governance/admin/databases",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("hosts")
+def list_hosts(
+    region_id: str | None = typer.Option(None, "--region-id"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """List governance hosts."""
+    params = {"region_id": region_id} if region_id else None
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/governance/hosts",
+            profile=profile,
+            require_scope=False,
+            params=params,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("host-patch")
+def host_patch(
+    host_id: str = typer.Argument(..., help="Host ID"),
+    status: str | None = typer.Option(None, "--status"),
+    address: str | None = typer.Option(None, "--address"),
+    total_vcpu: float | None = typer.Option(None, "--total-vcpu"),
+    total_memory_mb: int | None = typer.Option(None, "--total-memory-mb"),
+    total_storage_gb: int | None = typer.Option(None, "--total-storage-gb"),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Patch governance host metadata."""
+    body: dict[str, object] = {}
+    if status is not None:
+        body["status"] = status
+    if address is not None:
+        body["address"] = address
+    if total_vcpu is not None:
+        body["total_vcpu"] = total_vcpu
+    if total_memory_mb is not None:
+        body["total_memory_mb"] = total_memory_mb
+    if total_storage_gb is not None:
+        body["total_storage_gb"] = total_storage_gb
+    if not body:
+        raise typer.BadParameter("Provide at least one patch field")
+    try:
+        result = call_api(
+            method="PATCH",
+            path=_gov_path("hosts", host_id),
+            profile=profile,
+            require_scope=False,
+            body=body,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("metrics-overview")
+def metrics_overview(
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch platform metrics overview."""
+    try:
+        result = call_api(
+            method="GET",
+            path="/api/v1/governance/metrics/overview",
+            profile=profile,
+            require_scope=False,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)
+
+
+@app.command("project-metrics")
+def project_metrics(
+    project_id: str = typer.Argument(..., help="Project ID"),
+    since: str = typer.Option("24", "--since", help="Hours or ISO timestamp"),
+    limit: int = typer.Option(500, "--limit", min=1, max=5000),
+    profile: str | None = typer.Option(None, "--profile"),
+) -> None:
+    """Fetch governance metrics for one project."""
+    params: dict[str, str] = {"since": since}
+    if limit != 500:
+        params["limit"] = str(limit)
+    try:
+        result = call_api(
+            method="GET",
+            path=_gov_path("metrics", "projects", project_id),
+            profile=profile,
+            require_scope=False,
+            params=params,
+        )
+    except CLIRequestError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    print_json(result)