jenkinsctl 0.0.8__tar.gz → 1.0.0__tar.gz

{jenkinsctl-0.0.8 → jenkinsctl-1.0.0}/PKG-INFO

@@ -1,24 +1,35 @@
 Metadata-Version: 2.1
 Name: jenkinsctl
-Version: 0.0.8
-Summary: Build Jenkins jobs effortlessly using a single command. 🚀
-Author-email: Aman Shaw <amanshaw4511@protonmail.com>
-Project-URL: Homepage, https://github.com/amanshaw4511/jenkinsctl
-Project-URL: Repository, https://github.com/amanshaw4511/jenkinsctl
-Project-URL: Issues, https://github.com/amanshaw4511/jenkinsctl/issues
+Version: 1.0.0
+Summary: A command-line tool to interact with Jenkins jobs 🚀
+Home-page: https://github.com/amanshaw4511/jenkinsctl
+License: GPL-3.0-or-later
 Keywords: jenkins,jenkin
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Author: Aman Shaw
+Author-email: amanshaw4511@protonmail.com
+Maintainer: Aman Shaw
+Maintainer-email: amanshaw4511@protonmail.com
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: click-completion (>=0.5.2,<0.6.0)
+Requires-Dist: dynaconf (>=3.2.6,<4.0.0)
+Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: rich (>=13.8.1,<14.0.0)
+Project-URL: Repository, https://github.com/amanshaw4511/jenkinsctl
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: api4jenkins
-Requires-Dist: dynaconf
-Requires-Dist: pyyaml
-Requires-Dist: argcomplete
 
-# jenkinsctl
+![jenkinsctl](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e9/Jenkins_logo.svg/226px-Jenkins_logo.svg.png?20120629215426)
+# jenkinsctl [![PyPI version](https://badge.fury.io/py/jenkinsctl.svg?)](https://badge.fury.io/py/jenkinsctl) [![Downloads](https://static.pepy.tech/badge/jenkinsctl/week?)](https://pepy.tech/project/jenkinsctl) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 Build Jenkins jobs effortlessly using a single command. 🚀
 
 ## Installation 📦
@@ -37,6 +48,7 @@ export JENKINS_API_KEY=21df49caf41726094323b803a6de363eae
 ```
 Adjust the values to match your Jenkins server's URL, your username, and the corresponding API key. This configuration is essential for jenkinsctl to interact with Jenkins and execute tasks efficiently.
 
+How to Get the API Token: https://www.baeldung.com/ops/jenkins-api-token
 ## Usage 🤖
 ```sh
 $ jenkinsctl --help
@@ -112,3 +124,4 @@ To generate a YAML configuration file from a specific build (e.g. 2nd build) of
 ```sh
 jenkinsctl config my_job 2 > my_job.yaml
 ```
+

{jenkinsctl-0.0.8 → jenkinsctl-1.0.0}/README.md

@@ -1,4 +1,5 @@
-# jenkinsctl
+![jenkinsctl](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e9/Jenkins_logo.svg/226px-Jenkins_logo.svg.png?20120629215426)
+# jenkinsctl [![PyPI version](https://badge.fury.io/py/jenkinsctl.svg?)](https://badge.fury.io/py/jenkinsctl) [![Downloads](https://static.pepy.tech/badge/jenkinsctl/week?)](https://pepy.tech/project/jenkinsctl) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 Build Jenkins jobs effortlessly using a single command. 🚀
 
 ## Installation 📦
@@ -17,6 +18,7 @@ export JENKINS_API_KEY=21df49caf41726094323b803a6de363eae
 ```
 Adjust the values to match your Jenkins server's URL, your username, and the corresponding API key. This configuration is essential for jenkinsctl to interact with Jenkins and execute tasks efficiently.
 
+How to Get the API Token: https://www.baeldung.com/ops/jenkins-api-token
 ## Usage 🤖
 ```sh
 $ jenkinsctl --help

jenkinsctl-1.0.0/jenkinsctl/cli.py

