yardmaster 0.1.0__py3-none-any.whl

yardmaster/__init__.py

@@ -0,0 +1,8 @@
+__version__ = "0.1.0"
+__author__ = "Flatcar Team"
+__license__ = "Apache-2.0"
+
+from yardmaster.core.release import ReleaseManager, ReleaseSpec
+from yardmaster.core.version import Channel, Version
+
+__all__ = ["ReleaseManager", "ReleaseSpec", "Version", "Channel"]

yardmaster/__main__.py

@@ -0,0 +1,4 @@
+from yardmaster.cli import main
+
+if __name__ == "__main__":
+    main()

yardmaster/cli.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from yardmaster import __version__
+from yardmaster.commands.epoch import epoch_command
+from yardmaster.commands.jenkins import jenkins_command
+from yardmaster.commands.release import release_command
+from yardmaster.commands.retag import retag_command
+from yardmaster.commands.sdk import sdk_command
+from yardmaster.commands.status import status_command
+from yardmaster.config import load_config
+from yardmaster.utils.logger import setup_logger
+
+console = Console()
+CONFIG_FILE = ".yardmaster.yaml"
+CONFIG_ENV_VAR = "YARDMASTER_CONFIG"
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="yardmaster")
+@click.option(
+    "-c",
+    "--config",
+    type=click.Path(path_type=Path),
+    default=None,
+    envvar=CONFIG_ENV_VAR,
+    help=f"Configuration file path (env: {CONFIG_ENV_VAR})",
+)
+@click.option("-v", "--verbose", is_flag=True, help="Verbose output")
+@click.pass_context
+def cli(ctx: click.Context, config: Path | None, verbose: bool) -> None:
+    """🚂 Yardmaster - Flatcar Container Linux Release Management Tool"""
+    ctx.ensure_object(dict)
+    ctx.obj["verbose"] = verbose
+
+    # Commands that don't need configuration
+    if ctx.invoked_subcommand in ("epoch",):
+        return
+
+    if config is None:
+        config = Path(CONFIG_FILE)
+
+    if not config.exists():
+        console.print(f"[red]Error: Config file not found: {config}[/red]")
+        console.print(
+            "Copy [cyan].yardmaster.yaml.sample[/cyan] to "
+            f"[cyan]{CONFIG_FILE}[/cyan] and update the values."
+        )
+        sys.exit(1)
+
+    ctx.obj["config"] = load_config(config)
+    log_level = "DEBUG" if verbose else ctx.obj["config"].logging.level
+    setup_logger(log_level, fmt=ctx.obj["config"].logging.format)
+
+
+cli.add_command(epoch_command, name="epoch")
+cli.add_command(release_command, name="release")
+cli.add_command(jenkins_command, name="jenkins")
+cli.add_command(retag_command, name="retag")
+cli.add_command(sdk_command, name="sdk")
+cli.add_command(status_command, name="status")
+
+
+def main() -> None:
+    cli(obj={})
+
+
+if __name__ == "__main__":
+    main()

yardmaster/commands/epoch.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from datetime import date
+
+import click
+from rich.console import Console
+
+from yardmaster.core.version import EPOCH_BASE_DATE, days_since_epoch
+
+console = Console()
+
+
+@click.command(help="Show the alpha epoch for a given date (default: today).")
+@click.argument("date_str", required=False, default=None)
+def epoch_command(date_str: str | None) -> None:
+    if date_str is not None:
+        try:
+            target = date.fromisoformat(date_str)
+        except ValueError:
+            console.print(f"[red]Invalid date '{date_str}'. Use YYYY-MM-DD format.[/red]")
+            raise SystemExit(1)
+    else:
+        target = date.today()
+
+    epoch = days_since_epoch(target)
+    console.print(f"Base date:  {EPOCH_BASE_DATE}")
+    console.print(f"Target:     {target}")
+    console.print(f"Epoch:      [bold green]{epoch}[/bold green]")

