#! /usr/bin/python
#
# Note that the above interpreter choice is correct -
# '/usr/bin/python'. It isn't '/usr/bin/python2' or
# '/usr/bin/python3'. But, this is OK. This script is run in a
# container, and we won't know which python we're executing (or even
# which will be installed), but we should be assured of one or the
# other. This script was written to be executable by either version of
# python (checked by running pylint-2 and pylint-3 on it).

"""Install specific versions of packages."""

# Here we want to make sure that we've got all the right versions of
# certain software installed.

from __future__ import print_function
import os
import os.path
import sys
import subprocess
import re
import platform
import getopt
import shutil


# split_nvra() is based on rpmUtils.miscutils.splitFilename() from
# yum. Why not just use that? There isn't a python3 version supported
# and yum is going away (at some point) from Fedora.
def split_nvra(pkg_nvr):
    """
    Pass in a standard style rpm name

    Returns a name, version, release, arch, e.g.::
        foo-1.0-1.i386.rpm returns foo, 1.0, 1, i386
    """

    # If we've got a build id link target, it will end with
    # '.debug'. Remove it.
    if pkg_nvr[-6:] == '.debug':
        pkg_nvr = pkg_nvr[:-6]

    arch_index = pkg_nvr.rfind('.')
    arch = pkg_nvr[arch_index+1:]

    rel_index = pkg_nvr[:arch_index].rfind('-')
    rel = pkg_nvr[rel_index+1:arch_index]

    ver_index = pkg_nvr[:rel_index].rfind('-')
    ver = pkg_nvr[ver_index+1:rel_index]

    name = pkg_nvr[:ver_index]
    return name, ver, rel, arch

def which(cmd):
    """Find the full path of a command."""
    for path in os.environ["PATH"].split(os.pathsep):
        if os.path.exists(os.path.join(path, cmd)):
            return os.path.join(path, cmd)

    return None

def _eprint(*args, **kwargs):
    """Print to stderr."""
    print(*args, file=sys.stderr, **kwargs)

def build_id_symlink_is_valid(bid_path):
    """Check if a build id symlink is valid."""
    symlink_exists = os.path.exists(bid_path) and os.path.islink(bid_path)
    bid_target = ''
    if symlink_exists:
        bid_target = os.readlink(bid_path)
        if not os.path.isabs(bid_target):
            bid_target = \
                os.path.abspath(os.path.join(os.path.dirname(bid_path),
                                             bid_target))
        if not os.path.exists(bid_target) \
           or os.path.islink(bid_target):
            symlink_exists = 0
    return symlink_exists, bid_target

