qod-cli 0.3.7__py3-none-any.whl

qod_cli/commands/node.py

@@ -0,0 +1,58 @@
+import typer
+
+from ._run import call
+
+app = typer.Typer(help="Node lifecycle and statement inspection.")
+statement_app = typer.Typer(help="Statement control.")
+
+TENANT = typer.Option(..., "--tenant")
+DB = typer.Option(..., "--db", help="Tenant database name.")
+POOL = typer.Option(..., "--pool")
+NODE = typer.Option(..., "--node-id")
+
+
+def _key(tenant: str, db: str, pool: str, node_id: str) -> dict:
+    return {"tenant": tenant, "tenantDb": db, "pool": pool, "nodeId": node_id}
+
+
+@app.command()
+def quarantine(ctx: typer.Context, tenant: str = TENANT, db: str = DB, pool: str = POOL, node_id: str = NODE):
+    call(ctx, "POST", "/api/node/quarantine", body=_key(tenant, db, pool, node_id))
+
+
+@app.command()
+def unquarantine(ctx: typer.Context, tenant: str = TENANT, db: str = DB, pool: str = POOL, node_id: str = NODE):
+    call(ctx, "POST", "/api/node/unquarantine", body=_key(tenant, db, pool, node_id))
+
+
+@app.command()
+def restart(ctx: typer.Context, tenant: str = TENANT, db: str = DB, pool: str = POOL, node_id: str = NODE):
+    call(ctx, "POST", "/api/node/restart", body=_key(tenant, db, pool, node_id))
+
+
+@app.command("set-max-concurrent")
+def set_max_concurrent(
+    ctx: typer.Context,
+    tenant: str = TENANT,
+    db: str = DB,
+    pool: str = POOL,
+    node_id: str = NODE,
+    max_: int = typer.Option(..., "--max"),
+):
+    call(ctx, "POST", "/api/node/setMaxConcurrent", body={**_key(tenant, db, pool, node_id), "max": max_})
+
+
+@app.command()
+def statements(ctx: typer.Context, limit: int = typer.Option(None, "--limit")):
+    """Recent statement history, newest first."""
+    call(ctx, "GET", "/api/node/statements", params={"limit": limit})
+
+
+@app.command("active-statements")
+def active_statements(ctx: typer.Context):
+    call(ctx, "GET", "/api/node/active-statements")
+
+
+@statement_app.command()
+def kill(ctx: typer.Context, statement_id: str = typer.Argument(..., metavar="ID")):
+    call(ctx, "POST", "/api/statement/kill", body={"id": statement_id})

qod_cli/commands/pool.py