@@ -0,0 +1,158 @@
+import logging
+from io import TextIOWrapper
+from typing import Optional
+
+import click
+import click_completion
+
+from jenkinsctl.commands.build import build_handler
+from jenkinsctl.commands.config import config_handler
+from jenkinsctl.commands.enable_completion import handle_enable_completion
+from jenkinsctl.commands.jobs import jobs_handler
+from jenkinsctl.commands.json import json_handler
+from jenkinsctl.commands.list import list_handler
+from jenkinsctl.commands.logs import logs_handler
+from jenkinsctl.commands.rebuild import rebuild_handler
+from jenkinsctl.configs.logging_config import setup_logging
+from jenkinsctl.jenkins.cli_helper import error_handler_and_session
+
+click_completion.init()
+
+
+@click.group()
+@click.option('-v', '--verbose', is_flag=True, help="Enable verbose output")
+@click.pass_context
+def cli(ctx: click.Context, verbose: bool) -> None:
+    """A command-line tool to interact with Jenkins jobs"""
+    log_level: int = logging.DEBUG if verbose else logging.INFO
+    ctx.logger = setup_logging(log_level)
+
+
+@cli.command("list")
+@click.argument("job_name")
+@click.option("-n", "--number", default=5, type=int, help="No of builds to list (default: 5)")
+def list_command(job_name: str, number: int) -> None:
+    """
+    List all builds of a Jenkins job
+
+    \b
+    JOB_NAME: Name of the Jenkins job
+    """
+    with error_handler_and_session() as session:
+        list_handler(session, job_name, number)
+
+
+@cli.command("logs")
+@click.argument("job_name")
+@click.argument("build_no", required=False, type=int)
+def logs_command(job_name: str, build_no: Optional[int]) -> None:
+    """
+    Print logs of a Jenkins build
+
+    \b
+    JOB_NAME: Name of the Jenkins job
+    BUILD_NO: Build number (default: last build)
+    """
+    with error_handler_and_session() as session:
+        logs_handler(session, job_name, build_no)
+
+
+@cli.command("json")
+@click.argument("job_name")
+@click.argument("build_no", required=False, type=int)
+def json_command(job_name: str, build_no: Optional[int]) -> None:
+    """
+    Fetch and print the JSON API response of a Jenkins build
+
+    \b
+    JOB_NAME: Name of the Jenkins job
+    BUILD_NO: Build number (default: last build)
+    """
+    with error_handler_and_session() as session:
+        json_handler(session, job_name, build_no)
+
+
+@cli.command("config")
+@click.argument("job_name")
+@click.argument("build_no", required=False, type=int)
+def config_command(job_name: str, build_no: Optional[int]) -> None:
+    """
+    Get the configuration of a specific build in YAML format
+
+    \b
+    JOB_NAME: Name of the Jenkins job
+    BUILD_NO: Build number (default: last build)
+    """
+    with error_handler_and_session() as session:
+        config_handler(session, job_name, build_no)
+
+
+@cli.command("rebuild")
+@click.argument("job_name")
+@click.argument("build_no", required=False, type=int)
+def rebuild_command(job_name: str, build_no: Optional[int]) -> None:
+    """
+    Rebuild a specific Jenkins job
+
+    \b
+    JOB_NAME: Name of the Jenkins job
+    BUILD_NO: Build number (default: last build)
+    """
+    with error_handler_and_session() as session:
+        rebuild_handler(session, job_name, build_no)
+
+
+@cli.command("build")
+@click.option("-p", "--param", multiple=True,
+              help="Override parameters in the YAML configuration (e.g., --param key=value)")
+@click.option("-f", "--file", type=click.File('r'), required=True, help="YAML configuration file for the Jenkins job")
+def build_command(file: TextIOWrapper, param: tuple[str]) -> None:
+    """
+    Trigger a new Jenkins build
+    """
+    params = [p for p in param]
+    with error_handler_and_session() as session:
+        build_handler(session, file, params)
+
+
+@cli.command("enable-completion")
+@click.argument('shell', required=False)
+def enable_completion(shell: str):
+    """
+    Enable shell autocompletion for jenkinsctl.
+
+    This command allows you to set up autocompletion for the jenkinsctl command-line tool,
+    making it easier to use by providing suggestions as you type.
+
+    \b
+    SHELL: Specify a shell for which to enable autocompletion.
+    Supported options include:
+      - bash
+      - zsh
+      - fish
+
+    If no shell is specified, it will attempt to autodetect your shell.
+    """
+    if shell is None:
+        shell = click_completion.core.get_auto_shell()  # Detect the current shell
+
+    handle_enable_completion(shell)
+
+
+@cli.command("jobs")
+@click.argument("folder_name", default="")
+def jobs_command(folder_name: str) -> None:
+    """
+        List all jobs in a Jenkins folder.
+
+        \b
+        FOLDER_NAME: Path of the folder to list jobs (e.g., projectA/subProjectX).
+                     If no folder is specified, it lists jobs in the root folder.
+    """
+    with error_handler_and_session() as session:
+        jobs_handler(session, folder_name)
+
+
+# Entry point
+if __name__ == '__main__':
+    cli()

jenkinsctl-1.0.0/jenkinsctl/commands/build.py