class PkgSystem(object):
    "A class to hide the details of package management."
    # pylint: disable=too-many-instance-attributes
    __verbose = 0
    __distro_id = None
    __release = None
    __pkgr_path = None
    __pkgmgr_path = None
    __using_dnf = 0
    __wget_path = None
    __local_repo_path = ''
    __local_rpm_dir = ''

    def __init__(self, verbose):
        self.__verbose = verbose

        #
        # Try to figure out what distro/release we've got. We might
        # have to do more later if necessary to figure out the
        # distro/release (like looking at /etc/redhat-release).
        #
        # Note that it isn't an error if we can't figure out the
        # distro/release - we may not need that information.
        lsb_release = which("lsb_release")
        if lsb_release != None:
            try:
                if self.__verbose:
                    print("Running: %s" % [lsb_release, "-is"])
                self.__distro_id = subprocess.check_output([lsb_release, "-is"])
                self.__distro_id = self.__distro_id.strip()
            except subprocess.CalledProcessError:
                pass
            try:
                if self.__verbose:
                    print("Running: %s" % [lsb_release, "-rs"])
                self.__release = subprocess.check_output([lsb_release, "-rs"])
                self.__release = self.__release.strip()
            except subprocess.CalledProcessError:
                pass
        if self.__distro_id is None:
            self.__distro_id = platform.linux_distribution()[0]
        if self.__release is None:
            self.__release = platform.linux_distribution()[1]

        #
        # Make sure we know the base package manager the system uses.
        self.__pkgr_path = which("rpm")
        if self.__pkgr_path is None:
            _eprint("Can't find the 'rpm' executable.")
            sys.exit(1)

        #
        # Find the package manager for this system.
        self.__pkgmgr_path = which("dnf")
        self.__debuginfo_install = [self.__pkgmgr_path, 'debuginfo-install']
        self.__using_dnf = 1
        if self.__pkgmgr_path is None:
            self.__pkgmgr_path = which("yum")
            self.__debuginfo_install = [which('debuginfo-install')]
            self.__using_dnf = 0
        if self.__pkgmgr_path is None:
            _eprint("Can't find a package manager (either 'dnr' or 'yum').")
            sys.exit(1)

        #
        # See if we've got 'wget'. It isn't an error if we don't have
        # it since we may not need it.
        self.__wget_path = which("wget")

    def build_id_is_valid(self, name, build_id):
        """Return true if the 'name' matches the build id."""
        # If we don't have a build id, pretend it matched.
        if build_id == '':
            return 1
        # First, make sure the build id symbolic link exists. This has
        # to be an exact match. Note that Centos build id symbolic
        # links don't end in '.debug', Fedora build id symbolic links
        # do. Handle both.
        bid_path = '/usr/lib/debug/.build-id/' + build_id[:2] \
            + '/' + build_id[2:]
        (symlink_exists, bid_target) = build_id_symlink_is_valid(bid_path)
        if not symlink_exists:
            bid_path = '/usr/lib/debug/.build-id/' + build_id[:2] \
                + '/' + build_id[2:] + '.debug'
            (symlink_exists, bid_target) = build_id_symlink_is_valid(bid_path)
        if not symlink_exists:
            if self.__verbose:
                print("Build id %s doesn't exist." % build_id)
            return 0

        # Now we know the build id exists. But, does it point to the
        # correct file? Note that we're comparing basenames here. Why?
        # (1) The kernel doesn't really have a "path". (2)
        # "/usr/bin/FOO" is really the same file as "/bin/FOO"
        # (UsrMove feature).
        sym_target = os.path.basename(bid_target)
        if name == 'kernel':
            name = 'vmlinux'
        else:
            name = os.path.basename(name)
        matchp = (sym_target == name)
        if not matchp:
            # On Fedora 28, the link doesn't point to "FOO", but
            # "FOO-V-R.A.debug".
            pkg_details = split_nvra(sym_target)
            if pkg_details[0] == name:
                matchp = 1
        if not matchp:
            if self.__verbose:
                print("Build id %s doesn't match '%s'." % (build_id, name))
            return 0
        return 1

    def pkg_exists(self, pkg_nvr):
        """Return true if the package and its debuginfo exists."""
        if self.__verbose:
            print("Running: %s" % [self.__pkgr_path, '-qi', '--quiet',
                                   pkg_nvr])
        if subprocess.call([self.__pkgr_path, '-qi', '--quiet', pkg_nvr]) != 0:
            return 0
        return 1

    def pkg_install(self, pkg_nvr, build_id):
        """Install a package and its debuginfo."""
        if not self.pkg_exists(pkg_nvr):
            # Why are we using the "noscripts" option here? Background
            # - building a Fedora 28 container on a Centos 7 host. On
            # a kernel install, the Fedora kernel rpm %post script ran
            # "dracut" to create a new initrd. The dracut command hit
            # an error, then proceeded to spew lots of errors and
            # ended up deleting /tmp in the container. So, to avoid
            # this, we won't run %pre/%post rpm scripts (which
            # hopefully shouldn't be needed anyway). If the %pre/%post
            # scripts end up being needed, we could only use
            # "noscripts" when installing a kernel.
            #
            # If we're using dnf, add the '--allowerasing' option so that
            # we can override conflicting packages.
            cmd = [self.__pkgmgr_path, 'install', '-y', '--quiet'] \
                + (['--allowerasing'] if self.__using_dnf else []) \
                + ['--setopt=tsflags=noscripts', pkg_nvr]
            if self.__verbose:
                print("Running: %s" % cmd)
            if subprocess.call(cmd) != 0:
                return 0

        # If we don't have a build id, we don't need to install
        # debuginfo.
        if build_id == '':
            return 1

        # Here we're assuming the debuginfo package doesn't already exist.
        cmd = self.__debuginfo_install + ['-y', '--quiet', pkg_nvr]
        if self.__verbose:
            print("Running: %s" % cmd)
        if subprocess.call(cmd) != 0:
            return 0
        # 'dnf debuginfo' has a *really* annoying habit of not
        # installing the exact version you asked for if the version
        # you asked for isn't available. So, make sure we actually
        # installed the right debuginfo package.
        pkg_details = split_nvra(pkg_nvr)
        debuginfo_nvr = (pkg_details[0] + '-debuginfo-' + pkg_details[1]
                         + '-' + pkg_details[2] + '.' + pkg_details[3])
        if not self.pkg_exists(debuginfo_nvr):
            # The wrong debuginfo package got installed. Try to remove
            # it.
            debuginfo_wildcard = pkg_details[0] + '-debuginfo-*'
            cmd = [self.__pkgmgr_path, 'remove', '-y',
                   '--setopt=tsflags=noscripts', debuginfo_wildcard]
            if self.__verbose:
                print("Running: %s" % cmd)
            subprocess.call(cmd)
            return 0
        return 1

    def pkg_download_and_install(self, pkg_nvr, build_id):
        """Manually download and install a package."""
        # If we're not on Fedora, we don't know how to get the
        # package.
        if self.__wget_path is None or self.__distro_id is None \
           or self.__distro_id.lower() != "fedora":
            _eprint("Can't download package '%s'" % pkg_nvr)
            return 0

        # Try downloading the package from koji, Fedora's build system.
        #
        # Build up the koji url. Koji urls look like:
        # http://kojipkgs.fedoraproject.org/packages/NAME/VER/RELEASE/ARCH/
        pkg_details = split_nvra(pkg_nvr)
        koji_url = ("http://kojipkgs.fedoraproject.org/packages/%s/%s/%s/%s"
                    % (pkg_details[0], pkg_details[1], pkg_details[2],
                       pkg_details[3]))
        _eprint("URL: '%s'" % koji_url)

        # Download the entire arch directory. Here's a description of
        # wget's arguments:
        #
        #   --quiet: Don't display progress.
        #   -nH: No host directories (i.e. get rid of the host name in
        #        the download directory name).
        #   --cut-dirs=4: Ignore 4 directory components.
        #   -r: Turn on recursive retrieving.
        #   -l 1: Maximum recursion depth is 1.
        #
        if self.__verbose:
            print("Running: %s" % ['wget', '--quiet', '-nH', '--cut-dirs=4',
                                   '-r', '-l', '1', koji_url])
        if subprocess.call(['wget', '--quiet', '-nH', '--cut-dirs=4',
                            '-r', '-l', '1', koji_url]) != 0:
            _eprint("Can't download package '%s'" % pkg_nvr)
            return 0

        # OK, now we've got a directory which contains all the RPMs
        # for package 'foo'. We can't just do a "dnf install RPM",
        # because (for example) the 'kernel' RPM requires the
        # 'kernel-core' and 'kernel-firmware' RPMs. We might be able
        # to install all the RPMs we just downloaded, but besides
        # being overkill, it is theoretically possible that they might
        # conflict somehow.
        #
        # So, instead we'll create a local repo that then yum/dnf can
        # use when looking for RPMs.

        # First create the repo file.
        self.__local_repo_path = '/etc/yum.repos.d/local.repo'
        self.__local_rpm_dir = '/root/%s' % pkg_details[3]
        if not os.path.exists(self.__local_repo_path):
            repo_file = open(self.__local_repo_path, 'w')
            repo_file.write('[local]\n')
            repo_file.write('name=Local repository\n')
            repo_file.write('baseurl=file://%s\n' % self.__local_rpm_dir)
            repo_file.write('enabled=1\n')
            repo_file.write('gpgcheck=0\n')
            repo_file.write('type=rpm\n')
            repo_file.close()

        # Next run 'createrepo_c' on the directory.
        if self.__verbose:
            print("Running: %s" % ['createrepo_c', '--quiet', self.__local_rpm_dir])
        if subprocess.call(['createrepo_c', '--quiet', self.__local_rpm_dir]) != 0:
            _eprint("Can't run createrepo_c")
            return 0

        # At this point we should be set up to let the package manager
        # install the package.
        return self.pkg_install(pkg_nvr, build_id)

    def cleanup(self):
        """Perform cleanup (if necessary)."""
        if self.__local_repo_path:
            os.remove(self.__local_repo_path)
        if self.__local_rpm_dir:
            shutil.rmtree(self.__local_rpm_dir)