@@ -0,0 +1,137 @@
+import typer
+
+from ._run import call
+
+app = typer.Typer(help="Pool lifecycle and pool-level access grants.")
+permission_app = typer.Typer(help="Pool access grants for users and groups.")
+app.add_typer(permission_app, name="permission")
+
+TENANT = typer.Option(..., "--tenant")
+DB = typer.Option(..., "--db", help="Tenant database name.")
+POOL = typer.Option(..., "--pool")
+
+
+def _key(tenant: str, db: str, pool: str) -> dict:
+    return {"tenant": tenant, "tenantDb": db, "pool": pool}
+
+
+@app.command("list")
+def list_(ctx: typer.Context):
+    call(ctx, "GET", "/api/pool/list")
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    tenant: str = TENANT,
+    db: str = DB,
+    pool: str = POOL,
+    size: int = typer.Option(..., "--size"),
+    writeonly: int = typer.Option(0, "--writeonly"),
+    readonly: int = typer.Option(0, "--readonly"),
+    dual: int = typer.Option(0, "--dual"),
+    idle_timeout_sec: int = typer.Option(-1, "--idle-timeout-sec"),
+    max_concurrent_per_node: int = typer.Option(0, "--max-concurrent-per-node"),
+    disabled: bool = typer.Option(False, "--disabled"),
+    init_sql: str = typer.Option(None, "--init-sql"),
+    cpu: str = typer.Option("", "--cpu"),
+    memory: str = typer.Option("", "--memory"),
+    pod_template_file: typer.FileText = typer.Option(None, "--pod-template-file"),
+):
+    body = {
+        **_key(tenant, db, pool),
+        "size": size,
+        "roleDistribution": {"writeonly": writeonly, "readonly": readonly, "dual": dual},
+        "idleTimeoutSec": idle_timeout_sec,
+        "maxConcurrentPerNode": max_concurrent_per_node,
+        "disabled": disabled,
+        "cpu": cpu,
+        "memory": memory,
+        "podTemplateYaml": pod_template_file.read() if pod_template_file else "",
+    }
+    if init_sql is not None:
+        body["initSql"] = init_sql
+    call(ctx, "POST", "/api/pool/create", body=body)
+
+
+@app.command()
+def scale(
+    ctx: typer.Context,
+    tenant: str = TENANT,
+    db: str = DB,
+    pool: str = POOL,
+    target_size: int = typer.Option(..., "--target-size"),
+    writeonly: int = typer.Option(0, "--writeonly"),
+    readonly: int = typer.Option(0, "--readonly"),
+    dual: int = typer.Option(0, "--dual"),
+    force: bool = typer.Option(False, "--force"),
+):
+    call(
+        ctx,
+        "POST",
+        "/api/pool/scale",
+        body={
+            **_key(tenant, db, pool),
+            "targetSize": target_size,
+            "roleDistribution": {"writeonly": writeonly, "readonly": readonly, "dual": dual},
+            "force": force,
+        },
+    )
+
+
+@app.command()
+def stop(ctx: typer.Context, tenant: str = TENANT, db: str = DB, pool: str = POOL, force: bool = typer.Option(False, "--force")):
+    call(ctx, "POST", "/api/pool/stop", body={**_key(tenant, db, pool), "force": force})
+
+
+@app.command()
+def delete(ctx: typer.Context, tenant: str = TENANT, db: str = DB, pool: str = POOL, force: bool = typer.Option(False, "--force")):
+    call(ctx, "POST", "/api/pool/delete", body={**_key(tenant, db, pool), "force": force})
+
+
+@app.command("set-disabled")
+def set_disabled(ctx: typer.Context, tenant: str = TENANT, db: str = DB, pool: str = POOL, disabled: bool = typer.Option(..., "--disabled/--enabled")):
+    call(ctx, "POST", "/api/pool/setDisabled", body={**_key(tenant, db, pool), "disabled": disabled})
+
+
+@app.command("set-resources")
+def set_resources(ctx: typer.Context, tenant: str = TENANT, db: str = DB, pool: str = POOL, cpu: str = typer.Option(..., "--cpu"), memory: str = typer.Option(..., "--memory")):
+    call(ctx, "POST", "/api/pool/setResources", body={**_key(tenant, db, pool), "cpu": cpu, "memory": memory})
+
+
+@app.command("set-pod-template")
+def set_pod_template(ctx: typer.Context, tenant: str = TENANT, db: str = DB, pool: str = POOL, file: typer.FileText = typer.Option(..., "--file")):
+    call(ctx, "POST", "/api/pool/setPodTemplate", body={**_key(tenant, db, pool), "podTemplateYaml": file.read()})
+
+
+@permission_app.command("list")
+def permission_list(
+    ctx: typer.Context,
+    tenant: str = typer.Option(None, "--tenant"),
+    user_id: str = typer.Option(None, "--user-id"),
+    group_id: str = typer.Option(None, "--group-id"),
+):
+    call(ctx, "GET", "/api/pool/permission/list", params={"tenant": tenant, "userId": user_id, "groupId": group_id})
+
+
+@permission_app.command("grant")
+def permission_grant(
+    ctx: typer.Context,
+    tenant: str = typer.Option(..., "--tenant"),
+    pool_id: str = typer.Option(None, "--pool-id", help="Omit = every pool in the tenant."),
+    user_id: str = typer.Option(None, "--user-id"),
+    group_id: str = typer.Option(None, "--group-id", help="Exactly one of --user-id / --group-id."),
+):
+    body: dict = {"tenant": tenant}
+    if pool_id is not None:
+        body["poolId"] = pool_id
+    if user_id is not None:
+        body["userId"] = user_id
+    if group_id is not None:
+        body["groupId"] = group_id
+    call(ctx, "POST", "/api/pool/permission/grant", body=body)
+
+
+@permission_app.command("revoke")
+def permission_revoke(ctx: typer.Context, grant_id: str = typer.Argument(..., metavar="ID")):
+    call(ctx, "POST", "/api/pool/permission/revoke", body={"id": grant_id})