@@ -0,0 +1,46 @@
+import logging
+import sys
+from io import TextIOWrapper
+from typing import List
+
+import yaml
+
+from jenkinsctl.configs.session import Session
+from jenkinsctl.jenkins.console_util import json_preety
+from jenkinsctl.jenkins.job import build_job
+
+log = logging.getLogger(__name__)
+
+
+def get_config_from_yaml(file):
+    config_data = None
+    try:
+        with open(file.name, "r") as config_file:
+            config_data = yaml.safe_load(config_file)  # Use safe_load for YAML
+    except FileNotFoundError:
+        print(f"Error: Configuration file '{file}' not found.")
+        sys.exit()
+    except yaml.YAMLError as e:
+        print(f"Error: Invalid YAML format in '{file}': {e}")
+        sys.exit()
+
+    return config_data
+
+
+def get_conf(file, params):
+    config = get_config_from_yaml(file)
+    override_params(params, config)
+    return config
+
+
+def override_params(params, file_config):
+    for param in params:
+        name, value = param.split('=')
+        file_config['params'][name] = value
+
+
+def build_handler(session: Session, file: TextIOWrapper, params: List[str]):
+    conf = get_conf(file, params)
+    log.debug(f"config: {json_preety(conf)}")
+    location = build_job(session, conf["job"], conf["params"])
+    print(location)

jenkinsctl-1.0.0/jenkinsctl/commands/config.py

@@ -0,0 +1,15 @@
+from typing import Optional
+
+from jenkinsctl.configs.session import Session
+from jenkinsctl.jenkins.commons import get_last_build_no_if_none
+from jenkinsctl.jenkins.job import get_build
+from jenkinsctl.jenkins.utils import get_build_params, to_yaml, normalize_job_path
+
+
+def config_handler(session: Session, job_name: str, build_no: Optional[int]):
+    job_name = normalize_job_path(job_name)
+    build_no = get_last_build_no_if_none(session, job_name, build_no)
+
+    build = get_build(session, job_name, build_no)
+    params = get_build_params(build)
+    print(to_yaml(job_name, params))

jenkinsctl-1.0.0/jenkinsctl/commands/enable_completion.py

@@ -0,0 +1,22 @@
+def handle_enable_completion(shell: str):
+    if shell == "bash":
+        print("\n# To enable autocompletion for bash, add the following to your ~/.bashrc:")
+        print("echo 'eval \"$(_JENKINSCTL_COMPLETE=bash_source jenkinsctl)\"' >> ~/.bashrc")
+        print("\n# Then reload your bash configuration:")
+        print("source ~/.bashrc")
+
+    elif shell == "zsh":
+        print("\n# To enable autocompletion for zsh, add the following to your ~/.zshrc:")
+        print("echo 'eval \"$(_JENKINSCTL_COMPLETE=zsh_source jenkinsctl)\"' >> ~/.zshrc")
+        print("\n# Then reload your zsh configuration:")
+        print("source ~/.zshrc")
+
+    elif shell == "fish":
+        print(
+            "\n# To enable autocompletion for fish, add the following to your Fish config (~/.config/fish/config.fish):")
+        print("echo 'eval (jenkinsctl enable-completion fish | source)' >> ~/.config/fish/config.fish")
+        print("\n# Then reload your fish shell configuration:")
+        print("source ~/.config/fish/config.fish")
+
+    else:
+        print("\n# Unsupported shell. Please specify bash, zsh, or fish.")

jenkinsctl-1.0.0/jenkinsctl/commands/jobs.py

@@ -0,0 +1,18 @@
+from jenkinsctl.configs.session import Session
+from jenkinsctl.jenkins.job import get_jobs
+from jenkinsctl.jenkins.utils import normalize_job_path
+
+
+def jobs_handler(session: Session, folder_name: str):
+    folder_name = normalize_job_path(folder_name)
+    response = get_jobs(session, folder_name)
+    all_jobs = response["jobs"]
+
+    folders = [job for job in all_jobs if job["_class"] == "com.cloudbees.hudson.plugins.folder.Folder"]
+    jobs = [job for job in all_jobs if job["_class"] != "com.cloudbees.hudson.plugins.folder.Folder"]
+
+    for folder in folders:
+        print(f"[{folder["name"]}]")
+
+    for job in jobs:
+        print(f"{job["name"]}")

jenkinsctl-1.0.0/jenkinsctl/commands/json.py

@@ -0,0 +1,14 @@
+from typing import Optional
+
+from jenkinsctl.configs.session import Session
+from jenkinsctl.jenkins.commons import get_last_build_no_if_none
+from jenkinsctl.jenkins.console_util import print_json
+from jenkinsctl.jenkins.job import progressive_log, get_build
+from jenkinsctl.jenkins.utils import normalize_job_path
+
+
+def json_handler(session: Session, job_name: str, build_no: Optional[int]):
+    job_name = normalize_job_path(job_name)
+    build_no = get_last_build_no_if_none(session, job_name, build_no)
+    build = get_build(session, job_name, build_no)
+    print_json(build)

