python-jcli 0.1.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

jcli/plugins/plugin.py

@@ -1,173 +0,0 @@
-"""Jenkins Plugin management commands."""
-
-from __future__ import annotations
-
-import click
-
-from jcli.cli_helpers import get_client, get_formatter
-from jcli.sdk.plugin import (
-    check_plugin_updates,
-    get_plugin,
-    install_plugins,
-    list_plugins,
-    uninstall_plugin,
-)
-
-
-def _parse_plugin_spec(spec: str) -> tuple[str, str | None]:
-    """Parse a plugin spec like 'git' or 'git@5.0.0'.
-
-    Returns:
-        (short_name, version_or_None)
-    """
-    if "@" in spec:
-        name, _, version = spec.partition("@")
-        return name, version
-    return spec, None
-
-
-# ------------------------------------------------------------------
-# Plugin command group
-# ------------------------------------------------------------------
-
-
-@click.group("plugin", help="Manage Jenkins plugins.")
-@click.pass_context
-def plugin_group(ctx):
-    """Plugin management commands."""
-
-
-@plugin_group.command("list")
-@click.pass_context
-def list_cmd(ctx):
-    """List installed Jenkins plugins."""
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-
-    try:
-        plugins = list_plugins(client)
-    except Exception as exc:
-        fmt.print_error(str(exc))
-        raise SystemExit(1)
-
-    if not plugins:
-        fmt.print_info("No plugins found.")
-        return
-
-    headers = ["Name", "Version", "Active", "Update"]
-    rows = [
-        [p.get("shortName", "?"), p.get("version", "?"),
-         "Yes" if p.get("active") else "No",
-         "Yes" if p.get("hasUpdate") else "No"]
-        for p in plugins
-    ]
-    fmt.print_table(headers, rows, title="Installed Plugins")
-
-
-@plugin_group.command("get")
-@click.argument("name")
-@click.pass_context
-def get_cmd(ctx, name):
-    """Show details for a single plugin."""
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-
-    try:
-        plugin = get_plugin(client, name)
-    except Exception as exc:
-        fmt.print_error(str(exc))
-        raise SystemExit(1)
-
-    # Display all fields in a vertical key-value table
-    headers = ["Field", "Value"]
-    rows = [[str(k), str(v)] for k, v in plugin.items()] if plugin else []
-    fmt.print_table(
-        headers,
-        rows,
-        title=f"Plugin: {plugin.get('shortName', name)}" if plugin else f"Plugin {name}",
-    )
-
-
-@plugin_group.command("install")
-@click.argument("plugin_spec")
-@click.pass_context
-def install_cmd(ctx, plugin_spec):
-    """Install a Jenkins plugin.
-
-    PLUGIN_SPEC can be just a plugin name (e.g. 'git') or
-    name@version (e.g. 'git@5.0.0') to install a specific version.
-    """
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-
-    name, version = _parse_plugin_spec(plugin_spec)
-    plugins_dict: dict[str, str | None] = {name: version}
-
-    try:
-        install_plugins(client, plugins_dict)
-    except Exception as exc:
-        fmt.print_error(str(exc))
-        raise SystemExit(1)
-
-    msg = f"Plugin '{name}' installed successfully"
-    if version:
-        msg += f" (version {version})"
-    fmt.print_success(msg)
-
-
-@plugin_group.command("uninstall")
-@click.argument("name")
-@click.pass_context
-def uninstall_cmd(ctx, name):
-    """Uninstall a Jenkins plugin.
-
-    The plugin is scheduled for removal; a server restart is typically
-    required to complete the uninstall.
-    """
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-
-    try:
-        uninstall_plugin(client, name)
-    except Exception as exc:
-        fmt.print_error(str(exc))
-        raise SystemExit(1)
-
-    fmt.print_success(f"Plugin '{name}' scheduled for uninstall (restart may be required)")
-
-
-@plugin_group.command("check-updates")
-@click.pass_context
-def check_updates_cmd(ctx):
-    """Check for available plugin updates."""
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-    try:
-        result = check_plugin_updates(client)
-        fmt.print_info("Plugin update check triggered. Run 'jcli plugin list' to see results.")
-        if isinstance(result, dict) and result:
-            fmt.print_json(result)
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-@plugin_group.command("restart")
-@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt.")
-@click.pass_context
-def restart_cmd(ctx, yes):
-    """Restart Jenkins after plugin changes."""
-    if not yes:
-        click.confirm("Restart Jenkins server?", abort=True)
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-    try:
-        from jcli.sdk.system import safe_restart
-        safe_restart(client)
-        fmt.print_success("Jenkins restart initiated.")
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-def register(parent_group):
-    """Register the plugin subgroup under the parent Click group."""
-    parent_group.add_command(plugin_group)