qod_cli/commands/role.py

@@ -0,0 +1,150 @@
+import typer
+
+from ._run import call
+
+app = typer.Typer(help="Roles, table permissions, and row/column policies.")
+permission_app = typer.Typer(help="Table permissions attached to a role.")
+row_policy_app = typer.Typer(help="Row-level security predicates.")
+column_policy_app = typer.Typer(help="Column-level security policies.")
+app.add_typer(permission_app, name="permission")
+app.add_typer(row_policy_app, name="row-policy")
+app.add_typer(column_policy_app, name="column-policy")
+
+
+@app.command("list")
+def list_(ctx: typer.Context, tenant: str = typer.Option(..., "--tenant")):
+    call(ctx, "GET", "/api/role/list", params={"tenant": tenant})
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    tenant: str = typer.Option(..., "--tenant"),
+    name: str = typer.Option(..., "--name"),
+    description: str = typer.Option(None, "--description"),
+):
+    body: dict = {"tenant": tenant, "name": name}
+    if description is not None:
+        body["description"] = description
+    call(ctx, "POST", "/api/role/create", body=body)
+
+
+@app.command()
+def delete(ctx: typer.Context, role_id: str = typer.Argument(..., metavar="ID")):
+    call(ctx, "POST", "/api/role/delete", body={"id": role_id})
+
+
+@permission_app.command("list")
+def permission_list(ctx: typer.Context, role_id: str = typer.Option(..., "--role-id")):
+    call(ctx, "GET", "/api/role/permission/list", params={"roleId": role_id})
+
+
+@permission_app.command("grant")
+def permission_grant(
+    ctx: typer.Context,
+    role_id: str = typer.Option(..., "--role-id"),
+    verb: str = typer.Option(..., "--verb", help="RO|RW|DDL|ALL"),
+    catalog: str = typer.Option("*", "--catalog"),
+    schema: str = typer.Option("*", "--schema"),
+    table: str = typer.Option("*", "--table"),
+):
+    call(
+        ctx,
+        "POST",
+        "/api/role/permission/grant",
+        body={"roleId": role_id, "catalog": catalog, "schema": schema, "table": table, "verb": verb},
+    )
+
+
+@permission_app.command("revoke")
+def permission_revoke(ctx: typer.Context, permission_id: str = typer.Argument(..., metavar="ID")):
+    call(ctx, "POST", "/api/role/permission/revoke", body={"id": permission_id})
+
+
+@row_policy_app.command("list")
+def row_policy_list(ctx: typer.Context, role_id: str = typer.Option(..., "--role-id")):
+    call(ctx, "GET", "/api/role/row-policy/list", params={"roleId": role_id})
+
+
+@row_policy_app.command("create")
+def row_policy_create(
+    ctx: typer.Context,
+    role_id: str = typer.Option(..., "--role-id"),
+    catalog: str = typer.Option(..., "--catalog"),
+    schema: str = typer.Option(..., "--schema"),
+    table: str = typer.Option(..., "--table"),
+    predicate_sql: str = typer.Option(..., "--predicate-sql"),
+):
+    call(
+        ctx,
+        "POST",
+        "/api/role/row-policy/create",
+        body={
+            "roleId": role_id,
+            "catalogName": catalog,
+            "schemaName": schema,
+            "tableName": table,
+            "predicateSql": predicate_sql,
+        },
+    )
+
+
+@row_policy_app.command("update")
+def row_policy_update(
+    ctx: typer.Context,
+    policy_id: str = typer.Argument(..., metavar="ID"),
+    predicate_sql: str = typer.Option(..., "--predicate-sql"),
+):
+    call(ctx, "POST", "/api/role/row-policy/update", body={"id": policy_id, "predicateSql": predicate_sql})
+
+
+@row_policy_app.command("delete")
+def row_policy_delete(ctx: typer.Context, policy_id: str = typer.Argument(..., metavar="ID")):
+    call(ctx, "POST", "/api/role/row-policy/delete", body={"id": policy_id})
+
+
+@column_policy_app.command("list")
+def column_policy_list(ctx: typer.Context, role_id: str = typer.Option(..., "--role-id")):
+    call(ctx, "GET", "/api/role/column-policy/list", params={"roleId": role_id})
+
+
+@column_policy_app.command("create")
+def column_policy_create(
+    ctx: typer.Context,
+    role_id: str = typer.Option(..., "--role-id"),
+    catalog: str = typer.Option(..., "--catalog"),
+    schema: str = typer.Option(..., "--schema"),
+    table: str = typer.Option(..., "--table"),
+    column: str = typer.Option(..., "--column"),
+    action: str = typer.Option(..., "--action"),
+    transform_sql: str = typer.Option(None, "--transform-sql"),
+):
+    body: dict = {
+        "roleId": role_id,
+        "catalogName": catalog,
+        "schemaName": schema,
+        "tableName": table,
+        "columnName": column,
+        "action": action,
+    }
+    if transform_sql is not None:
+        body["transformSql"] = transform_sql
+    call(ctx, "POST", "/api/role/column-policy/create", body=body)
+
+
+@column_policy_app.command("update")
+def column_policy_update(
+    ctx: typer.Context,
+    policy_id: str = typer.Argument(..., metavar="ID"),
+    action: str = typer.Option(..., "--action"),
+    transform_sql: str = typer.Option(None, "--transform-sql"),
+):
+    body: dict = {"id": policy_id, "action": action}
+    if transform_sql is not None:
+        body["transformSql"] = transform_sql
+    call(ctx, "POST", "/api/role/column-policy/update", body=body)
+
+
+@column_policy_app.command("delete")
+def column_policy_delete(ctx: typer.Context, policy_id: str = typer.Argument(..., metavar="ID")):
+    call(ctx, "POST", "/api/role/column-policy/delete", body={"id": policy_id})