jenkinsctl-1.0.0/jenkinsctl/commands/list.py

@@ -0,0 +1,62 @@
+from itertools import islice
+
+from rich.console import Console
+from rich.table import Table
+
+from jenkinsctl.configs.session import Session
+from jenkinsctl.jenkins.console_util import format_timestamp
+from jenkinsctl.jenkins.job import get_job, get_builds_iter
+from jenkinsctl.jenkins.utils import normalize_job_path
+
+
+def list_handler(session: Session, job_name: str, number: int):
+    job_name = normalize_job_path(job_name)
+    job = get_job(session, job_name)
+
+    console = Console()
+    table = Table(show_header=True, header_style="bold cyan", box=None)
+
+    table.add_column("NUMBER", width=6)
+    table.add_column("IN PROGRESS", width=15)
+    table.add_column("RESULT", width=10)
+    table.add_column("BUILDING", width=8)
+    table.add_column("BRANCH", width=15)
+    table.add_column("REVISION", width=8)
+    table.add_column("STARTED BY", width=15)
+    table.add_column("BUILD TIME", width=20)
+
+    for build in islice(get_builds_iter(session, job), number):
+        number = build["number"]
+        building = build["building"]
+        in_progress = build["inProgress"]
+        result = build["result"]
+        timestamp = build["timestamp"]
+
+        actions = build["actions"]
+        causes = next((action["causes"] for action in actions if action.get("causes") is not None), None)
+        user_id = next((cause["userId"] for cause in causes if cause.get("userId") is not None), None)
+
+        branch = None
+        revision = None
+        # fixme: not working below code
+        # last_build = next((action["lastBuildRevision"] for action in actions if action.get("lastBuildRevision") is not None))
+        last_build = None
+        if last_build:
+            branch_prefix = "refs/remotes/origin/"
+            branch = last_build["branch"][0]["name"]
+            if branch.startswith(branch_prefix):
+                branch = branch[len(branch_prefix):]
+            revision = last_build["SHA1"][:5]
+
+
+        table.add_row(
+            str(number),
+            str(in_progress),
+            str(result),
+            str(building),
+            branch,
+            revision,
+            user_id,
+            str(format_timestamp(timestamp)))
+
+    console.print(table)

jenkinsctl-1.0.0/jenkinsctl/commands/logs.py

@@ -0,0 +1,12 @@
+from typing import Optional
+
+from jenkinsctl.configs.session import Session
+from jenkinsctl.jenkins.commons import get_last_build_no_if_none
+from jenkinsctl.jenkins.job import progressive_log
+from jenkinsctl.jenkins.utils import normalize_job_path
+
+
+def logs_handler(session: Session, job_name: str, build_no: Optional[int]):
+    job_name = normalize_job_path(job_name)
+    build_no = get_last_build_no_if_none(session, job_name, build_no)
+    progressive_log(session, job_name, build_no)

jenkinsctl-1.0.0/jenkinsctl/commands/rebuild.py

@@ -0,0 +1,14 @@
+from typing import Optional
+
+from jenkinsctl.configs.session import Session
+from jenkinsctl.jenkins.commons import get_last_build_no_if_none
+from jenkinsctl.jenkins.job import get_build, build_job
+from jenkinsctl.jenkins.utils import get_build_params, normalize_job_path
+
+
+def rebuild_handler(session: Session, job_name: str, build_no: Optional[int]):
+    job_name = normalize_job_path(job_name)
+    build_no = get_last_build_no_if_none(session, job_name, build_no)
+    build = get_build(session, job_name, build_no)
+    location = build_job(session, job_name, get_build_params(build))
+    print(location)

jenkinsctl-1.0.0/jenkinsctl/configs/logging_config.py

@@ -0,0 +1,19 @@
+import logging
+import sys
+
+def setup_logging(log_level=logging.INFO):
+    logger = logging.getLogger()
+    logger.setLevel(log_level)
+
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(log_level)
+    console_handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+
+    file_handler = logging.FileHandler('jenkinsctl.log')
+    file_handler.setLevel(log_level)
+    file_handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
+
+    return logger

jenkinsctl-1.0.0/jenkinsctl/configs/session.py

@@ -0,0 +1,21 @@
+from urllib.parse import urljoin
+
+import requests
+import logging
+
+logger = logging.getLogger(__name__)
+
+class Session(requests.Session):
+    def __init__(self, base_url: str):
+        super().__init__()
+        self.base_url = base_url
+
+    def request(
+            self,
+            method,
+            url,
+            **kwargs
+    ):
+        joined_url = urljoin(self.base_url, url)
+        return super().request(method, joined_url, **kwargs)
+

jenkinsctl-1.0.0/jenkinsctl/jenkins/cli_helper.py