yardmaster/commands/jenkins.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import os
+
+import click
+from rich.console import Console
+
+from yardmaster.services.jenkins import JenkinsService
+
+console = Console()
+
+
+@click.group(help="Jenkins utilities.")
+def jenkins_command() -> None:
+    pass
+
+
+@jenkins_command.command("pr-build", help="Trigger a Jenkins build for a GitHub PR (kernel tests).")
+@click.argument("owner")
+@click.argument("repo")
+@click.argument("pr", type=int)
+@click.option("--job", default="release", help="Jenkins job key or path")
+@click.option("--github-token", default=None, help="GitHub token (or set GITHUB_TOKEN)")
+@click.option("--dry-run", is_flag=True, help="Show what would be sent without triggering")
+@click.pass_context
+def jenkins_pr_build(
+    ctx: click.Context,
+    owner: str,
+    repo: str,
+    pr: int,
+    job: str,
+    github_token: str | None,
+    dry_run: bool,
+) -> None:
+    cfg = ctx.obj["config"]
+    jenkins = JenkinsService(
+        url=cfg.jenkins.url,
+        username=cfg.jenkins.username,
+        token=cfg.jenkins.token,
+        jobs=cfg.jenkins.jobs,
+        pipeline_branch=cfg.jenkins.pipeline_branch,
+        timeout=cfg.network.timeout,
+        retries=cfg.network.retries,
+        verify_ssl=cfg.network.verify_ssl,
+    )
+    try:
+        ok = jenkins.trigger_pr_build(
+            owner=owner,
+            repo=repo,
+            pr_number=pr,
+            job=job,
+            github_token=github_token or os.getenv("GITHUB_TOKEN"),
+            dry_run=dry_run,
+        )
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+    if ok:
+        console.print("[green]✓[/green] Jenkins build triggered.")

