splunkctl 0.1.0__py3-none-any.whl

splunkctl/commands/dashboards.py

@@ -0,0 +1,216 @@
+"""Dashboard CRUD — raw REST (SDK gap)."""
+
+import json
+import urllib.parse
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+import click
+
+from splunkctl import guard, output
+from splunkctl.client import get_client
+
+_READ_BASE = "/servicesNS/-/{app}/data/ui/views"
+_WRITE_BASE = "/servicesNS/nobody/{app}/data/ui/views"
+
+
+def _read_path(app: str, name: str | None = None) -> str:
+    base = _READ_BASE.format(app=quote(app, safe=""))
+    return f"{base}/{quote(name, safe='')}" if name else base
+
+
+def _write_path(app: str, name: str | None = None) -> str:
+    base = _WRITE_BASE.format(app=quote(app, safe=""))
+    return f"{base}/{quote(name, safe='')}" if name else base
+
+
+def _rest_get(service: Any, path: str) -> dict[str, Any]:
+    """GET JSON from Splunk REST API."""
+    resp = service.get(path, output_mode="json", count=0)
+    body: dict[str, Any] = json.loads(resp.body.read())
+    return body
+
+
+@click.group("dashboards")
+def dashboards_group() -> None:
+    """Dashboard management (raw REST)."""
+
+
+@dashboards_group.command("list")
+@click.option("--app", default="-", help="Splunk app context.")
+@click.pass_context
+def list_dashboards(ctx: click.Context, *, app: str) -> None:
+    """List dashboards."""
+    client = get_client(ctx)
+    body = _rest_get(client.service, _read_path(app))
+    rows: list[dict[str, Any]] = [
+        {
+            "name": e["name"],
+            "app": e.get("acl", {}).get("app", ""),
+            "label": e.get("content", {}).get("label", ""),
+            "isDashboard": e.get("content", {}).get("isDashboard", False),
+            "isVisible": e.get("content", {}).get("isVisible", False),
+        }
+        for e in body.get("entry", [])
+    ]
+    output.render(ctx, rows)
+
+
+@dashboards_group.command("get")
+@click.argument("name")
+@click.option("--app", default="-", help="Splunk app context.")
+@click.pass_context
+def get_dashboard(ctx: click.Context, name: str, *, app: str) -> None:
+    """Get dashboard details including XML source."""
+    client = get_client(ctx)
+    try:
+        body = _rest_get(client.service, _read_path(app, name))
+    except Exception as exc:
+        output.error(f"Dashboard '{name}' not found: {exc}")
+        ctx.exit(1)
+        return
+    entries: list[dict[str, Any]] = body.get("entry", [])
+    if not entries:
+        output.error(f"Dashboard '{name}' not found.")
+        ctx.exit(1)
+        return
+    e = entries[0]
+    row: dict[str, Any] = {
+        "name": e["name"],
+        "app": e.get("acl", {}).get("app", ""),
+        "label": e.get("content", {}).get("label", ""),
+        "isDashboard": e.get("content", {}).get("isDashboard", False),
+        "isVisible": e.get("content", {}).get("isVisible", False),
+        "eai:data": e.get("content", {}).get("eai:data", ""),
+    }
+    output.render(ctx, row)
+
+
+@dashboards_group.command("create")
+@click.option("--name", required=True, help="Dashboard name.")
+@click.option(
+    "--file",
+    "filepath",
+    required=True,
+    type=click.Path(exists=True),
+    help="XML file path.",
+)
+@click.option("--app", default="search", help="Splunk app context.")
+@click.option("--label", default=None, help="Dashboard label.")
+@click.pass_context
+def create_dashboard(
+    ctx: click.Context,
+    name: str,
+    filepath: str,
+    *,
+    app: str,
+    label: str | None,
+) -> None:
+    """Create a dashboard from XML file."""
+    xml_content = Path(filepath).read_text(encoding="utf-8")
+    details = f"  name: {name}\n  app: {app}\n  file: {filepath}"
+    if label:
+        details += f"\n  label: {label}"
+    if not guard.check(ctx, f"Create dashboard '{name}'", details=details):
+        return
+    client = get_client(ctx)
+    params: dict[str, str] = {"name": name, "eai:data": xml_content}
+    if label:
+        params["label"] = label
+    try:
+        client.service.post(_write_path(app), body=urllib.parse.urlencode(params))
+    except Exception as exc:
+        output.error(f"Create failed: {exc}")
+        ctx.exit(1)
+        return
+    output.info(f"Dashboard '{name}' created in app '{app}'.")
+
+
+@dashboards_group.command("update")
+@click.argument("name")
+@click.option(
+    "--file",
+    "filepath",
+    required=True,
+    type=click.Path(exists=True),
+    help="XML file path.",
+)
+@click.option("--app", default="search", help="Splunk app context.")
+@click.pass_context
+def update_dashboard(
+    ctx: click.Context,
+    name: str,
+    filepath: str,
+    *,
+    app: str,
+) -> None:
+    """Update dashboard XML."""
+    xml_content = Path(filepath).read_text(encoding="utf-8")
+    details = f"  name: {name}\n  app: {app}\n  file: {filepath}"
+    if not guard.check(ctx, f"Update dashboard '{name}'", details=details):
+        return
+    client = get_client(ctx)
+    try:
+        client.service.post(
+            _write_path(app, name),
+            body=urllib.parse.urlencode({"eai:data": xml_content}),
+        )
+    except Exception as exc:
+        output.error(f"Update failed: {exc}")
+        ctx.exit(1)
+        return
+    output.info(f"Dashboard '{name}' updated.")
+
+
+@dashboards_group.command("delete")
+@click.argument("name")
+@click.option("--app", default="search", help="Splunk app context.")
+@click.pass_context
+def delete_dashboard(ctx: click.Context, name: str, *, app: str) -> None:
+    """Delete a dashboard."""
+    if not guard.check(ctx, f"Delete dashboard '{name}'", details=f"  app: {app}"):
+        return
+    client = get_client(ctx)
+    try:
+        client.service.delete(_write_path(app, name))
+    except Exception as exc:
+        output.error(f"Delete failed: {exc}")
+        ctx.exit(1)
+        return
+    output.info(f"Dashboard '{name}' deleted.")
+
+
+@dashboards_group.command("export")
+@click.argument("name")
+@click.option("--app", default="-", help="Splunk app context.")
+@click.option(
+    "--out",
+    "out_file",
+    type=click.Path(),
+    default=None,
+    help="Output file.",
+)
+@click.pass_context
+def export_dashboard(
+    ctx: click.Context, name: str, *, app: str, out_file: str | None
+) -> None:
+    """Export dashboard XML to file or stdout."""
+    client = get_client(ctx)
+    try:
+        body = _rest_get(client.service, _read_path(app, name))
+    except Exception as exc:
+        output.error(f"Dashboard '{name}' not found: {exc}")
+        ctx.exit(1)
+        return
+    entries: list[dict[str, Any]] = body.get("entry", [])
+    if not entries:
+        output.error(f"Dashboard '{name}' not found.")
+        ctx.exit(1)
+        return
+    xml: str = entries[0].get("content", {}).get("eai:data", "")
+    if out_file:
+        Path(out_file).write_text(xml, encoding="utf-8")
+        output.info(f"Exported to {out_file}")
+    else:
+        click.echo(xml)