@@ -0,0 +1,25 @@
+import logging
+from contextlib import contextmanager
+
+from jenkinsctl.configs.config import settings
+from jenkinsctl.configs.session import Session
+
+log = logging.getLogger(__name__)
+
+@contextmanager
+def error_handler_and_session():
+    server_url: str = settings.server_url
+    username: str = settings.username
+    api_key: str = settings.api_key
+
+    session = None
+    try:
+        session = Session(server_url)
+        session.auth = (username, api_key)
+        yield session
+    except Exception as e:
+        log.debug(f"An error occurred", exc_info=e )
+        print(f"An error occurred, run same command with --verbose flag to print error details")
+    finally:
+        if session:
+            session.close()

jenkinsctl-1.0.0/jenkinsctl/jenkins/commons.py

@@ -0,0 +1,9 @@
+from jenkinsctl.jenkins.job import get_job
+from jenkinsctl.jenkins.utils import get_last_build
+
+
+def get_last_build_no_if_none(session, job_name, build_no):
+    if build_no is None:
+        job = get_job(session, job_name)
+        return get_last_build(job)
+    return build_no

jenkinsctl-1.0.0/jenkinsctl/jenkins/console_util.py

@@ -0,0 +1,31 @@
+import json
+
+from rich.console import Console
+from datetime import datetime
+from dateutil import tz
+
+
+def get_console():
+    return Console()
+
+
+def format_timestamp(epoch_timestamp):
+    # Convert epoch timestamp to a naive datetime object
+    naive_dt = datetime.fromtimestamp(epoch_timestamp / 1000)
+
+    # Get the local timezone
+    local_tz = tz.tzlocal()
+
+    # Convert naive datetime to local timezone
+    local_dt = naive_dt.astimezone(local_tz)
+
+    # Format the datetime object to a string
+    return local_dt.strftime('%Y-%m-%d %H:%M')
+
+
+def print_json(dict_obj):
+    json_str = json.dumps(dict_obj)
+    get_console().print_json(json_str)
+
+def json_preety(dict_obj):
+    return json.dumps(dict_obj, indent=2)

jenkinsctl-1.0.0/jenkinsctl/jenkins/job.py

@@ -0,0 +1,69 @@
+import time
+
+from urllib.parse import urlparse
+
+from jenkinsctl.configs.session import Session
+
+def _remove_base_url(url: str):
+    return urlparse(url).path
+
+def _get(session: Session, url: str):
+    url = _remove_base_url(url)
+    url = f"{url}api/json"
+    return session.get(url).json()
+
+
+def build_job(session: Session, job_name: str, params: dict):
+    response = None
+    if len(params) == 0:
+        url = f"/job/{job_name}/build"
+        response = session.post(url)
+    else:
+        url = f"/job/{job_name}/buildWithParameters"
+        response = session.post(url, params=params)
+
+    return response.headers.get("Location")
+
+
+def get_job(session: Session, job_name: str):
+    url = f"/job/{job_name}/"
+    return _get(session, url)
+
+
+def get_jobs(session: Session, folder_name: str):
+    if folder_name.strip() == "":
+        return _get(session, "")
+
+    url = f"/job/{folder_name}/"
+    return _get(session, url)
+
+
+def get_builds_iter(session: Session, job_json):
+    builds = job_json["builds"]
+    for build in builds:
+        yield _get_build(session, job_json, build["number"])
+
+
+def _get_build(session: Session, job_json, build_no):
+    builds = job_json["builds"]
+    build = next((build for build in builds if build["number"] == build_no), None)
+
+    return _get(session, build["url"])
+
+
+def get_build(session: Session, job_name: str, build_no: int):
+    url = f"/job/{job_name}/{build_no}/"
+    return _get(session, url)
+
+
+def progressive_log(session: Session, job_name: str, build_no: int):
+    url = f"/job/{job_name}/{build_no}/logText/progressiveText"
+    start_byte = 0
+    while True:
+        response = session.get(url, params={'start': start_byte})
+        text = response.text
+        print(text, end="")
+        start_byte = int(response.headers.get('X-Text-Size', 0))
+        if response.headers.get('X-More-Data') == 'false' or text.strip() == "":
+            break
+        time.sleep(2)

jenkinsctl-1.0.0/jenkinsctl/jenkins/utils.py