yardmaster/commands/release.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+import re
+from datetime import date, datetime, timezone
+from pathlib import Path
+from urllib.parse import urlparse
+
+import click
+from rich.console import Console
+
+from yardmaster.config import Config, load_config
+from yardmaster.core.release import ReleaseManager, ReleaseSpec
+from yardmaster.core.state import (
+    load_release_state,
+    resolve_state_path,
+    save_release_state,
+    update_release_state,
+)
+from yardmaster.core.version import Version
+from yardmaster.utils.http import HttpClient
+
+console = Console()
+ISSUE_TITLE_RE = re.compile(r"\b(alpha|beta|stable|lts)\s+(\d+\.\d+\.\d+)\b", re.IGNORECASE)
+EPOCH_BASE_DATE = date(2013, 7, 1)
+
+CHANNEL_ORDER = ["alpha", "beta", "stable", "lts"]
+
+
+def _parse_issue_url(issue_url: str) -> tuple[str, str, str]:
+    parsed = urlparse(issue_url)
+    if parsed.netloc not in {"github.com", "www.github.com"}:
+        raise click.ClickException("Only github.com issue URLs are supported.")
+    parts = [p for p in parsed.path.split("/") if p]
+    if len(parts) < 4 or parts[2] != "issues":
+        raise click.ClickException(
+            "Expected GitHub issue URL like https://github.com/org/repo/issues/1234"
+        )
+    return parts[0], parts[1], parts[3]
+
+
+def _extract_versions_from_title(title: str) -> dict[str, str]:
+    matches = ISSUE_TITLE_RE.findall(title)
+    if not matches:
+        raise click.ClickException("Could not find channel versions in issue title.")
+    versions: dict[str, str] = {}
+    for channel, version in matches:
+        key = channel.lower()
+        if key in versions and versions[key] != version:
+            raise click.ClickException(f"Conflicting versions for {key} in issue title.")
+        versions[key] = version
+    return versions
+
+
+def _issue_api_url(issue_url: str) -> tuple[str, str]:
+    owner, repo, issue_id = _parse_issue_url(issue_url)
+    return issue_id, f"https://api.github.com/repos/{owner}/{repo}/issues/{issue_id}"
+
+
+def _build_http_client(cfg: Config) -> HttpClient:
+    return HttpClient(
+        timeout=cfg.network.timeout,
+        retries=cfg.network.retries,
+        verify_ssl=cfg.network.verify_ssl,
+    )
+
+
+def _fetch_issue_title(http: HttpClient, issue_url: str) -> str:
+    issue_id, api_url = _issue_api_url(issue_url)
+    title: str | None = http.get_json(api_url).get("title")
+    if not title:
+        raise click.ClickException(f"Missing issue title for {issue_id}.")
+    return title
+
+
+def _specs_from_state(state: dict[str, object], http: HttpClient, skip_issue_check: bool) -> list[str]:
+    versions = state.get("versions")
+    if not isinstance(versions, dict) or not versions:
+        raise click.ClickException("Release state has no versions.")
+
+    issue_url = state.get("issue_url")
+    if issue_url and not skip_issue_check:
+        try:
+            title = _fetch_issue_title(http, issue_url)
+        except Exception as exc:  # noqa: BLE001
+            raise click.ClickException(
+                "Could not refresh issue title. Use --skip-issue-check or pass specs explicitly."
+            ) from exc
+        if _extract_versions_from_title(title) != versions:
+            raise click.ClickException(
+                "Release state is out of date with the issue title. Run `yardmaster release init --force <issue-url>`."
+            )
+
+    return [f"{ch}:{versions[ch]}" for ch in CHANNEL_ORDER if ch in versions]
+
+
+def _expected_epoch_today() -> int:
+    return (date.today() - EPOCH_BASE_DATE).days
+
+
+def _reconcile_alpha_epoch(specs: list[ReleaseSpec], verbose: bool) -> list[ReleaseSpec]:
+    expected_epoch = _expected_epoch_today()
+    updated: list[ReleaseSpec] = []
+    for spec in specs:
+        if spec.channel.value != "alpha" or spec.version.stream != 0 or spec.version.revision != 0:
+            if spec.channel.value == "alpha" and spec.version.stream != 0 and verbose:
+                console.print("[yellow]Alpha stream is not 0; skipping epoch check.[/yellow]")
+            updated.append(spec)
+            continue
+        if spec.version.epoch == expected_epoch:
+            updated.append(spec)
+            continue
+
+        provided_version = f"{spec.version.epoch}.{spec.version.stream}.{spec.version.revision}"
+        expected_version = f"{expected_epoch}.{spec.version.stream}.{spec.version.revision}"
+        prompt = (
+            f"Alpha epoch {spec.version.epoch} does not match expected {expected_epoch} "
+            f"(days since {EPOCH_BASE_DATE}).\n"
+            f"Provided:\n  1. {provided_version}\n"
+            f"Expected:\n  2. {expected_version}\n"
+            "Choose version (1 or 2)"
+        )
+        choice = click.prompt(prompt, type=click.IntRange(1, 2), default=2, prompt_suffix=": ")
+        chosen_version = expected_version if choice == 2 else provided_version
+        console.print(f"[cyan]Proceeding with alpha version {chosen_version}[/cyan]")
+        if choice == 2:
+            updated.append(
+                ReleaseSpec(
+                    channel=spec.channel,
+                    version=Version(expected_epoch, spec.version.stream, spec.version.revision),
+                )
+            )
+        else:
+            updated.append(spec)
+    return updated
+
+
+def _run_release(
+    specs: list[str],
+    *,
+    phase: str,
+    dry_run: bool,
+    force: bool,
+    skip_jenkins: bool,
+    skip_issue_check: bool,
+    config: Path,
+    verbose: bool,
+) -> None:
+    cfg = load_config(config)
+    state_path = resolve_state_path(cfg)
+    if not specs:
+        if verbose:
+            console.print(f"[cyan]Using stored release state from {state_path}[/cyan]")
+        http = _build_http_client(cfg)
+        specs = _specs_from_state(load_release_state(state_path), http, skip_issue_check)
+
+    manager = ReleaseManager(cfg, dry_run=dry_run, verbose=verbose)
+    parsed = _reconcile_alpha_epoch(manager.parse_specs(specs), verbose)
+    manager.run(parsed, phase=phase, force=force, skip_jenkins=skip_jenkins, state_path=state_path)
+
+
+@click.group(
+    help="Release one or more channels: CHANNEL:VERSION ...",
+    invoke_without_command=True,
+    context_settings={"allow_extra_args": True},
+)
+@click.option("--dry-run", is_flag=True, help="Show what would be done")
+@click.option("--force", is_flag=True, help="Force tag creation even if exists")
+@click.option("--skip-jenkins", is_flag=True, help="Skip Jenkins build trigger")
+@click.option(
+    "--skip-issue-check", is_flag=True, help="Skip verifying issue title when using release state"
+)
+@click.option(
+    "-c", "--config", type=click.Path(exists=True, path_type=Path), default=".yardmaster.yaml"
+)
+@click.option("-v", "--verbose", is_flag=True, help="Verbose output")
+@click.pass_context
+def release_command(
+    ctx: click.Context,
+    dry_run: bool,
+    force: bool,
+    skip_jenkins: bool,
+    skip_issue_check: bool,
+    config: Path,
+    verbose: bool,
+) -> None:
+    if ctx.invoked_subcommand is not None:
+        ctx.obj = {"config": config, "verbose": verbose}
+        return
+
+    _run_release(
+        list(ctx.args),
+        phase="all",
+        dry_run=dry_run,
+        force=force,
+        skip_jenkins=skip_jenkins,
+        skip_issue_check=skip_issue_check,
+        config=config,
+        verbose=verbose,
+    )
+
+
+@release_command.command("run", help="Run release steps for a phase.")
+@click.argument("specs", nargs=-1, required=False)
+@click.option("--pre", "phase_pre", is_flag=True, help="Run pre-release steps")
+@click.option("--post", "phase_post", is_flag=True, help="Run post-release steps")
+@click.option("--dry-run", is_flag=True, help="Show what would be done")
+@click.option("--force", is_flag=True, help="Force tag creation even if exists")
+@click.option("--skip-jenkins", is_flag=True, help="Skip Jenkins build trigger")
+@click.option(
+    "--skip-issue-check", is_flag=True, help="Skip verifying issue title when using release state"
+)
+@click.option(
+    "-c", "--config", type=click.Path(exists=True, path_type=Path), default=".yardmaster.yaml"
+)
+@click.option("-v", "--verbose", is_flag=True, help="Verbose output")
+def release_run(
+    specs: list[str],
+    phase_pre: bool,
+    phase_post: bool,
+    dry_run: bool,
+    force: bool,
+    skip_jenkins: bool,
+    skip_issue_check: bool,
+    config: Path,
+    verbose: bool,
+) -> None:
+    if phase_pre == phase_post:
+        raise click.ClickException("Choose exactly one of --pre or --post.")
+    phase = "pre" if phase_pre else "post"
+    cfg = load_config(config)
+    state_path = resolve_state_path(cfg)
+    if phase == "post":
+        state = load_release_state(state_path)
+        if state.get("status") != "in_progress":
+            raise click.ClickException(
+                "Post-release steps require a completed pre-release run. Run `yardmaster release run --pre` first."
+            )
+    _run_release(
+        list(specs),
+        phase=phase,
+        dry_run=dry_run,
+        force=force,
+        skip_jenkins=skip_jenkins,
+        skip_issue_check=skip_issue_check,
+        config=config,
+        verbose=verbose,
+    )
+    if not dry_run:
+        if phase == "pre":
+            update_release_state("in_progress", state_path)
+        elif phase == "post":
+            update_release_state("completed", state_path)
+
+
+@release_command.command("complete", help="Mark the current release as completed.")
+@click.option(
+    "-c", "--config", type=click.Path(exists=True, path_type=Path), default=".yardmaster.yaml"
+)
+def release_complete(config: Path) -> None:
+    cfg = load_config(config)
+    state_path = resolve_state_path(cfg)
+    state = load_release_state(state_path)
+    status = state.get("status")
+    if status == "completed":
+        console.print("[yellow]Release is already marked as completed.[/yellow]")
+        return
+    update_release_state("completed", state_path)
+    console.print("[green]✓[/green] Release marked as completed.")
+
+
+@release_command.command("init", help="Initialize release state from a GitHub issue.")
+@click.argument("issue_url", required=True)
+@click.option(
+    "--dry-run", is_flag=True, help="Show what would be done without writing state"
+)
+@click.option("--force", is_flag=True, help="Overwrite existing release state")
+@click.pass_context
+def release_init(
+    ctx: click.Context, issue_url: str, dry_run: bool, force: bool
+) -> None:
+    cfg_path = Path(".yardmaster.yaml")
+    verbose = False
+    if ctx.obj:
+        cfg_path = ctx.obj.get("config", cfg_path)
+        verbose = ctx.obj.get("verbose", False)
+
+    cfg = load_config(cfg_path)
+    state_path = resolve_state_path(cfg)
+    http = _build_http_client(cfg)
+    if verbose:
+        console.print(f"[cyan]Fetching issue metadata from {issue_url}[/cyan]")
+    issue_id, _api_url = _issue_api_url(issue_url)
+    title = _fetch_issue_title(http, issue_url)
+    versions = _extract_versions_from_title(title)
+
+    if state_path.exists() and not force:
+        existing_state = load_release_state(state_path)
+        if (
+            existing_state.get("issue_url") != issue_url
+            or existing_state.get("versions") != versions
+        ):
+            raise click.ClickException(
+                f"Release state already exists and differs from issue {issue_id}. Use --force to overwrite."
+            )
+
+    now = datetime.now(timezone.utc).isoformat()
+    state = {
+        "issue_url": issue_url,
+        "issue_title": title,
+        "issue_id": issue_id,
+        "versions": versions,
+        "status": "planned",
+        "created_at": now,
+        "updated_at": now,
+    }
+    if dry_run:
+        console.print(f"[cyan]Dry-run[/cyan]: would write state to {state_path}:")
+        for ch in CHANNEL_ORDER:
+            if ch in versions:
+                console.print(f"  {ch}: {versions[ch]}")
+        return
+
+    save_release_state(state, state_path)
+    console.print(f"[green]Release state saved to {state_path}[/green]")
+    for ch in CHANNEL_ORDER:
+        if ch in versions:
+            console.print(f"  {ch}: {versions[ch]}")

