tumbi-assembler/pungi/wrappers/pungi.py

# -*- coding: utf-8 -*-


# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Library General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <https://gnu.org/licenses/>.


import os
import re

from .. import util


PACKAGES_RE = {
    "rpm": re.compile(r"^RPM(\((?P<flags>[^\)]*)\))?: (?P<path>.+)$"),
    "srpm": re.compile(r"^SRPM(\((?P<flags>[^\)]*)\))?: (?P<path>.+)$"),
    "debuginfo": re.compile(r"^DEBUGINFO(\((?P<flags>[^\)]*)\))?: (?P<path>.+)$"),
}


UNRESOLVED_DEPENDENCY_RE = re.compile(r"^.*Unresolvable dependency (.+) in ([^ ]+).*$")

MISSING_COMPS_PACKAGE_RE = re.compile(
    r"^.*Could not find a match for (.+) in any configured repo"
)


def _write_ks_section(f, section, lines):
    if lines:
        f.write("\n%%%s\n" % section)
        for i in sorted(lines):
            f.write("%s\n" % i)

        f.write("%end\n")


class PungiWrapper(object):
    def write_kickstart(
        self,
        ks_path,
        repos,
        groups,
        packages,
        exclude_packages=None,
        comps_repo=None,
        lookaside_repos=None,
        fulltree_excludes=None,
        multilib_blacklist=None,
        multilib_whitelist=None,
        prepopulate=None,
    ):
        groups = groups or []
        exclude_packages = exclude_packages or {}
        lookaside_repos = lookaside_repos or {}
        # repos = {name: url}
        fulltree_excludes = fulltree_excludes or set()
        multilib_blacklist = multilib_blacklist or set()
        multilib_whitelist = multilib_whitelist or set()
        ks_path = os.path.abspath(ks_path)

        ks_dir = os.path.dirname(ks_path)
        util.makedirs(ks_dir)

        kickstart = open(ks_path, "w")

        # repos
        for repo_name, repo_url in list(repos.items()) + list(lookaside_repos.items()):
            if "://" not in repo_url:
                repo_url = "file://" + os.path.abspath(repo_url)
            repo_str = "repo --name=%s --baseurl=%s" % (repo_name, repo_url)
            # TODO: make sure pungi works when there are no comps in repodata
            # XXX: if groups are ignored, langpacks are ignored too
            if comps_repo and repo_name != comps_repo:
                repo_str += " --ignoregroups=true"
            kickstart.write(repo_str + "\n")

        # %packages
        kickstart.write("\n")
        kickstart.write("%packages\n")

        for group in sorted(groups):
            kickstart.write("@%s --optional\n" % group)

        for package in sorted(packages):
            kickstart.write("%s\n" % package)

        for package in sorted(exclude_packages):
            kickstart.write("-%s\n" % package)

        kickstart.write("%end\n")

        _write_ks_section(kickstart, "fulltree-excludes", fulltree_excludes)
        _write_ks_section(kickstart, "multilib-blacklist", multilib_blacklist)
        _write_ks_section(kickstart, "multilib-whitelist", multilib_whitelist)
        _write_ks_section(kickstart, "prepopulate", prepopulate)

        kickstart.close()

    def get_pungi_cmd_dnf(
        self,
        config,
        destdir,
        name,
        version=None,
        flavor=None,
        selfhosting=False,
        fulltree=False,
        greedy=None,
        nodeps=False,
        nodownload=True,
        full_archlist=False,
        arch=None,
        cache_dir=None,
        lookaside_repos=None,
        multilib_methods=None,
        profiler=False,
    ):
        cmd = ["pungi-gather"]

        # path to a kickstart file
        cmd.append("--config=%s" % config)

        # turn selfhosting on
        if selfhosting:
            cmd.append("--selfhosting")

        # NPLB
        if fulltree:
            cmd.append("--fulltree")

        greedy = greedy or "none"
        cmd.append("--greedy=%s" % greedy)

        if nodeps:
            cmd.append("--nodeps")

        if arch:
            cmd.append("--arch=%s" % arch)

        if not nodownload:
            cmd.append("--download-to=%s" % destdir)

        if multilib_methods:
            for i in multilib_methods:
                cmd.append("--multilib=%s" % i)

        if lookaside_repos:
            for i in lookaside_repos:
                cmd.append("--lookaside=%s" % i)

        if profiler:
            cmd.append("--profiler")

        return cmd

    def parse_log(self, f):
        packages = dict(((i, []) for i in PACKAGES_RE))
        broken_deps = {}
        missing_comps = set()

        for line in f:
            for file_type, pattern in PACKAGES_RE.items():
                match = pattern.match(line)
                if match:
                    item = {}
                    item["path"] = match.groupdict()["path"].strip()
                    if item["path"].startswith("file://"):
                        item["path"] = item["path"][7:]
                    flags = match.groupdict()["flags"] or ""
                    flags = sorted([i.strip() for i in flags.split(",") if i.strip()])
                    item["flags"] = flags
                    packages[file_type].append(item)
                    break

            match = MISSING_COMPS_PACKAGE_RE.match(line)
            if match:
                missing_comps.add(match.group(1))

            match = UNRESOLVED_DEPENDENCY_RE.match(line)
            if match:
                broken_deps.setdefault(match.group(2), set()).add(match.group(1))

        return packages, broken_deps, missing_comps