splunkctl/commands/indexes.py

@@ -0,0 +1,199 @@
+"""Index management — list, get, create, update, delete, clean, reload."""
+
+from typing import Any
+
+import click
+
+from splunkctl import guard, output
+from splunkctl.client import get_client
+
+_LIST_FIELDS = (
+    "name",
+    "datatype",
+    "totalEventCount",
+    "currentDBSizeMB",
+    "maxDataSizeMB",
+    "frozenTimePeriodInSecs",
+    "disabled",
+)
+
+
+def _index_row(idx: Any, fields: tuple[str, ...] = _LIST_FIELDS) -> dict[str, Any]:
+    content: dict[str, Any] = dict(idx.content)
+    row: dict[str, Any] = {"name": idx.name}
+    for f in fields:
+        if f != "name":
+            row[f] = content.get(f, "")
+    return row
+
+
+@click.group("indexes")
+def indexes_group() -> None:
+    """Manage Splunk indexes."""
+
+
+@indexes_group.command("list")
+@click.pass_context
+def list_indexes(ctx: click.Context) -> None:
+    """List all indexes."""
+    client = get_client(ctx)
+    rows = [_index_row(idx) for idx in client.service.indexes.list()]
+    output.render(ctx, rows)
+
+
+@indexes_group.command("get")
+@click.argument("name")
+@click.pass_context
+def get_index(ctx: click.Context, name: str) -> None:
+    """Get full index details."""
+    client = get_client(ctx)
+    try:
+        idx = client.service.indexes[name]
+    except KeyError:
+        output.error(f"Index '{name}' not found.")
+        ctx.exit(1)
+        return
+    row: dict[str, Any] = {"name": idx.name, **dict(idx.content)}
+    output.render(ctx, row)
+
+
+@indexes_group.command("create")
+@click.option("--name", required=True, help="Index name.")
+@click.option(
+    "--datatype",
+    type=click.Choice(["event", "metric"]),
+    default=None,
+    help="Index datatype.",
+)
+@click.option("--max-size", type=int, default=None, help="Max data size in MB.")
+@click.option(
+    "--frozen-period", type=int, default=None, help="Frozen time period in seconds."
+)
+@click.option("--home-path", default=None, help="Home path for hot/warm buckets.")
+@click.option("--cold-path", default=None, help="Cold path for cold buckets.")
+@click.pass_context
+def create_index(
+    ctx: click.Context,
+    name: str,
+    datatype: str | None,
+    max_size: int | None,
+    frozen_period: int | None,
+    home_path: str | None,
+    cold_path: str | None,
+) -> None:
+    """Create a new index."""
+    kwargs: dict[str, Any] = {}
+    if datatype is not None:
+        kwargs["datatype"] = datatype
+    if max_size is not None:
+        kwargs["maxDataSizeMB"] = max_size
+    if frozen_period is not None:
+        kwargs["frozenTimePeriodInSecs"] = frozen_period
+    if home_path is not None:
+        kwargs["homePath"] = home_path
+    if cold_path is not None:
+        kwargs["coldPath"] = cold_path
+
+    details = f"  name={name}"
+    for k, v in kwargs.items():
+        details += f"\n  {k}={v}"
+
+    if not guard.check(ctx, f"Create index '{name}'", details=details):
+        return
+
+    client = get_client(ctx)
+    client.service.indexes.create(name, **kwargs)
+    output.info(f"Index '{name}' created.")
+
+
+@indexes_group.command("update")
+@click.argument("name")
+@click.option("--max-size", type=int, default=None, help="Max data size in MB.")
+@click.option(
+    "--frozen-period", type=int, default=None, help="Frozen time period in seconds."
+)
+@click.pass_context
+def update_index(
+    ctx: click.Context,
+    name: str,
+    max_size: int | None,
+    frozen_period: int | None,
+) -> None:
+    """Update index settings."""
+    kwargs: dict[str, Any] = {}
+    if max_size is not None:
+        kwargs["maxDataSizeMB"] = max_size
+    if frozen_period is not None:
+        kwargs["frozenTimePeriodInSecs"] = frozen_period
+
+    if not kwargs:
+        output.error("No settings to update. Provide --max-size or --frozen-period.")
+        ctx.exit(1)
+        return
+
+    details = f"  index={name}"
+    for k, v in kwargs.items():
+        details += f"\n  {k}={v}"
+
+    if not guard.check(ctx, f"Update index '{name}'", details=details):
+        return
+
+    client = get_client(ctx)
+    try:
+        idx = client.service.indexes[name]
+    except KeyError:
+        output.error(f"Index '{name}' not found.")
+        ctx.exit(1)
+        return
+    idx.update(**kwargs).refresh()
+    output.info(f"Index '{name}' updated.")
+
+
+@indexes_group.command("delete")
+@click.argument("name")
+@click.pass_context
+def delete_index(ctx: click.Context, name: str) -> None:
+    """Delete an index."""
+    if not guard.check(ctx, f"Delete index '{name}'"):
+        return
+
+    client = get_client(ctx)
+    try:
+        idx = client.service.indexes[name]
+    except KeyError:
+        output.error(f"Index '{name}' not found.")
+        ctx.exit(1)
+        return
+    idx.delete()
+    output.info(f"Index '{name}' deleted.")
+
+
+@indexes_group.command("clean")
+@click.argument("name")
+@click.pass_context
+def clean_index(ctx: click.Context, name: str) -> None:
+    """Remove all events from an index."""
+    if not guard.check(ctx, f"Clean index '{name}' (remove all events)"):
+        return
+
+    client = get_client(ctx)
+    try:
+        idx = client.service.indexes[name]
+    except KeyError:
+        output.error(f"Index '{name}' not found.")
+        ctx.exit(1)
+        return
+    idx.clean(timeout=60)
+    output.info(f"Index '{name}' cleaned.")
+
+
+@indexes_group.command("reload")
+@click.pass_context
+def reload_indexes(ctx: click.Context) -> None:
+    """Reload all index configurations."""
+    if not guard.check(ctx, "Reload all index configurations"):
+        return
+
+    client = get_client(ctx)
+    client.service.post("/services/data/indexes/_reload")
+    output.info("Index configurations reloaded.")