yardmaster/commands/retag.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from yardmaster.config import load_config
+from yardmaster.core.state import load_release_state, resolve_state_path
+from yardmaster.core.version import Channel, Version
+from yardmaster.services.runner import CommandRunner
+from yardmaster.services.sdk import SDKService
+from yardmaster.utils.http import HttpClient
+
+console = Console()
+
+
+@click.command(help="Retag the ongoing release for a channel.")
+@click.argument("channel", nargs=1, required=True)
+@click.option("--dry-run", is_flag=True, help="Show what would be done")
+@click.option("--force", is_flag=True, help="Force retag (delete existing tag)")
+@click.option(
+    "-c", "--config", type=click.Path(exists=True, path_type=Path), default=".yardmaster.yaml"
+)
+@click.option("-v", "--verbose", is_flag=True, help="Verbose output")
+def retag_command(
+    channel: str,
+    dry_run: bool,
+    force: bool,
+    config: Path,
+    verbose: bool,
+) -> None:
+    _ = force
+    cfg = load_config(config)
+    state_path = resolve_state_path(cfg)
+    ch = Channel(channel)
+    state = load_release_state(state_path)
+    versions = state.get("versions")
+    if not isinstance(versions, dict) or ch.value not in versions:
+        raise click.ClickException(f"No ongoing release for channel {ch.value}.")
+    version = Version.parse(str(versions[ch.value]))
+
+    if not click.confirm(f"Retag ongoing {ch.value}:{version}?", default=False):
+        console.print("[yellow]Cancelled.[/yellow]")
+        return
+
+    http = HttpClient(
+        timeout=cfg.network.timeout,
+        retries=cfg.network.retries,
+        verify_ssl=cfg.network.verify_ssl,
+    )
+    release_urls = {k: v.release_url for k, v in cfg.channels.items()}
+    sdk = SDKService(
+        http=http,
+        release_urls=release_urls,
+        scripts_path=cfg.paths.scripts,
+        fallback_strategy=cfg.sdk.fallback_strategy,
+        seed_sdk_offset=cfg.sdk.seed_sdk_offset,
+    )
+    resolution = sdk.resolve_sdk_for_release(ch, version)
+    if verbose:
+        console.print(f"[cyan]SDK[/cyan]: {ch.value}:{version} -> {resolution.sdk_version}")
+
+    script_path = Path(cfg.paths.build_scripts) / "tag-release"
+    CommandRunner().run_tag_release(
+        script_path,
+        channel=ch.value,
+        version=str(version),
+        sdk_version=resolution.sdk_version,
+        dry_run=dry_run,
+    )