@@ -0,0 +1,37 @@
+import yaml
+
+
+def get_build_params(build_json):
+    actions = build_json["actions"]
+    params = next((action["parameters"] for action in actions if action.get("parameters") is not None), [])
+    params = dict([(param["name"], param["value"]) for param in params])
+    return params
+
+
+def normalize_job_path(path: str):
+    return (path.strip()
+            .removeprefix("/")
+            .replace("/", "/job/"))
+
+
+def print_build(build_json):
+    number = build_json["number"]
+    building = build_json["building"]
+    in_progress = build_json["inProgress"]
+    result = build_json["result"]
+    timestamp = build_json["timestamp"]
+
+    actions = build_json["actions"]
+    causes = next((action["causes"] for action in actions if action.get("causes") is not None), None)
+    user_id = next((cause["userId"] for cause in causes if cause.get("userId") is not None), None)
+
+    print(number, building, in_progress, result, timestamp, user_id)
+    print(get_build_params(build_json))
+
+
+def get_last_build(job) -> int:
+    return job["lastBuild"]["number"]
+
+
+def to_yaml(job_name, params):
+    return yaml.dump({"job": job_name, "params": params})

jenkinsctl-1.0.0/pyproject.toml

@@ -0,0 +1,36 @@
+[tool.poetry]
+name = "jenkinsctl"
+version = "1.0.0"
+description = "A command-line tool to interact with Jenkins jobs 🚀"
+authors = ["Aman Shaw <amanshaw4511@protonmail.com>"]
+readme = "README.md"
+license = "GPL-3.0-or-later"
+maintainers = [
+    "Aman Shaw <amanshaw4511@protonmail.com>"
+]
+homepage = "https://github.com/amanshaw4511/jenkinsctl"
+repository = "https://github.com/amanshaw4511/jenkinsctl"
+keywords = ["jenkins", "jenkin"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+pyyaml = "^6.0.2"
+dynaconf = "^3.2.6"
+rich = "^13.8.1"
+python-dateutil = "^2.9.0.post0"
+requests = "^2.32.3"
+click = "^8.1.7"
+click-completion = "^0.5.2"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.poetry.scripts]
+jenkinsctl = "jenkinsctl.cli:cli"

jenkinsctl-0.0.8/jenkinsctl/commons.py

@@ -1,8 +0,0 @@
-
-
-def use_vprint(verbose_flag):
-    def vprint(*args, **kwargs):
-        if verbose_flag:
-            print(*args, **kwargs)
-
-    return vprint

jenkinsctl-0.0.8/jenkinsctl/jbuild.py

@@ -1,113 +0,0 @@
-#!/usr/bin/env python3
-# PYTHON_ARGCOMPLETE_OK
-
-import time
-import sys
-import yaml
-from threading import Thread
-
-from .commons import use_vprint
-
-
-def handle_build_command(args):
-    vprint = use_vprint(args.verbose)
-    vprint(f"Passed args : {vars(args)}")
-
-    conf = get_conf(args, vprint)
-    vprint("Final config: ", conf)
-
-    create_build(args.client, conf, args.suppress_logs, vprint)
-
-
-def get_config_from_yaml(file):
-    config_data = None
-    try:
-        with open(file.name, "r") as config_file:
-            config_data = yaml.safe_load(config_file)  # Use safe_load for YAML
-    except FileNotFoundError:
-        print(f"Error: Configuration file '{file}' not found.")
-        sys.exit()
-    except yaml.YAMLError as e:
-        print(f"Error: Invalid YAML format in '{file}': {e}")
-        sys.exit()
-
-    return config_data
-
-
-def get_conf(args, vprint):
-    config = get_config_from_yaml(args.file)
-    vprint(f"Config from file : {config}")
-    override_params(args, config)
-    return config
-
-
-def override_params(args, file_config):
-    for param in args.param:
-        name, value = param.split('=')
-        file_config['params'][name] = value
-
-
-def get_build(queued_item):
-    build = queued_item.get_build()
-    while build == None:
-        time.sleep(2)
-        build = queued_item.get_build()
-    return build
-
-
-def get_build_no(queued_item):
-    return queued_item.api_json()["executable"]["number"]
-
-
-def print_build_log(build):
-    for line in build.progressive_output():
-        print(line)
-
-
-def approve_pending_input(build):
-    if not hasattr(build, 'get_pending_input'):
-        return
-
-    while not build.get_pending_input() and build.building:
-        time.sleep(1)
-
-    if build.building:
-        build.get_pending_input().submit()
-
-
-def create_build(client, conf, suppress_logs: bool, vprint=print):
-
-    client = client()
-    vprint(f"client version: {client.version}")
-
-    job = client.get_job(conf["job"])
-    vprint(f"job : {job}")
-
-    queued_item = job.build(**conf["params"])
-    vprint(f"queued : {queued_item}")
-
-    build = get_build(queued_item)
-    vprint(f"build : {build}")
-
-    build_number = get_build_no(queued_item)
-
-    if not suppress_logs:
-        print(f"STARTED... build number : {build_number}")
-
-    approve_pending_input_thread = Thread(
-        target=approve_pending_input, args=(build,))
-    approve_pending_input_thread.start()
-
-    if not suppress_logs:
-        log_thread = Thread(target=print_build_log, args=(build,))
-        log_thread.start()
-        log_thread.join()
-
-    approve_pending_input_thread.join()
-
-    if not suppress_logs:
-        print(f"FINISHED... build number : {build_number}")
-    else:
-        print(build_number)
-
-    return build_number