jcli/plugins/system.py

@@ -1,173 +0,0 @@
-"""Jenkins System management commands."""
-
-import logging
-
-import click
-
-from jcli.cli_helpers import get_client, get_formatter
-from jcli.sdk.client import JenkinsClient
-from jcli.sdk.config import Config
-from jcli.sdk.exceptions import JenkinsConfigError
-from jcli.sdk.system import (
-    cancel_quiet_down,
-    generate_token,
-    get_system_info,
-    get_system_load,
-    list_users,
-    quiet_down,
-    run_script,
-    safe_restart,
-)
-
-logger = logging.getLogger(__name__)
-
-
-@click.group("system", help="Jenkins system information and management.")
-def system_group():
-    """System management commands."""
-
-
-@system_group.command("info")
-@click.pass_context
-def system_info(ctx: click.Context):
-    """Show Jenkins system information."""
-    formatter = get_formatter(ctx)
-    client = get_client(ctx)
-
-    info = get_system_info(client)
-
-    formatter.print_info(f"Jenkins {info['version']}")
-    formatter.print_info(f"Mode: {info['mode']}")
-    formatter.print_info(f"Quieting down: {info['quietingDown']}")
-
-    rows = [
-        ("Executors", str(info["num_executors"])),
-        ("Nodes", str(info["num_nodes"])),
-        ("Jobs", str(info["num_jobs"])),
-        ("Slave Agent Port", str(info["slaveAgentPort"])),
-    ]
-    formatter.print_table(
-        headers=("Property", "Value"),
-        rows=rows,
-        title="System Overview",
-    )
-
-
-@system_group.command("restart")
-@click.pass_context
-def system_restart(ctx: click.Context):
-    """Trigger a safe restart of Jenkins."""
-    formatter = get_formatter(ctx)
-    client = get_client(ctx)
-
-    if safe_restart(client):
-        formatter.print_success("Safe restart initiated.")
-    else:
-        formatter.print_error("Failed to initiate safe restart.")
-
-
-@system_group.command("quiet-down")
-@click.option("--reason", "-r", default="", help="Reason for quiet-down.")
-@click.pass_context
-def system_quiet_down(ctx: click.Context, reason: str):
-    """Put Jenkins into quiet-down mode."""
-    formatter = get_formatter(ctx)
-    client = get_client(ctx)
-
-    if quiet_down(client, reason=reason):
-        formatter.print_success("Jenkins is now in quiet-down mode.")
-        if reason:
-            formatter.print_info(f"Reason: {reason}")
-    else:
-        formatter.print_error("Failed to enter quiet-down mode.")
-
-
-@system_group.command("cancel-quiet-down")
-@click.pass_context
-def system_cancel_quiet_down(ctx: click.Context):
-    """Cancel quiet-down mode."""
-    formatter = get_formatter(ctx)
-    client = get_client(ctx)
-
-    if cancel_quiet_down(client):
-        formatter.print_success("Quiet-down mode cancelled.")
-    else:
-        formatter.print_error("Failed to cancel quiet-down mode.")
-
-
-@system_group.command("load")
-@click.pass_context
-def system_load(ctx: click.Context):
-    """Show current system load (queue length, executor usage)."""
-    formatter = get_formatter(ctx)
-    client = get_client(ctx)
-
-    load = get_system_load(client)
-
-    rows = [
-        ("Queue Length", str(load["queue_length"])),
-        ("Total Executors", str(load["total_executors"])),
-        ("Busy Executors", str(load["busy_executors"])),
-        ("Idle Executors", str(load["idle_executors"])),
-    ]
-    formatter.print_table(
-        headers=("Metric", "Value"),
-        rows=rows,
-        title="System Load",
-    )
-
-
-@system_group.command("script")
-@click.argument("script")
-@click.pass_context
-def script_cmd(ctx: click.Context, script: str):
-    """Execute a Groovy script on the Jenkins server.
-
-    SCRIPT is the Groovy script text to execute.
-    """
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-    try:
-        result = run_script(client, script)
-        print(result)
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-@system_group.command("users")
-@click.pass_context
-def users_cmd(ctx: click.Context):
-    """List all Jenkins users."""
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-    try:
-        data = list_users(client)
-        users = data.get("users", [])
-        if not users:
-            fmt.print_info("No users found.")
-            return
-        user_ids = [u["user"]["fullName"] for u in users]
-        fmt.print_json(user_ids)
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-@system_group.command("token")
-@click.argument("username")
-@click.option("--name", "-n", default="jcli-generated", help="Token name/label.")
-@click.pass_context
-def token_cmd(ctx: click.Context, username: str, name: str):
-    """Generate a new API token for a user."""
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-    try:
-        result = generate_token(client, username, token_name=name)
-        fmt.print_json(result)
-        fmt.print_success(f"Token generated for user '{username}'.")
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-def register(parent_group):
-    """Register the system subgroup under the parent Click group."""
-    parent_group.add_command(system_group)

