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

jcli/plugins/node.py

@@ -1,134 +0,0 @@
-"""Jenkins Node management commands."""
-
-from __future__ import annotations
-
-import click
-
-from jcli.cli_helpers import get_client, get_formatter
-from jcli.sdk.node import create_node, delete_node, get_node, list_nodes, toggle_offline
-
-
-@click.group("node", help="Manage Jenkins nodes (agents).")
-def node_group():
-    """Node management commands."""
-
-
-@node_group.command("list")
-@click.pass_context
-def list_nodes_cmd(ctx: click.Context):
-    """List all Jenkins nodes."""
-    fmt = get_formatter(ctx)
-    client = get_client(ctx)
-
-    try:
-        nodes = list_nodes(client)
-        if nodes:
-            headers = ["Name", "Online", "Temporarily Offline", "Architecture"]
-            rows = [
-                [
-                    n.get("displayName", "?"),
-                    "Yes" if not n.get("offline", True) else "No",
-                    "Yes" if n.get("temporarilyOffline", False) else "No",
-                    n.get("monitorData", {}).get("hudson.node_monitors.ArchitectureMonitor", "?"),
-                ]
-                for n in nodes
-            ]
-            fmt.print_table(headers, rows, title="Jenkins Nodes")
-        else:
-            fmt.print_info("No nodes found.")
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-@node_group.command("get")
-@click.argument("name")
-@click.pass_context
-def get_node_cmd(ctx: click.Context, name: str):
-    """Get details of a specific node."""
-    fmt = get_formatter(ctx)
-    client = get_client(ctx)
-
-    try:
-        node = get_node(client, name)
-        if fmt.format_type == "json":
-            fmt.print_json(node)
-        else:
-            headers = ["Property", "Value"]
-            rows = [
-                ["Display Name", node.get("displayName", "?")],
-                ["Description", node.get("description", "") or "-"],
-                ["Offline", "Yes" if node.get("offline", True) else "No"],
-                ["Temporarily Offline", "Yes" if node.get("temporarilyOffline", False) else "No"],
-                ["Num Executors", str(node.get("numExecutors", "?"))],
-                ["Idle", "Yes" if node.get("idle", False) else "No"],
-                ["JNLP Agent", "Yes" if node.get("jnlpAgent", False) else "No"],
-            ]
-            # Add monitor data if available
-            monitor = node.get("monitorData", {})
-            if monitor:
-                for key, val in monitor.items():
-                    if key.startswith("hudson.node_monitors."):
-                        label = key.replace("hudson.node_monitors.", "")
-                        rows.append([f"Monitor: {label}", str(val)])
-            fmt.print_table(headers, rows, title=f"Node: {name}")
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-@node_group.command("delete")
-@click.argument("name")
-@click.option("--force", "-f", is_flag=True, help="Skip confirmation prompt.")
-@click.pass_context
-def delete_node_cmd(ctx: click.Context, name: str, force: bool):
-    """Delete a Jenkins node (agent)."""
-    fmt = get_formatter(ctx)
-    client = get_client(ctx)
-
-    if not force:
-        if not click.confirm(f"Are you sure you want to delete node '{name}'?"):
-            fmt.print_info("Delete cancelled.")
-            return
-
-    try:
-        delete_node(client, name)
-        fmt.print_success(f"Node '{name}' deleted successfully.")
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-@node_group.command("toggle")
-@click.argument("name")
-@click.option("--message", "-m", default="", help="Reason for toggling offline/online.")
-@click.pass_context
-def toggle_node_cmd(ctx: click.Context, name: str, message: str):
-    """Toggle a node offline or online."""
-    fmt = get_formatter(ctx)
-    client = get_client(ctx)
-
-    try:
-        toggle_offline(client, name, msg=message)
-        fmt.print_success(f"Node '{name}' toggled successfully.")
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-@node_group.command("create")
-@click.argument("name")
-@click.option("--executors", type=int, default=1, help="Number of executors (default: 1).")
-@click.option("--remote-fs", default="/tmp", help="Remote filesystem root (default: /tmp).")
-@click.option("--labels", default="", help="Node labels.")
-@click.pass_context
-def create_node_cmd(ctx: click.Context, name: str, executors: int, remote_fs: str, labels: str):
-    """Create a new Jenkins agent node."""
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-    try:
-        create_node(client, name, num_executors=executors, remote_fs=remote_fs, labels=labels)
-        fmt.print_success(f"Node '{name}' created.")
-    except Exception as exc:
-        fmt.print_error(str(exc))
-
-
-def register(parent_group):
-    """Register the node subgroup under the parent Click group."""
-    parent_group.add_command(node_group)