jenkinsctl-0.0.8/jenkinsctl/jenkins.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-# PYTHON_ARGCOMPLETE_OK
-
-import argparse
-import argcomplete
-from .jbuild import handle_build_command
-from api4jenkins import Jenkins
-from .config import settings
-from .jget_config import handle_get_config
-
-
-server_url = settings.server_url
-username = settings.username
-api_key = settings.api_key
-
-
-def get_client():
-    return Jenkins(server_url, auth=(username, api_key))
-
-
-def get_args():
-    parser = argparse.ArgumentParser()
-    subparsers = parser.add_subparsers(title="Subcommand", dest="subcommand")
-
-    add_build_subparser(subparsers)
-    add_get_config_subparser(subparsers)
-
-    argcomplete.autocomplete(parser)
-    args = parser.parse_args()
-    args.func(args)
-
-
-def add_build_subparser(subparsers):
-    subparser = subparsers.add_parser("build", help="run new build")
-    subparser.set_defaults(func=handle_build_command, client=get_client)
-    subparser.add_argument(
-        "-f", "--file", type=argparse.FileType("r"), help="Yaml configuration file"
-    )
-    subparser.add_argument("-v", "--verbose", action="store_true")
-    subparser.add_argument("-s", "--suppress-logs", action="store_true")
-    subparser.add_argument("--param", action="append", default=[])
-
-
-def add_get_config_subparser(subparsers):
-    subparser = subparsers.add_parser("config", help="get config of a build")
-    subparser.set_defaults(func=handle_get_config, client=get_client)
-    subparser.add_argument("job_name")
-    subparser.add_argument("build_no", type=int, nargs="?")
-    subparser.add_argument("-v", "--verbose", action="store_true")
-
-
-if __name__ == '__main__':
-    get_args()

jenkinsctl-0.0.8/jenkinsctl/jget_config.py

@@ -1,41 +0,0 @@
-import yaml
-
-from .commons import use_vprint
-
-
-def handle_get_config(args):
-    vprint = use_vprint(args.verbose)
-    vprint(f"Passed args : {vars(args)}")
-
-    client = args.client()
-
-    job_name = args.job_name
-
-    build = get_build(client, vprint, job_name, args.build_no)
-
-    params = get_params(build)
-
-    print(to_yaml(job_name, params))
-
-
-def get_build(client, vprint, job_name, build_no):
-    job = client.get_job(job_name)
-
-    final_build_no = get_last_build_no(job) if build_no is None else build_no
-    vprint(f"final build no {final_build_no}")
-
-    build = job.get(final_build_no)
-
-    return build
-
-
-def get_last_build_no(job):
-    return job.get_last_build().number
-
-
-def get_params(build):
-    return dict([(param.name, param.value) for param in build.get_parameters()])
-
-
-def to_yaml(job_name, params):
-    return yaml.dump({"job": job_name, "params": params})

jenkinsctl-0.0.8/jenkinsctl.egg-info/PKG-INFO