qod_cli/commands/sql_cmd.py

@@ -0,0 +1,86 @@
+import typer
+
+from ..sql import SqlClient, render_table
+
+
+def repl(client, mode: str, input_fn=input) -> None:
+    try:
+        import readline  # noqa: F401  (line editing + history; pyreadline3 provides it on Windows)
+    except ImportError:
+        pass
+    import sys
+
+    buffer: list[str] = []
+    while True:
+        prompt = "qod> " if not buffer else "...> "
+        try:
+            line = input_fn(prompt)
+        except EOFError:
+            break
+        except KeyboardInterrupt:
+            buffer.clear()
+            print(file=sys.stderr)
+            continue
+        if not buffer and line.strip() == "\\q":
+            break
+        buffer.append(line)
+        if not line.rstrip().endswith(";"):
+            continue
+        statement = "\n".join(buffer)
+        buffer.clear()
+        try:
+            render_table(client.query(statement), mode)
+        except Exception as exc:
+            print(f"error: {exc}", file=sys.stderr)
+
+
+def _mode(ctx: typer.Context, csv_flag: bool) -> str:
+    if csv_flag and ctx.obj.json_output:
+        raise typer.BadParameter("--csv and --json are mutually exclusive")
+    return "csv" if csv_flag else "json" if ctx.obj.json_output else "table"
+
+
+def _connect(ctx: typer.Context) -> SqlClient:
+    settings = ctx.obj.settings
+    if not settings.sql_user:
+        raise typer.BadParameter("no SQL user configured; run qod login or set QOD_USER")
+    if not settings.sql_password:
+        settings.sql_password = typer.prompt(f"Password for {settings.sql_user}", hide_input=True)
+    return SqlClient.connect(settings)
+
+
+def sql(
+    ctx: typer.Context,
+    statement: str = typer.Argument(None, help="SQL to run; omit for the interactive REPL."),
+    csv_flag: bool = typer.Option(False, "--csv", help="CSV to stdout."),
+    tenant: str = typer.Option(None, "--tenant", help="Override the profile tenant."),
+    pool: str = typer.Option(None, "--pool", help="Override the profile pool."),
+    superuser: bool = typer.Option(None, "--superuser/--no-superuser"),
+):
+    """Run SQL against the FlightSQL edge."""
+    settings = ctx.obj.settings
+    if tenant is not None:
+        settings.tenant = tenant
+    if pool is not None:
+        settings.pool = pool
+    if superuser is not None:
+        settings.superuser = superuser
+    mode = _mode(ctx, csv_flag)
+    if statement is None:
+        try:
+            with _connect(ctx) as client:
+                repl(client, mode)
+        except (typer.BadParameter, typer.Exit):
+            raise
+        except Exception as exc:
+            typer.echo(f"error: {exc}", err=True)
+            raise typer.Exit(1)
+        return
+    try:
+        with _connect(ctx) as client:
+            render_table(client.query(statement), mode)
+    except (typer.BadParameter, typer.Exit):
+        raise
+    except Exception as exc:  # ADBC raises driver-specific exception types
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(1)

