cranky-0

#!/usr/bin/env python3

import os
import sys
from subprocess import CalledProcessError, check_call

import click
from debian.changelog import Changelog

CRANKY = os.getenv("CRANKY", "cranky")
COLS = int(os.popen("tput cols", "r").read().strip())


def source_debian_env():
    with open("debian/debian.env", encoding="utf-8") as fh:
        for line in fh:
            if line.startswith("DEBIAN="):
                return line.strip().split("=")[1]
    return None


def parse_changelog(changelog=None, offset=0):
    if not changelog:
        changelog = f"{source_debian_env()}/changelog"

    with open(changelog, encoding="utf-8") as fh:
        return Changelog(fh)[offset]


def print_banner(cmd, invert=True, color=9):
    txt = " ".join(cmd) + " " * COLS
    x = 48 if invert else 38
    print(f"\033[{x};5;{color}m{txt[:COLS]}\033[0m")


def run(cmd, shell=False):
    print()
    print_banner(cmd)
    try:
        if cmd[0] == "cranky":
            print_banner([os.popen("which cranky", "r").read().strip()], invert=False)

        if shell:
            check_call(" ".join(cmd), bufsize=0, shell=True)
        else:
            check_call(cmd, bufsize=0)
    except CalledProcessError as e:
        print("Error: " + str(e))
        sys.exit(1)


def debian_version(git_obj):
    line = os.popen(f"git show {git_obj} | head -1", "r").read()
    return line.split("(")[1].split(")")[0]


@click.group()
def main():
    pass


@main.command()
def fix():
    series = parse_changelog().distributions
    if series == "UNRELEASED":
        print(f"Invalid series: {series}", file=sys.stderr)
        sys.exit(1)

    run([CRANKY, "fix"])


@main.command()
@click.option("--dry-run", is_flag=True)
@click.argument("tag")
@click.argument("tag2", nargs=-1)
def rebase(dry_run, tag, tag2):
    opts = []
    if dry_run:
        opts += ["--dry-run"]

    run(["cranky-rebase", "--tag", tag] + opts)

    ch = parse_changelog()
    if ch.package == "linux-raspi-realtime" and os.path.exists("debian.realtime"):
        run(["cranky-update-tree"] + opts + ["--strategy", "cherry-pick", "realtime", tag2[0]])


@main.command(name="open")
@click.option("--dry-run", is_flag=True)
def open_(dry_run):
    opts = []
    if dry_run:
        opts += ["--dry-run"]

    series = parse_changelog().distributions
    if series == "UNRELEASED":
        print(f"Invalid series: {series}", file=sys.stderr)
        sys.exit(1)

    run([CRANKY, "open"] + opts)


@main.command()
def configs():
    run([CRANKY, "updateconfigs"])


@main.command()
@click.option("--dry-run", is_flag=True)
@click.option("--re-run", is_flag=True)
@click.option("--cycle", required=True, help="SRU cycle name.")
def link(dry_run, re_run, cycle):
    opts = []
    if dry_run:
        opts += ["--dry-run"]
    if re_run:
        opts += ["--re-run"]

    run([CRANKY, "link-tb", "--sru-cycle", cycle] + opts)


@main.command()
def dkms():
    if os.path.exists("update-dkms-versions"):
        print("Error: ./update-dkms-versions exists. This is unexpected!")
        sys.exit(1)

    run([CRANKY, "update-dkms-versions"])


@main.command(name="close")
@click.option("--force", is_flag=True)
def close_(force):
    series = parse_changelog().distributions
    if series != "UNRELEASED":
        print(f"Invalid series: {series}", file=sys.stderr)
        sys.exit(1)

    opts = []
    if force:
        opts += ["--force"]

    run([CRANKY, "close"])

    if parse_changelog().package == "linux-raspi-realtime" and os.path.exists("debian.realtime"):
        print()
        print("*** FIXME ***")
        print()

        # Reset HEAD
        run(["git", "reset", "--hard", "HEAD~1"])

        cl = "debian.raspi-realtime/changelog"

        # Previous release version and tag
        raspi_realtime_version = str(parse_changelog("debian.raspi-realtime/changelog", offset=1).version)
        raspi_realtime_tag = f"Ubuntu-raspi-realtime-{raspi_realtime_version}"

        #
        # raspi
        #
        version = debian_version(f"{raspi_realtime_tag}:debian.raspi/changelog")
        run([CRANKY, "update-changelog", "--changelog", cl,
             "--from-version", version,
             "--from-changelog", "debian.raspi/changelog"])

        #
        # realtime
        #
        version = debian_version(f"{raspi_realtime_tag}:debian.realtime/changelog")
        from_commit = os.popen("git log --format='%h __%s__' |" +
                               f"grep -m1 -F '__UBUNTU: Ubuntu-realtime-{version}__' | sed 's/ .*//'",
                               "r").read().strip()
        version = str(parse_changelog("debian.realtime/changelog").version)
        to_commit = os.popen("git log --format='%h __%s__' |" +
                             f"grep -m1 -F '__UBUNTU: Ubuntu-realtime-{version}__' | sed 's/ .*//'",
                             "r").read().strip()
        run([CRANKY, "update-changelog", "--changelog", cl,
             "--commit-range", f"{from_commit}..{to_commit}"])

        #
        # raspi-realtime
        #
        from_commit = os.popen("git log --format='%h __%s__' |" +
                               f"grep -m1 -F '__UBUNTU: {raspi_realtime_tag}__' | sed 's/ .*//'",
                               "r").read().strip()
        run([CRANKY, "update-changelog", "--changelog", cl,
             "--from-commit", from_commit])

        # Commit
        series = parse_changelog(cl, offset=1).distributions
        version = str(parse_changelog(cl).version)
        run(["git", "add", cl])
        run(["dch", "--nomultimaint", "-c", cl, "-r", "-D", series, ""])
        run(["git", "commit", "-sam", f"UBUNTU: Ubuntu-raspi-realtime-{version}"])

    run([CRANKY, "tag"] + opts)


