build/bin/bump_kernel_packages

#!/usr/bin/python2

import argparse
import atexit
import os
import subprocess
import shutil
import sys
import tempfile

from entropy.server.interfaces import Server

import entropy.dep


if __name__ == "__main__":

    parser = argparse.ArgumentParser(
        description="Bump Kernel Packages for Entropy Server")

    parser.add_argument(
        "query_version", metavar="<query version>",
        help="the uname version to query")
    parser.add_argument(
        "build_version", metavar="<build version>",
        help="the uname version to build packages for")

    parser.add_argument(
        "query_repo", metavar="<query repo>",
        help="the repository to query")
    parser.add_argument(
        "build_repo", metavar="<build repo>",
        help="the repository to place packages into")

    parser.add_argument(
        "--only-injected", action="store_true", default=False,
        help="only consider injected packages")
    parser.add_argument(
        "--no-spm-repo", action="store_true", default=False,
        help=("do not include the SPM repository suffix "
              "in dependency atoms"))
    parser.add_argument(
        "--keyslot", action="store_true", default=False,
        help=("do not use the exact package version but "
              "rather key:slot"))
    parser.add_argument(
        "--canfail", action="store_true", default=False,
        help="if emerge can fail and you want to ignore it")

    nsargs = parser.parse_args(sys.argv[1:])

    srv = Server()
    pkgs_map = {}
    try:
        repo = srv.open_repository(nsargs.query_repo)
        pkg_ids = repo.searchTaggedPackages(nsargs.query_version)
        if not pkg_ids:
            print("!!! no packages for <query version>")
            raise SystemExit(1)

        injected_pkgs = []
        normal_pkgs = []
        for pkg_id in pkg_ids:
            injected = repo.isInjected(pkg_id)
            if injected:
                injected_pkgs.append(pkg_id)
            else:
                normal_pkgs.append(pkg_id)

        normal_atoms = []
        injected_atoms = []
        data = (
            (normal_pkgs, normal_atoms),
            (injected_pkgs, injected_atoms)
        )
        for lst, dst in data:
            for pkg_id in lst:
                if nsargs.keyslot:
                    atom_str = entropy.dep.remove_tag_from_slot(
                        repo.retrieveKeySlotAggregated(pkg_id))
                else:
                    atom_str = "~" + entropy.dep.remove_tag(
                        repo.retrieveAtom(pkg_id))
                if not nsargs.no_spm_repo:
                    spm_repo = repo.retrieveSpmRepository(pkg_id)
                    if spm_repo is not None:
                        atom_str += "::" + spm_repo
                dst.append(atom_str)
    finally:
        srv.shutdown()

    if not nsargs.only_injected:
        if normal_atoms:
            print("normal packages: %s" % (
                " ".join(normal_atoms),))
    if injected_atoms:
        print("injected packages: %s" % (
            " ".join(injected_atoms),))

    if not (normal_atoms or injected_atoms):
        print("nothing to do !!")
        raise SystemExit(0)

    def clean_dirs(xdirs):
        for directory in xdirs:
            try:
                shutil.rmtree(directory, True)
            except shutil.Error:
                pass

    dirs = []
    atexit.register(clean_dirs, dirs)

    os.environ['KERNEL_DIR'] = "/usr/src/linux-%s" % (
        nsargs.build_version,)

    portage_tmpdir = tempfile.mkdtemp(
        dir="/var/tmp", prefix="bump_kernel_packages.portage_tmpdir")
    dirs.append(portage_tmpdir)
    os.environ["PORTAGE_TMPDIR"] = portage_tmpdir

    if normal_atoms and not nsargs.only_injected:
        args = ["emerge", "-av", "--keep-going"]
        args += [x for x in normal_atoms]
        rc = subprocess.call(args)
        if rc != 0 and not nsargs.canfail:
            raise SystemExit(rc)
        subprocess.call(["/usr/sbin/etc-update"])

        args = ["eit", "add", "--to", nsargs.build_repo]
        args += normal_atoms
        rc = subprocess.call(args)
        if rc != 0:
            raise SystemExit(rc)

    if injected_atoms:
        tmp_dir = tempfile.mkdtemp(
            dir="/var/tmp", prefix="bump_kernel_packages")
        dirs.append(tmp_dir)
        os.environ['PKGDIR'] = tmp_dir

        args = ["emerge", "-Bav", "--nodeps"]
        args += [x for x in injected_atoms]
        rc = subprocess.call(args)
        if rc != 0 and not nsargs.canfail:
            raise SystemExit(rc)

        tbz2s = []
        for category in os.listdir(tmp_dir):
            path = os.path.join(tmp_dir, category)
            if not os.path.isdir(path):
                continue
            for sub_file in os.listdir(path):
                if not sub_file.endswith(".tbz2"):
                    continue
                tbz2s.append(os.path.join(path, sub_file))

        if tbz2s:
            args = ["eit", "inject", "--to", nsargs.build_repo]
            args += tbz2s
            rc = subprocess.call(args)
            if rc != 0:
                raise SystemExit(rc)

    raise SystemExit(0)