jcli/plugins/view.py

@@ -1,148 +0,0 @@
-"""Jenkins View management commands."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import click
-
-from jcli.cli_helpers import get_client, get_formatter
-from jcli.sdk.view import create_view as sdk_create_view
-from jcli.sdk.view import delete_view as sdk_delete_view
-from jcli.sdk.view import get_view as sdk_get_view
-from jcli.sdk.view import list_views as sdk_list_views
-from jcli.sdk.view import update_view as sdk_update_view
-
-
-def _format_output(ctx: click.Context, data: object) -> str:
-    """Format data according to the user-specified output format."""
-    ctx_obj = ctx.obj or {}
-    fmt = ctx_obj.get("format", "table")
-
-    if fmt == "json":
-        return json.dumps(data, indent=2, ensure_ascii=False)
-
-    if fmt == "yaml":
-        import yaml
-
-        return yaml.dump(data, default_flow_style=False, allow_unicode=True)
-
-    # Default: table-like plain text
-    return str(data)
-
-
-# ------------------------------------------------------------------
-# Click command group
-# ------------------------------------------------------------------
-
-
-@click.group("view", help="Manage Jenkins views.")
-def view_group():
-    """View management commands."""
-
-
-@view_group.command("list")
-@click.pass_context
-def view_list(ctx: click.Context) -> None:
-    """List all Jenkins views."""
-    client = get_client(ctx)
-    views = sdk_list_views(client)
-
-    # Build table output
-    ctx_obj = ctx.obj or {}
-    if ctx_obj.get("format", "table") == "table":
-        if not views:
-            click.echo("No views found.")
-            return
-        for v in views:
-            job_count = len(v.get("jobs", []))
-            click.echo(f"  {v['name']} ({job_count} jobs)")
-        return
-
-    click.echo(_format_output(ctx, views))
-
-
-@view_group.command("get")
-@click.argument("view_name", metavar="NAME")
-@click.pass_context
-def view_get(ctx: click.Context, view_name: str) -> None:
-    """Get details for a Jenkins view."""
-    client = get_client(ctx)
-    data = sdk_get_view(client, view_name)
-
-    # Table output: show key fields
-    ctx_obj = ctx.obj or {}
-    if ctx_obj.get("format", "table") == "table":
-        click.echo(f"Name:        {data.get('name', view_name)}")
-        click.echo(f"URL:         {data.get('url', '')}")
-        click.echo(f"Description: {data.get('description', '')}")
-        jobs = data.get("jobs", [])
-        if jobs:
-            click.echo("Jobs:")
-            for j in jobs:
-                click.echo(f"  - {j['name']}  [{j.get('color', 'unknown')}]")
-        return
-
-    click.echo(_format_output(ctx, data))
-
-
-@view_group.command("create")
-@click.argument("view_name", metavar="NAME")
-@click.argument(
-    "config_file",
-    metavar="CONFIG_XML",
-    type=click.Path(exists=True, dir_okay=False, path_type=Path),
-)
-@click.pass_context
-def view_create(ctx: click.Context, view_name: str, config_file: Path) -> None:
-    """Create a new Jenkins view from an XML config file."""
-    xml_data = config_file.read_text(encoding="utf-8")
-
-    client = get_client(ctx)
-    sdk_create_view(client, view_name, xml_data)
-    click.echo(f"View '{view_name}' created successfully.")
-
-
-@view_group.command("update")
-@click.argument("view_name")
-@click.argument("config_file", type=click.Path(exists=True, dir_okay=False))
-@click.pass_context
-def update_view_cmd(ctx, view_name, config_file):
-    """Update a view's configuration from an XML file."""
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-    try:
-        with open(config_file, "r", encoding="utf-8") as f:
-            config_xml = f.read()
-        sdk_update_view(client, view_name, config_xml)
-        fmt.print_success(f"View '{view_name}' updated.")
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-@view_group.command("delete")
-@click.argument("view_name", metavar="NAME")
-@click.option(
-    "--yes",
-    "-y",
-    is_flag=True,
-    help="Skip confirmation prompt.",
-)
-@click.pass_context
-def view_delete(ctx: click.Context, view_name: str, yes: bool) -> None:
-    """Delete a Jenkins view."""
-    if not yes:
-        click.confirm(
-            f"Are you sure you want to delete view '{view_name}'?",
-            abort=True,
-        )
-
-    client = get_client(ctx)
-    sdk_delete_view(client, view_name)
-    click.echo(f"View '{view_name}' deleted successfully.")
-
-
-def register(parent_group: click.Group) -> None:
-    """Register the view subgroup under the parent Click group."""
-    parent_group.add_command(view_group)