@main.command()
def dependents():
    run(["cranky-update-dependents", "-f"])


@main.command()
def verify():
    run(["cranky-verify-release-ready"])


@main.command()
@click.option("--no-orig", is_flag=True)
@click.option("--orig", is_flag=True)
@click.argument("pocket_offset_abi")
def build(pocket_offset_abi, no_orig, orig):
    cmd = ["cranky-build-sources", "--force"]
    if no_orig:
        cmd.append("--no-orig")
    if orig:
        cmd.append("--orig")
    cmd.append(pocket_offset_abi)
    run(cmd)


@main.command()
@click.argument("pocket_offset_abi")
def review(pocket_offset_abi):
    run(["cranky-review-sources", pocket_offset_abi])
    run(["cranky-reduce-debdiff"])

    run(["cranky-review-sources", "|", "less"], shell=True)
    run(["review-debdiff", "-r", "|", "less"], shell=True)


@main.command()
def push():
    run(["cranky-push-all", "--dry-run"])

    val = ""
    while val != "y":
        val = input("Push (y|n)? ")

    run(["cranky-push-all"])


@main.command()
@click.argument("ppa")
def dput(ppa):
    run([CRANKY, "dput-sources", ppa])


@main.command()
@click.option("--dry-run", is_flag=True)
def checkout(dry_run):
    opts = []
    if dry_run:
        opts += ["--dry-run"]
    run(["cranky-checkout"] + opts)


@main.command(context_settings=dict(ignore_unknown_options=True,))
@click.argument("cbd_args", nargs=-1, type=click.UNPROCESSED)
def cbd(cbd_args):
    run(["cbd-cli", "-n", "build"] + list(cbd_args))


# ---------------------------------------------------------------------------------------------------

@main.command(name="1--checkout")
@click.option("--dry-run", is_flag=True)
@click.pass_context
def x1(ctx, dry_run):
    ctx.invoke(checkout, dry_run=dry_run)


@main.command(name="2--fix-rebase-fix-open")
@click.option("--dry-run", is_flag=True)
@click.argument("tag")
@click.argument("tag2", nargs=-1)
@click.pass_context
def x2(ctx, dry_run, tag, tag2):
    ctx.invoke(fix)
    ctx.invoke(rebase, dry_run=dry_run, tag=tag, tag2=tag2)
    ctx.invoke(fix)
    ctx.invoke(open_, dry_run=dry_run)


@main.command(name="3--configs")
@click.pass_context
def x3(ctx):
    ctx.invoke(configs)


@main.command(name="4--link-dkms-close-dependents-verify")
@click.option("--dry-run", is_flag=True)
@click.option("--re-run", is_flag=True)
@click.option("--cycle", required=True, help="SRU cycle name.")
@click.option("--force", is_flag=True)
@click.pass_context
def x4(ctx, dry_run, re_run, cycle, force):
    ctx.invoke(link, dry_run=dry_run, re_run=re_run, cycle=cycle)
    ctx.invoke(dkms)
    ctx.invoke(close_, force=force)
    ctx.invoke(dependents)
    ctx.invoke(verify)


@main.command(name="5--build-review")
@click.option("--no-orig", is_flag=True)
@click.option("--orig", is_flag=True)
@click.argument("pocket_offset_abi")
@click.pass_context
def x5(ctx, pocket_offset_abi, no_orig, orig):
    ctx.invoke(build, pocket_offset_abi=pocket_offset_abi, no_orig=no_orig, orig=orig)
    ctx.invoke(review, pocket_offset_abi=pocket_offset_abi)


@main.command(name="6--cbd",
              context_settings=dict(ignore_unknown_options=True,))
@click.argument("cbd_args", nargs=-1, type=click.UNPROCESSED)
@click.pass_context
def x6(ctx, cbd_args):
    ctx.invoke(cbd, cbd_args=cbd_args)


@main.command(name="7--push-dput")
@click.argument("ppa")
@click.pass_context
def x7(ctx, ppa):
    ctx.invoke(push)
    ctx.invoke(dput, ppa=ppa)


if __name__ == "__main__":
    if "--" in sys.argv[0]:
        subcmd = os.path.basename(sys.argv[0]).removeprefix("cranky-")
        sys.argv[0] = sys.argv[0].removesuffix(f"-{subcmd}")
        sys.argv.insert(1, subcmd)
    main()