jcli/plugins/pipeline.py

@@ -1,108 +0,0 @@
-"""Jenkins Pipeline management commands."""
-
-import click
-
-from jcli.cli_helpers import get_client, get_formatter
-from jcli.sdk.exceptions import (
-    JenkinsAPIError,
-    JenkinsAuthError,
-    JenkinsConnectionError,
-    JenkinsNotFoundError,
-)
-from jcli.sdk.pipeline import (
-    get_pending_input,
-    get_pipeline_log,
-    get_pipeline_stages,
-    validate_jenkinsfile,
-)
-
-
-@click.group("pipeline", help="Manage Jenkins pipelines.")
-def pipeline_group():
-    """Pipeline management commands."""
-
-
-@pipeline_group.command("stages")
-@click.argument("job_name")
-@click.argument("build_number")
-@click.pass_context
-def stages(ctx, job_name, build_number):
-    """List stages for a Pipeline build.
-
-    JOB_NAME is the Pipeline job name.
-    BUILD_NUMBER is the build number to query.
-    """
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-
-    try:
-        result = get_pipeline_stages(client, job_name, build_number)
-        fmt.print_json(result)
-    except (JenkinsNotFoundError, JenkinsAuthError, JenkinsConnectionError, JenkinsAPIError) as exc:
-        fmt.print_error(str(exc))
-
-
-@pipeline_group.command("log")
-@click.argument("job_name")
-@click.argument("build_number")
-@click.argument("node_id")
-@click.pass_context
-def log(ctx, job_name, build_number, node_id):
-    """Get log output for a Pipeline step.
-
-    JOB_NAME is the Pipeline job name.
-    BUILD_NUMBER is the build number to query.
-    NODE_ID is the flow node ID from stage/step info.
-    """
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-
-    try:
-        result = get_pipeline_log(client, job_name, build_number, node_id)
-        fmt.print_json(result)
-    except (JenkinsNotFoundError, JenkinsAuthError, JenkinsConnectionError, JenkinsAPIError) as exc:
-        fmt.print_error(str(exc))
-
-
-@pipeline_group.command("validate")
-@click.argument("file_path", type=click.Path(exists=True, dir_okay=False))
-@click.pass_context
-def validate(ctx, file_path):
-    """Validate a Jenkinsfile against the Jenkins server.
-
-    FILE_PATH is the path to the Jenkinsfile to validate.
-    """
-    with open(file_path, "r", encoding="utf-8") as f:
-        content = f.read()
-
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-
-    result = validate_jenkinsfile(client, content)
-
-    fmt.print_json(result)
-
-
-@pipeline_group.command("pending")
-@click.argument("job_name")
-@click.argument("build_number")
-@click.pass_context
-def pending(ctx, job_name, build_number):
-    """Show pending input actions for a Pipeline build.
-
-    JOB_NAME is the Pipeline job name.
-    BUILD_NUMBER is the build number to query.
-    """
-    client = get_client(ctx)
-    fmt = get_formatter(ctx)
-
-    try:
-        result = get_pending_input(client, job_name, build_number)
-        fmt.print_json(result)
-    except (JenkinsNotFoundError, JenkinsAuthError, JenkinsConnectionError, JenkinsAPIError) as exc:
-        fmt.print_error(str(exc))
-
-
-def register(parent_group):
-    """Register the pipeline subgroup under the parent Click group."""
-    parent_group.add_command(pipeline_group)

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)