jcli/sdk/build.py

@@ -1,182 +0,0 @@
-"""Jenkins Build SDK — trigger, query, stop builds and manage queue."""
-
-from __future__ import annotations
-
-import time
-import urllib.parse
-from typing import Any
-
-from jcli.sdk.client import JenkinsClient
-from jcli.sdk.exceptions import JenkinsError
-
-
-def _job_path(job_name: str) -> str:
-    """Convert a job name to a Jenkins URL path segment.
-
-    Handles nested jobs (folder/sub-job) by converting each slash-separated
-    segment into ``/job/<segment>``.
-    """
-    segments = job_name.split("/")
-    return "/job/" + "/job/".join(segments)
-
-
-def trigger_build(
-    client: JenkinsClient,
-    job_name: str,
-    params: dict[str, Any] | None = None,
-) -> dict[str, Any]:
-    """Trigger a new build for the given job.
-
-    If *params* is provided the build is triggered with parameters via
-    ``/buildWithParameters``, otherwise a plain ``/build`` is used.
-    Jenkins returns a ``Location`` header pointing to the queued item.
-    This function follows that redirect and parses the queue-item JSON.
-
-    :returns: Queue item info as returned by Jenkins (dict).
-    """
-    path = _job_path(job_name)
-    if params:
-        url = f"{path}/buildWithParameters"
-        resp = client.request("POST", url, params=params, allow_redirects=False)
-    else:
-        url = f"{path}/build"
-        resp = client.request("POST", url, allow_redirects=False)
-
-    # Jenkins responds with 201 Created or 302 Found and a Location header
-    # pointing to the queue item.  Follow that URL to get the queue item JSON.
-    location = resp.headers.get("Location")
-    if location:
-        queue_path = urllib.parse.urlparse(location).path
-        # Strip the base URL prefix — client.get_json accepts an absolute path
-        if queue_path.startswith(client.base_url):
-            queue_path = queue_path[len(client.base_url) :]
-        try:
-            return client.get_json(queue_path + "api/json")
-        except JenkinsError:
-            pass
-
-    # Fallback — return a minimal dict
-    return {"status": "queued", "url": location or ""}
-
-
-def get_build(
-    client: JenkinsClient,
-    job_name: str,
-    number: int,
-) -> dict[str, Any]:
-    """Get details for a specific build.
-
-    :returns: Build details as returned by the Jenkins API.
-    """
-    path = f"{_job_path(job_name)}/{number}"
-    return client.get_json(f"{path}/api/json")
-
-
-def get_builds(
-    client: JenkinsClient,
-    job_name: str,
-    limit: int = 10,
-) -> list[dict[str, Any]]:
-    """List recent builds for a job.
-
-    :param limit: Maximum number of builds to return (applied client-side).
-    :returns: List of build dicts (trimmed to *limit*).
-    """
-    path = _job_path(job_name)
-    tree = f"builds[number,url,result,timestamp,duration,building]{f'{{{0},{limit - 1}}}' if limit > 0 else ''}"
-    data = client.get_json(f"{path}/api/json", tree=tree)
-    builds: list[dict[str, Any]] = data.get("builds", [])
-    return builds[:limit]
-
-
-def get_build_log(
-    client: JenkinsClient,
-    job_name: str,
-    number: int,
-    start: int = 0,
-) -> str:
-    """Retrieve the console log for a build.
-
-    :param start: Byte offset to start reading from (useful for polling).
-    :returns: Console log text.
-    """
-    path = f"{_job_path(job_name)}/{number}/consoleText"
-    resp = client.request("GET", path)
-    text = resp.text
-    if start > 0:
-        return text[start:]
-    return text
-
-
-def stop_build(
-    client: JenkinsClient,
-    job_name: str,
-    number: int,
-) -> dict[str, Any]:
-    """Stop (abort) a running build.
-
-    :returns: Empty dict on success.
-    """
-    path = f"{_job_path(job_name)}/{number}"
-    client.request("POST", f"{path}/stop")
-    return {}
-
-
-def get_queue(client: JenkinsClient) -> list[dict[str, Any]]:
-    """Return all items currently in the Jenkins build queue.
-
-    :returns: List of queue item dicts.
-    """
-    data = client.get_json("/queue/api/json")
-    return data.get("items", [])
-
-
-def cancel_queue_item(
-    client: JenkinsClient,
-    queue_id: int,
-) -> dict[str, Any]:
-    """Cancel a queued item.
-
-    :param queue_id: Numeric queue item ID.
-    :returns: Empty dict on success.
-    """
-    client.request("POST", "/queue/cancelItem", params={"id": queue_id})
-    return {}
-
-
-def get_build_artifacts(
-    client: JenkinsClient,
-    job_name: str,
-    build_number: int | str,
-) -> Any:
-    """Get build artifacts.
-
-    Lists artifacts produced by a build.
-    """
-    path = _job_path(job_name) + f"/{build_number}/api/json"
-    return client.get_json(path, tree="artifacts[fileName,relativePath]")
-
-
-def wait_for_build(
-    client: JenkinsClient,
-    job_name: str,
-    number: int,
-    timeout: int = 600,
-    poll_interval: int = 2,
-) -> dict[str, Any]:
-    """Poll until a build completes or *timeout* is reached.
-
-    :param timeout: Maximum seconds to wait.
-    :param poll_interval: Seconds between status checks.
-    :returns: Final build dict.
-    :raises TimeoutError: if the build does not finish within *timeout*.
-    """
-    deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
-        build = get_build(client, job_name, number)
-        if not build.get("building", False):
-            return build
-        time.sleep(poll_interval)
-    raise TimeoutError(
-        f"Build {job_name}#{number} did not complete within {timeout}s"
-    )