yardmaster/commands/sdk.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import click
+from rich.console import Console
+from tabulate import tabulate
+
+from yardmaster.config import load_config
+from yardmaster.core.release import ReleaseManager
+from yardmaster.core.version import STREAM_TO_CHANNEL
+from yardmaster.services.sdk import SDKService
+from yardmaster.utils.http import HttpClient
+
+console = Console()
+
+
+@click.group(help="SDK utilities.")
+def sdk_command() -> None:
+    pass
+
+
+@sdk_command.command("determine", help="Determine SDK versions for upcoming releases.")
+@click.argument("specs", nargs=-1, required=True)
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+@click.option(
+    "-c", "--config", type=click.Path(exists=True, path_type=Path), default=".yardmaster.yaml"
+)
+def sdk_determine(specs: list[str], as_json: bool, config: Path) -> None:
+    cfg = load_config(config)
+    http = HttpClient(
+        timeout=cfg.network.timeout,
+        retries=cfg.network.retries,
+        verify_ssl=cfg.network.verify_ssl,
+    )
+    release_urls = {k: v.release_url for k, v in cfg.channels.items()}
+    sdk = SDKService(
+        http=http,
+        release_urls=release_urls,
+        scripts_path=cfg.paths.scripts,
+        fallback_strategy=cfg.sdk.fallback_strategy,
+        seed_sdk_offset=cfg.sdk.seed_sdk_offset,
+    )
+
+    parsed = ReleaseManager.parse_specs(list(specs))
+    rows = []
+    json_payload = []
+    for spec in parsed:
+        resolution = sdk.resolve_sdk_for_release(spec.channel, spec.version)
+        expected = STREAM_TO_CHANNEL.get(spec.version.stream)
+        note = resolution.note
+        if expected and expected != spec.channel:
+            note = f"{note} stream/channel mismatch" if note else "stream/channel mismatch"
+        prev_ch = resolution.previous_channel.value if resolution.previous_channel else ""
+        prev_ver = str(resolution.previous_version) if resolution.previous_version else ""
+        json_payload.append(
+            {
+                "channel": spec.channel.value,
+                "version": str(spec.version),
+                "previous_channel": prev_ch,
+                "previous_version": prev_ver,
+                "sdk_version": resolution.sdk_version,
+                "lookup_url": resolution.lookup_url or "",
+                "note": note,
+            }
+        )
+        rows.append(
+            [
+                spec.channel.value,
+                str(spec.version),
+                prev_ch,
+                prev_ver,
+                resolution.sdk_version,
+                resolution.lookup_url or "",
+                note,
+            ]
+        )
+
+    if as_json:
+        console.print(json.dumps(json_payload, indent=2))
+        return
+
+    console.print(
+        tabulate(
+            rows,
+            headers=[
+                "Channel",
+                "Version",
+                "Prev Channel",
+                "Prev Version",
+                "SDK",
+                "Lookup URL",
+                "Note",
+            ],
+            tablefmt="github",
+        )
+    )