def _usage():
    """Display command-line usage."""
    _eprint("Usage: %s [-v] --name NAME --pkg PACKAGE --build_id BUILD_ID"
            % sys.argv[0])
    sys.exit(1)

def _handle_command_line():
    """Process command line."""
    verbose = 0
    name = ''
    pkg_nvr = ''
    build_id = ''

    # Make sure the command line looks reasonable.
    if len(sys.argv) < 4:
        _usage()
    try:
        (opts, pargs) = getopt.getopt(sys.argv[1:], 'v', ['name=', 'pkg=', 'build_id='])
    except getopt.GetoptError as err:
        _eprint("Error: %s" % err)
        _usage()
    for (opt, value) in opts:
        if opt == '-v':
            verbose += 1
        elif opt == '--name':
            name = value
        elif opt == '--pkg':
            pkg_nvr = value
        elif opt == '--build_id':
            build_id = value
    if pargs:
        _usage()
    if not name or not pkg_nvr or not build_id:
        _eprint("Error: '--name', '--pkg', and '--build_id' are required arguments.")
        _usage()
    return (verbose, name, pkg_nvr, build_id)

def main():
    """Main function."""
    (verbose, name, pkg_nvr, build_id) = _handle_command_line()

    # Make sure we're in /root.
    os.chdir('/root')

    packages = []
    packages.append([name, pkg_nvr, build_id])

    # If the package name is 'kernel', we've got to do some special
    # processing. We also want to install the matching kernel-devel
    # (along with the debuginfo).
    #
    # Note that we have to handle/recognize kernel variants, like
    # 'kernel-PAE' or 'kernel-debug'.
    kernel_regexp = re.compile(r'^kernel(-\w+)?')
    match = kernel_regexp.match(name)
    if match:
        devel_name = name + '-devel'
        devel_nvr = re.sub(name, devel_name, pkg_nvr)
        # Notice we're not including the build id. When there's no
        # build id, build_id_is_valid() returns a 1.
        packages.append([devel_name, devel_nvr, ''])

    pkgsys = PkgSystem(verbose)
    for (name, pkg_nvr, build_id) in packages:
        # Try using the package manager to install the package and its
        # debuginfo.
        if pkgsys.pkg_install(pkg_nvr, build_id):
            # The package and its debuginfo exist. Does the build id
            # match?
            if pkgsys.build_id_is_valid(name, build_id):
                continue
            # If the package and its debuginfo exists, but the build
            # ids don't match, we're done.
            _eprint("Package '%s' is installed, but the build id"
                    " doesn't match" % pkg_nvr)
            pkgsys.cleanup()
            sys.exit(1)

        # As a last resort, try downloading and installing the package
        # manually.
        if pkgsys.pkg_download_and_install(pkg_nvr, build_id):
            # The package and its debuginfo exist. Does the build id
            # match?
            if pkgsys.build_id_is_valid(name, build_id):
                continue
            # If the package and its debuginfo exists, but the build
            # ids don't match, we're done.
            _eprint("Package '%s' is installed, but the build id"
                    " doesn't match" % pkg_nvr)
            pkgsys.cleanup()
            sys.exit(1)

        # If the package manager couldn't install the package, and we
        # couldn't download and install the package manually, we're
        # done.
        _eprint("Can't find package '%s'" % pkg_nvr)
        sys.exit(1)

    if verbose:
        print("All packages installed.")

    # Perform cleanup, if needed.
    pkgsys.cleanup()
    sys.exit(0)

if __name__ == '__main__':
    main()