qod_cli/commands/tag.py

@@ -0,0 +1,47 @@
+import typer
+
+from ._run import call
+
+app = typer.Typer(help="Snapshot tags (create, delete, protect).")
+
+TENANT = typer.Option(..., "--tenant")
+DB = typer.Option(..., "--db")
+NAME = typer.Option(..., "--name")
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    tenant: str = TENANT,
+    db: str = DB,
+    name: str = NAME,
+    snapshot_id: int = typer.Option(..., "--snapshot-id"),
+    protected: bool = typer.Option(False, "--protected"),
+):
+    call(
+        ctx,
+        "POST",
+        "/api/catalog/tag/create",
+        body={"tenant": tenant, "tenantDb": db, "name": name, "snapshotId": snapshot_id, "isProtected": protected},
+    )
+
+
+@app.command()
+def delete(ctx: typer.Context, tenant: str = TENANT, db: str = DB, name: str = NAME):
+    call(ctx, "POST", "/api/catalog/tag/delete", body={"tenant": tenant, "tenantDb": db, "name": name})
+
+
+@app.command()
+def protect(
+    ctx: typer.Context,
+    tenant: str = TENANT,
+    db: str = DB,
+    name: str = NAME,
+    protected: bool = typer.Option(..., "--protected/--unprotected"),
+):
+    call(
+        ctx,
+        "POST",
+        "/api/catalog/tag/protect",
+        body={"tenant": tenant, "tenantDb": db, "name": name, "isProtected": protected},
+    )

qod_cli/commands/telemetry.py