splunkctl/commands/info.py

@@ -0,0 +1,29 @@
+"""Info command — server info, license, version."""
+
+from typing import Any
+
+import click
+
+from splunkctl import output
+from splunkctl.client import get_client
+
+
+@click.command()
+@click.pass_context
+def info(ctx: click.Context) -> None:
+    """Show Splunk server info."""
+    client = get_client(ctx)
+    svc = client.service
+    si: dict[str, Any] = dict(svc.info)
+
+    row: dict[str, Any] = {
+        "server_name": si.get("serverName", ""),
+        "version": si.get("version", ""),
+        "build": si.get("build", ""),
+        "os": si.get("os_name", ""),
+        "cpu_arch": si.get("cpu_arch", ""),
+        "license_state": si.get("licenseState", ""),
+        "mode": si.get("mode", ""),
+        "guid": si.get("guid", ""),
+    }
+    output.render(ctx, row)

splunkctl/commands/inputs.py

@@ -0,0 +1,204 @@
+"""Data input commands — list, create, update, delete, enable, disable."""
+
+from typing import Any
+
+import click
+
+from splunkctl import guard, output
+from splunkctl.client import get_client
+
+VALID_KINDS = ("monitor", "tcp", "udp", "script", "http")
+
+
+def _input_row(inp: Any) -> dict[str, Any]:
+    content: dict[str, Any] = dict(inp.content)
+    return {
+        "name": inp.name,
+        "kind": inp.kind,
+        "disabled": content.get("disabled", ""),
+        "index": content.get("index", ""),
+        "sourcetype": content.get("sourcetype", ""),
+    }
+
+
+def _find_input(service: Any, name: str) -> Any:
+    for inp in service.inputs.list():
+        if inp.name == name:
+            return inp
+    return None
+
+
+@click.group("inputs")
+def inputs_group() -> None:
+    """Manage data inputs."""
+
+
+@inputs_group.command("list")
+@click.option(
+    "--kind",
+    type=click.Choice(VALID_KINDS),
+    default=None,
+    help="Filter by input kind.",
+)
+@click.pass_context
+def list_inputs(ctx: click.Context, *, kind: str | None) -> None:
+    """List data inputs."""
+    client = get_client(ctx)
+    rows = [_input_row(i) for i in client.service.inputs.list()]
+    if kind:
+        rows = [r for r in rows if r["kind"] == kind]
+    output.render(ctx, rows)
+
+
+@inputs_group.command()
+@click.argument("name")
+@click.pass_context
+def get(ctx: click.Context, *, name: str) -> None:
+    """Show details for a specific input."""
+    client = get_client(ctx)
+    inp = _find_input(client.service, name)
+    if inp is None:
+        output.error(f"Input not found: {name}")
+        ctx.exit(1)
+        return
+    row: dict[str, Any] = {"name": inp.name, "kind": inp.kind}
+    row.update(dict(inp.content))
+    output.render(ctx, row)
+
+
+@inputs_group.command()
+@click.option("--name", required=True, help="Input name/path.")
+@click.option(
+    "--kind",
+    required=True,
+    type=click.Choice(VALID_KINDS),
+    help="Input kind.",
+)
+@click.option("--index", default=None, help="Target index.")
+@click.option("--sourcetype", default=None, help="Source type.")
+@click.option("--disabled", is_flag=True, default=False, help="Create disabled.")
+@click.pass_context
+def create(
+    ctx: click.Context,
+    *,
+    name: str,
+    kind: str,
+    index: str | None,
+    sourcetype: str | None,
+    disabled: bool,
+) -> None:
+    """Create a new data input."""
+    kwargs: dict[str, Any] = {}
+    if index:
+        kwargs["index"] = index
+    if sourcetype:
+        kwargs["sourcetype"] = sourcetype
+    if disabled:
+        kwargs["disabled"] = True
+
+    details = f"kind={kind}"
+    if kwargs:
+        details += ", " + ", ".join(f"{k}={v}" for k, v in kwargs.items())
+
+    if not guard.check(ctx, f"Create input '{name}'", details=details):
+        return
+
+    client = get_client(ctx)
+    client.service.inputs.create(name, kind, **kwargs)
+    output.info(f"Created input: {name} ({kind})")
+
+
+@inputs_group.command()
+@click.argument("name")
+@click.option("--index", default=None, help="Target index.")
+@click.option("--sourcetype", default=None, help="Source type.")
+@click.option("--enabled/--disabled", default=None, help="Enable or disable.")
+@click.pass_context
+def update(
+    ctx: click.Context,
+    *,
+    name: str,
+    index: str | None,
+    sourcetype: str | None,
+    enabled: bool | None,
+) -> None:
+    """Update an existing data input."""
+    kwargs: dict[str, Any] = {}
+    if index is not None:
+        kwargs["index"] = index
+    if sourcetype is not None:
+        kwargs["sourcetype"] = sourcetype
+    if enabled is not None:
+        kwargs["disabled"] = not enabled
+
+    if not kwargs:
+        output.error("No update options provided.")
+        ctx.exit(1)
+        return
+
+    details = ", ".join(f"{k}={v}" for k, v in kwargs.items())
+    if not guard.check(ctx, f"Update input '{name}'", details=details):
+        return
+
+    client = get_client(ctx)
+    inp = _find_input(client.service, name)
+    if inp is None:
+        output.error(f"Input not found: {name}")
+        ctx.exit(1)
+        return
+    inp.update(**kwargs).refresh()
+    output.info(f"Updated input: {name}")
+
+
+@inputs_group.command()
+@click.argument("name")
+@click.pass_context
+def delete(ctx: click.Context, *, name: str) -> None:
+    """Delete a data input."""
+    if not guard.check(ctx, f"Delete input '{name}'"):
+        return
+
+    client = get_client(ctx)
+    inp = _find_input(client.service, name)
+    if inp is None:
+        output.error(f"Input not found: {name}")
+        ctx.exit(1)
+        return
+    inp.delete()
+    output.info(f"Deleted input: {name}")
+
+
+@inputs_group.command()
+@click.argument("name")
+@click.pass_context
+def enable(ctx: click.Context, *, name: str) -> None:
+    """Enable a disabled input."""
+    if not guard.check(ctx, f"Enable input '{name}'"):
+        return
+
+    client = get_client(ctx)
+    inp = _find_input(client.service, name)
+    if inp is None:
+        output.error(f"Input not found: {name}")
+        ctx.exit(1)
+        return
+    inp.enable()
+    output.info(f"Enabled input: {name}")
+
+
+@inputs_group.command()
+@click.argument("name")
+@click.pass_context
+def disable(ctx: click.Context, *, name: str) -> None:
+    """Disable an input."""
+    if not guard.check(ctx, f"Disable input '{name}'"):
+        return
+
+    client = get_client(ctx)
+    inp = _find_input(client.service, name)
+    if inp is None:
+        output.error(f"Input not found: {name}")
+        ctx.exit(1)
+        return
+    inp.disable()
+    output.info(f"Disabled input: {name}")