@@ -1,114 +0,0 @@
-Metadata-Version: 2.1
-Name: jenkinsctl
-Version: 0.0.8
-Summary: Build Jenkins jobs effortlessly using a single command. 🚀
-Author-email: Aman Shaw <amanshaw4511@protonmail.com>
-Project-URL: Homepage, https://github.com/amanshaw4511/jenkinsctl
-Project-URL: Repository, https://github.com/amanshaw4511/jenkinsctl
-Project-URL: Issues, https://github.com/amanshaw4511/jenkinsctl/issues
-Keywords: jenkins,jenkin
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: api4jenkins
-Requires-Dist: dynaconf
-Requires-Dist: pyyaml
-Requires-Dist: argcomplete
-
-# jenkinsctl
-Build Jenkins jobs effortlessly using a single command. 🚀
-
-## Installation 📦
-
-```sh
-pip install jenkinsctl
-```
-
-## Jenkins Configuration 🛠️
-Before using jenkinsctl, configure your Jenkins server details in your shell profile.
-Add these lines in your ~/.bashrc or ~/.zshrc file:
-```sh
-export JENKINS_SERVER_URL=http://localhost:8080
-export JENKINS_USERNAME=amanshaw4511
-export JENKINS_API_KEY=21df49caf41726094323b803a6de363eae
-```
-Adjust the values to match your Jenkins server's URL, your username, and the corresponding API key. This configuration is essential for jenkinsctl to interact with Jenkins and execute tasks efficiently.
-
-## Usage 🤖
-```sh
-$ jenkinsctl --help
-usage: jenkinsctl [-h] {build,config} ...
-
-options:
-  -h, --help      show this help message and exit
-
-Subcommand:
-  {build,config}
-    build         run new build
-    config        get config of a build
-```
-
-### Run a Jenkins Job
-```sh
-$ jenkinsctl build --help
-usage: jenkinsctl build [-h] [-f FILE] [-v] [-s SUPPRESS_LOGS] [--param PARAM]
-
-options:
-  -h, --help            show this help message and exit
-  -f FILE, --file FILE  Yaml configuration file
-  -v, --verbose
-  -s SUPPRESS_LOGS, --suppress-logs SUPPRESS_LOGS
-  --param PARAM
-```
-
-### Get Config of a Jenkin Build in YAML Format
-```sh
-$ jenkinsctl config --help
-usage: jenkinsctl config [-h] job_name build_no
-
-positional arguments:
-  job_name
-  build_no
-
-options:
-  -h, --help  show this help message and exit
-```
-
-## Examples 🎭
-### Runing a Jenkins Job
-Create a YAML configuration file, let's say `my_job.yaml`, with job parameters like this:
-```yaml
-job: my_job
-params:
-    param1: some value
-    param2: 10
-    param3: true
-```
-Initiate the job build using the following command:
-```sh
-jenkinsctl build -f my_job.yaml
-```
-This command executes the job based on the specified YAML configuration.
-
-### Overriding Specific Parameter from Configuration
-```sh
-jenkinsctl build -f my_job.yaml --param param2=11 --param param3=false
-```
-This command will override the value of `param2` and `param3` from original configuration file `my_job.yaml`, passing an effective configuration as follows to run jenkin job :
-```yaml
-job: my_job
-params:
-    param1: some value
-    param2: 11
-    param3: false
-```
-
-### Generating Config from Existing Builds
-Capture and reproduce configurations from previous Jenkins builds.
-To generate a YAML configuration file from a specific build (e.g. 2nd build) of a job (e.g., `my_job`), use the following command:
-```sh
-jenkinsctl config my_job 2 > my_job.yaml
-```

jenkinsctl-0.0.8/jenkinsctl.egg-info/SOURCES.txt

@@ -1,15 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-jenkinsctl/__init__.py
-jenkinsctl/commons.py
-jenkinsctl/config.py
-jenkinsctl/jbuild.py
-jenkinsctl/jenkins.py
-jenkinsctl/jget_config.py
-jenkinsctl.egg-info/PKG-INFO
-jenkinsctl.egg-info/SOURCES.txt
-jenkinsctl.egg-info/dependency_links.txt
-jenkinsctl.egg-info/entry_points.txt
-jenkinsctl.egg-info/requires.txt
-jenkinsctl.egg-info/top_level.txt

jenkinsctl-0.0.8/jenkinsctl.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

jenkinsctl-0.0.8/jenkinsctl.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-jenkinsctl = jenkinsctl.jenkins:get_args

jenkinsctl-0.0.8/jenkinsctl.egg-info/requires.txt

@@ -1,4 +0,0 @@
-api4jenkins
-dynaconf
-pyyaml
-argcomplete

jenkinsctl-0.0.8/jenkinsctl.egg-info/top_level.txt

@@ -1,2 +0,0 @@
-dist
-jenkinsctl

jenkinsctl-0.0.8/pyproject.toml

@@ -1,32 +0,0 @@
-[build-system]
-requires = ["setuptools"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "jenkinsctl"
-version = "v0.0.8"
-dependencies = ["api4jenkins", "dynaconf", "pyyaml", "argcomplete"]
-authors = [{ name = "Aman Shaw", email = "amanshaw4511@protonmail.com" }]
-description = "Build Jenkins jobs effortlessly using a single command. 🚀"
-readme = "README.md"
-requires-python = ">=3.8"
-classifiers = [
-  "Programming Language :: Python :: 3",
-  "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
-  "Operating System :: OS Independent",
-]
-keywords = ["jenkins", "jenkin"]
-
-[project.urls]
-Homepage = "https://github.com/amanshaw4511/jenkinsctl"
-Repository = "https://github.com/amanshaw4511/jenkinsctl"
-Issues = "https://github.com/amanshaw4511/jenkinsctl/issues"
-
-[project.scripts]
-jenkinsctl = "jenkinsctl.jenkins:get_args"
-
-[tool.setuptools.packages.find]
-where = ["."] # list of folders that contain the packages (["."] by default)
-#include = [] # package names should match these glob patterns (["*"] by default)
-exclude = [] # exclude packages matching these glob patterns (empty by default)
-#namespaces = false # to disable scanning PEP 420 namespaces (true by default)

jenkinsctl-0.0.8/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-