@@ -0,0 +1,95 @@
+import typer
+
+from ._run import call
+
+audit_app = typer.Typer(help="Audit log.")
+history_app = typer.Typer(help="Statement history and trends.")
+
+
+@audit_app.command("list")
+def audit_list(
+    ctx: typer.Context,
+    family: str = typer.Option(None, "--family"),
+    tenant: str = typer.Option(None, "--tenant"),
+    actor: str = typer.Option(None, "--actor"),
+    action: str = typer.Option(None, "--action"),
+    q: str = typer.Option(None, "--q", help="Free-text filter."),
+    from_: str = typer.Option(None, "--from"),
+    to: str = typer.Option(None, "--to"),
+    limit: int = typer.Option(None, "--limit"),
+    before: str = typer.Option(None, "--before", help="Keyset pagination token."),
+    no_tenant: bool = typer.Option(None, "--no-tenant", help="Only rows without a tenant."),
+):
+    call(
+        ctx,
+        "GET",
+        "/api/audit/list",
+        params={
+            "family": family, "tenant": tenant, "actor": actor, "action": action, "q": q,
+            "from": from_, "to": to, "limit": limit, "before": before, "noTenant": no_tenant,
+        },
+    )
+
+
+@audit_app.command()
+def actions(ctx: typer.Context):
+    """Distinct audit action names, for filter values."""
+    call(ctx, "GET", "/api/audit/actions")
+
+
+def usage(
+    ctx: typer.Context,
+    from_: str = typer.Option(None, "--from"),
+    to: str = typer.Option(None, "--to"),
+    group_by: str = typer.Option(None, "--group-by"),
+    tenant: str = typer.Option(None, "--tenant"),
+    pool: str = typer.Option(None, "--pool"),
+):
+    """Usage accounting rollups."""
+    call(
+        ctx,
+        "GET",
+        "/api/usage",
+        params={"from": from_, "to": to, "groupBy": group_by, "tenant": tenant, "pool": pool},
+    )
+
+
+@history_app.command()
+def statements(
+    ctx: typer.Context,
+    from_: str = typer.Option(None, "--from"),
+    to: str = typer.Option(None, "--to"),
+    tenant: str = typer.Option(None, "--tenant"),
+    pool: str = typer.Option(None, "--pool"),
+    user: str = typer.Option(None, "--user"),
+    status: str = typer.Option(None, "--status"),
+    q: str = typer.Option(None, "--q"),
+    limit: int = typer.Option(None, "--limit"),
+    before: str = typer.Option(None, "--before"),
+):
+    call(
+        ctx,
+        "GET",
+        "/api/history/statements",
+        params={
+            "from": from_, "to": to, "tenant": tenant, "pool": pool, "user": user,
+            "status": status, "q": q, "limit": limit, "before": before,
+        },
+    )
+
+
+@history_app.command()
+def trends(
+    ctx: typer.Context,
+    granularity: str = typer.Option(None, "--granularity"),
+    from_: str = typer.Option(None, "--from"),
+    to: str = typer.Option(None, "--to"),
+    tenant: str = typer.Option(None, "--tenant"),
+    pool: str = typer.Option(None, "--pool"),
+):
+    call(
+        ctx,
+        "GET",
+        "/api/history/trends",
+        params={"granularity": granularity, "from": from_, "to": to, "tenant": tenant, "pool": pool},
+    )

qod_cli/commands/tenant.py

@@ -0,0 +1,61 @@
+import typer
+
+from ._run import call, kv_pairs
+
+app = typer.Typer(help="Tenant CRUD.")
+
+
+@app.command("list")
+def list_(ctx: typer.Context):
+    call(ctx, "GET", "/api/tenant/list")
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    tenant_id: str = typer.Argument(..., metavar="ID", help="Lowercase slug, e.g. acme."),
+    display_name: str = typer.Option("", "--display-name"),
+    auth_provider: str = typer.Option("db", "--auth-provider", help="db|keycloak|google|azure|aws"),
+    auth_config: list[str] = typer.Option(None, "--auth-config", help="KEY=VALUE, repeatable."),
+):
+    call(
+        ctx,
+        "POST",
+        "/api/tenant/create",
+        body={
+            "id": tenant_id,
+            "displayName": display_name,
+            "authProvider": auth_provider,
+            "authConfig": kv_pairs(auth_config),
+        },
+    )
+
+
+@app.command()
+def delete(ctx: typer.Context, name: str = typer.Argument(...)):
+    """Delete a tenant (must have no pools)."""
+    call(ctx, "POST", "/api/tenant/delete", body={"name": name})
+
+
+@app.command("set-disabled")
+def set_disabled(
+    ctx: typer.Context,
+    name: str = typer.Argument(...),
+    disabled: bool = typer.Option(..., "--disabled/--enabled"),
+):
+    call(ctx, "POST", "/api/tenant/setDisabled", body={"name": name, "disabled": disabled})
+
+
+@app.command("set-auth")
+def set_auth(
+    ctx: typer.Context,
+    name: str = typer.Argument(...),
+    auth_provider: str = typer.Option(..., "--auth-provider"),
+    auth_config: list[str] = typer.Option(None, "--auth-config", help="KEY=VALUE, repeatable."),
+):
+    call(
+        ctx,
+        "POST",
+        "/api/tenant/setAuth",
+        body={"name": name, "authProvider": auth_provider, "authConfig": kv_pairs(auth_config)},
+    )