AnonymousFox

//lib/python3.6/site-packages/mockbuild/backend.py

# -*- coding: utf-8 -*-
# vim:expandtab:autoindent:tabstop=4:shiftwidth=4:filetype=python:textwidth=0:
# License: GPL2 or later see COPYING
# Originally written by Seth Vidal
# Sections taken from Mach by Thomas Vander Stichele
# Major reorganization and adaptation by Michael Brown
# Copyright (C) 2007 Michael E Brown <mebrown@michaels-house.net>

import glob
import os
import shutil
import sys
import tempfile
import getpass

# 3rd party imports
import rpm
from mockbuild.mounts import BindMountPoint

from . import file_util
from . import text
from . import util
from .external import ExternalDeps
from .file_downloader import FileDownloader
from .exception import PkgError, Error, RootError, BuildError, ExternalDepsError
from .trace_decorator import getLog, traceLog
from .rebuild import do_rebuild

class Commands(object):
    """Executes mock commands in the buildroot"""

@traceLog()
    def __init__(self, config, uid_manager, plugins, state, buildroot, bootstrap_buildroot):
        self.uid_manager = uid_manager
        self.buildroot = buildroot
        self.bootstrap_buildroot = bootstrap_buildroot
        self.state = state
        self.plugins = plugins
        self.config = config
        self.external = ExternalDeps(buildroot, bootstrap_buildroot, uid_manager)

self.rpmbuild_arch = config['rpmbuild_arch']
        self.clean_the_chroot = config['clean']

self.build_results = []

# config options
        self.configs = config['config_paths']
        self.config_name = config['chroot_name']
        self.buildroot.chrootuid = config['chrootuid']
        self.buildroot.chrootgid = config['chrootgid']
        self.use_host_resolv = config['use_host_resolv']
        self.chroot_file_contents = config['files']
        self.chroot_setup_cmd = config['chroot_setup_cmd']
        self.nspawn_args = config['nspawn_args']
        if isinstance(self.chroot_setup_cmd, str):
            # accept strings in addition to other sequence types
            self.chroot_setup_cmd = self.chroot_setup_cmd.split()
        self.more_buildreqs = config['more_buildreqs']
        self.cache_alterations = config['cache_alterations']

self.backup = config['backup_on_clean']
        self.backup_base_dir = config['backup_base_dir']

# do we allow interactive root shells?
        self.no_root_shells = config['no_root_shells']

self.private_network = not config['rpmbuild_networking']

def _get_nspawn_args(self):
        nspawn_args = []
        if util.USE_NSPAWN:
            nspawn_args.extend(self.config['nspawn_args'])
        return nspawn_args

@traceLog()
    def backup_results(self):
        srcdir = os.path.join(self.buildroot.basedir, "result")
        if not os.path.exists(srcdir):
            return
        dstdir = os.path.join(self.backup_base_dir, self.config['root'])
        file_util.mkdirIfAbsent(dstdir)
        rpms = glob.glob(os.path.join(srcdir, "*rpm"))
        if len(rpms) == 0:
            return
        self.state.state_log.info("backup_results: saving with cp %s %s", " ".join(rpms), dstdir)
        util.run(cmd="cp %s %s" % (" ".join(rpms), dstdir))

@traceLog()
    def clean(self):
        """clean out chroot with extreme prejudice :)"""
        if self.backup:
            self.backup_results()
        self.state.start("clean chroot")
        self.buildroot.delete()
        self.state.finish("clean chroot")

@traceLog()
    def scrub(self, scrub_opts):
        """clean out chroot and/or cache dirs with extreme prejudice :)"""
        statestr = "scrub %s" % scrub_opts
        self.state.start(statestr)
        try:
            try:
                self.plugins.call_hooks('clean')
                if self.bootstrap_buildroot is not None:
                    self.bootstrap_buildroot.plugins.call_hooks('clean')

for scrub in scrub_opts:
                    self.plugins.call_hooks('scrub', scrub)
                    if self.bootstrap_buildroot is not None:
                        self.bootstrap_buildroot.plugins.call_hooks('scrub', scrub)

if scrub == 'all':
                        self.buildroot.root_log.info("scrubbing everything for %s", self.config_name)
                        self.buildroot.delete()
                        file_util.rmtree(self.buildroot.cachedir, selinux=self.buildroot.selinux)
                        if self.bootstrap_buildroot is not None:
                            self.bootstrap_buildroot.delete()
                            file_util.rmtree(self.bootstrap_buildroot.cachedir,
                                             selinux=self.bootstrap_buildroot.selinux)
                    elif scrub == 'chroot':
                        self.buildroot.root_log.info("scrubbing chroot for %s", self.config_name)
                        self.buildroot.delete()
                    elif scrub == 'cache':
                        self.buildroot.root_log.info("scrubbing cache for %s", self.config_name)
                        file_util.rmtree(self.buildroot.cachedir, selinux=self.buildroot.selinux)
                    elif scrub == 'c-cache':
                        self.buildroot.root_log.info("scrubbing c-cache for %s", self.config_name)
                        file_util.rmtree(os.path.join(self.buildroot.cachedir, 'ccache'),
                                         selinux=self.buildroot.selinux)
                    elif scrub == 'root-cache':
                        self.buildroot.root_log.info("scrubbing root-cache for %s", self.config_name)
                        file_util.rmtree(os.path.join(self.buildroot.cachedir, 'root_cache'),
                                         selinux=self.buildroot.selinux)
                    elif scrub in ['yum-cache', 'dnf-cache']:
                        self.buildroot.root_log.info("scrubbing yum-cache and dnf-cache for %s", self.config_name)
                        file_util.rmtree(os.path.join(self.buildroot.cachedir, 'yum_cache'),
                                         selinux=self.buildroot.selinux)
                        file_util.rmtree(os.path.join(self.buildroot.cachedir, 'dnf_cache'),
                                         selinux=self.buildroot.selinux)
                    elif scrub == 'bootstrap' and self.bootstrap_buildroot is not None:
                        self.buildroot.root_log.info("scrubbing bootstrap for %s", self.config_name)
                        self.bootstrap_buildroot.delete()
                        file_util.rmtree(self.bootstrap_buildroot.cachedir, selinux=self.bootstrap_buildroot.selinux)

except IOError as e:
                getLog().warning("parts of chroot do not exist: %s", e)
                raise
        finally:
            self.state.finish(statestr)

@traceLog()
    def make_chroot_path(self, *args):
        '''For safety reasons, self._rootdir should not be used directly. Instead
        use this handy helper function anytime you want to reference a path in
        relation to the chroot.'''
        return self.buildroot.make_chroot_path(*args)

@traceLog()
    def init(self, **kwargs):
        try:
            if self.bootstrap_buildroot is not None:
                file_util.mkdirIfAbsent(self.buildroot.make_chroot_path())
                self.bootstrap_buildroot.initialize(**kwargs)
            self.buildroot.initialize(**kwargs)
            if not self.buildroot.chroot_was_initialized:
                self._show_installed_packages()
        except (KeyboardInterrupt, Exception):
            self.plugins.call_hooks('initfailed')
            # intentionally we do not call bootstrap hook here - it does not have sense
            raise

@traceLog()
    def getPreconfiguredDeps(self, srpms):
        """
        First check that some plugin didn't request installation of additional
        packages into buildroot.

Second, introspect the given array of SRPMs and check whether user did
        not want to install additional packages for them
        (config['more_buildreqs']).

Return the list of additional requirements that should be installed.
        """
        deps = list(self.buildroot.preexisting_deps)

if not self.more_buildreqs:
            # no need to analyze the src.rpm headers for NVR match
            return deps

# Check whether the N/NV/NVR isn't configured to have additional
        # explicit BuildRequires.
        for hdr in util.yieldSrpmHeaders(srpms, plainRpmOk=1):
            # get text buildreqs
            deps.extend(util.getAddtlReqs(hdr, self.more_buildreqs))

return deps

@traceLog()
    def installSrpmDeps(self, *srpms):
        """Figure out deps from srpm. Call package manager to install them"""
        try:
            self.uid_manager.becomeUser(0, 0)

deps = self.getPreconfiguredDeps(srpms)
            if deps:
                self.buildroot.pkg_manager.install(*deps, check=True)

# install actual build dependencies
            self.buildroot.pkg_manager.builddep(*srpms, check=True)
        finally:
            self.uid_manager.restorePrivs()

@traceLog()
    def installSpecDeps(self, spec_file):
        try:
            # pylint: disable=no-member
            spec_file = util.host_file(spec_file)
            spec = rpm.spec(spec_file).sourceHeader.dsFromHeader()
            self.uid_manager.becomeUser(0, 0)
            for i in range(len(spec)): # pylint: disable=consider-using-enumerate
                requirement_name = spec[i][2:]
                self.buildroot.pkg_manager.install(requirement_name, check=True)

finally:
            self.uid_manager.restorePrivs()

@traceLog()
    def _show_installed_packages(self):
        '''report the installed packages in the chroot to the root log'''
        pkgs = self.buildroot.all_chroot_packages()
        self.buildroot.root_log.info("Installed packages:")
        self.buildroot.root_log.info('\n'.join(pkgs))

@traceLog()
    def install_external(self, requires):
        """ requires is list of packages to be install.
        This function extract any external:* and install them.
        """
        external_deps = self.external.extract_external_deps(requires)
        if external_deps:
            if not self.config.get('use_bootstrap'):
                raise Error('ExternalBuildRequires requires `use_bootstrap` to be set on.')
            if self.config.get('external_buildrequires'):
                self.external.install_external_deps(external_deps)
            else:
                raise Error('ExternalBuildRequires are found but support is disabled.'
                            ' See "external_buildrequires" in config_opts.')
    #
    # UNPRIVILEGED:
    #   Everything in this function runs as the build user
    #       -> except hooks. :)
    #
    @traceLog()
    def build(self, srpm, timeout, check=True, spec=None):
        """build an srpm into binary rpms, capture log"""

# tell caching we are building
        self.plugins.call_hooks('earlyprebuild')
        # intentionally we do not call bootstrap hook here - it does not have sense

baserpm = os.path.basename(srpm)

buildstate = "build phase for %s" % baserpm
        self.state.start(buildstate)
        # remove rpm db files to prevent version mismatch problems
        # note: moved to do this before the user change below!
        self.buildroot.nuke_rpm_db()
        dropped_privs = False
        buildsetup_finished = False
        try:
            if not util.USE_NSPAWN:
                self.uid_manager.becomeUser(self.buildroot.chrootuid, self.buildroot.chrootgid)
                dropped_privs = True
            buildsetup = "build setup for %s" % baserpm
            self.state.start(buildsetup)

srpm = self.copy_srpm_into_chroot(srpm)
            self.install_srpm(srpm)

if spec and not self.config['scm']:
                # scm sets options.spec, but we want to get spec from SRPM when using scm
                spec_path = self.copy_spec_into_chroot(spec)
            else:
                spec = self.get_specfile_name(srpm)
                spec_path = os.path.join(self.buildroot.builddir, 'SPECS', spec)

rebuilt_srpm = self.rebuild_installed_srpm(spec_path, timeout)

# Check if we will have dynamic BuildRequires, but do not allow it
            hdr = next(util.yieldSrpmHeaders((rebuilt_srpm,)))
            # pylint: disable=no-member
            requires = {text._to_text(req) for req in hdr[rpm.RPMTAG_REQUIRES]}
            dynamic_buildreqs = 'rpmlib(DynamicBuildRequires)' in requires

if dynamic_buildreqs and not self.config.get('dynamic_buildrequires'):
                raise Error('DynamicBuildRequires are found but support is disabled.'
                            ' See "dynamic_buildrequires" in config_opts.')

self.install_external(requires)
            self.installSrpmDeps(rebuilt_srpm)
            self.state.finish(buildsetup)
            buildsetup_finished = True

rpmbuildstate = "rpmbuild %s" % baserpm

# tell caching we are building
            self.plugins.call_hooks('prebuild')
            # intentionally we do not call bootstrap hook here - it does not have sense

try:
                self.state.start(rpmbuildstate)
                results = self.rebuild_package(spec_path, timeout, check, dynamic_buildreqs)
            finally:
                self.state.finish(rpmbuildstate)

# In the nspawn case, we retained root until here, but we
            # need to ensure our output files are owned by the caller's uid.
            # So drop them now.
            if not dropped_privs:
                self.uid_manager.becomeUser(self.buildroot.chrootuid, self.buildroot.chrootgid)
                dropped_privs = True
            if results:
                self.build_results.extend(self.copy_build_results(results))
            elif self.config.get('short_circuit'):
                self.buildroot.root_log.info("Short circuit builds don't produce RPMs")
            else:
                raise PkgError('No build results found')
            self.state.result = 'success'

finally:
            if not buildsetup_finished:
                self.state.finish(buildsetup)
            self.state.finish(buildstate)
            if dropped_privs:
                self.uid_manager.restorePrivs()
            if self.state.result != 'success':
                self.state.result = 'fail'
            # tell caching we are done building
            self.plugins.call_hooks('postbuild')
            # intentionally we do not call bootstrap hook here - it does not have sense

@traceLog()
    def shell(self, options, cmd=None):
        log = getLog()
        log.debug("shell: calling preshell hooks")
        self.plugins.call_hooks("preshell")
        # intentionally we do not call bootstrap hook here - it does not have sense
        if options.unpriv or self.no_root_shells:
            uid = self.buildroot.chrootuid
            gid = self.buildroot.chrootgid
        else:
            uid = 0
            gid = 0
        cwd = options.cwd
        if not cwd:
            # Hack!  We don't set the cwd here because we know that we work
            # with old systemd-nspawn without --chdir option.  Still, users
            # might use --chdir explicitly and such situation would still
            # result in failure.  rhbz#1976702
            if not util.USE_NSPAWN or util.check_nspawn_has_chdir_option():
                cwd = self.config['chroothome']

try:
            self.state.start("shell")
            ret = util.doshell(chrootPath=self.buildroot.make_chroot_path(),
                               environ=self.buildroot.env, uid=uid, gid=gid,
                               cwd=cwd,
                               nspawn_args=self._get_nspawn_args(),
                               unshare_net=self.private_network,
                               cmd=cmd)
        finally:
            log.debug("shell: unmounting all filesystems")
            self.state.finish("shell")

log.debug("shell: calling postshell hooks")
        self.plugins.call_hooks('postshell')
        # intentionally we do not call bootstrap hook here - it does not have sense
        return ret

@traceLog()
    def chroot(self, args, options):
        log = getLog()
        shell = False
        if len(args) == 1:
            args = [args[0]]
            shell = True
        log.info("Running in chroot: %s", args)
        self.plugins.call_hooks("prechroot")
        # intentionally we do not call bootstrap hook here - it does not have sense
        chrootstate = "chroot %s" % args
        self.state.start(chrootstate)
        result=0
        try:
            if options.unpriv:
                result = self.buildroot.doChroot(args, shell=shell, printOutput=True,
                                                 uid=self.buildroot.chrootuid, gid=self.buildroot.chrootgid,
                                                 user=self.buildroot.chrootuser, cwd=options.cwd,
                                                 nspawn_args=self._get_nspawn_args(), raiseExc=False,
                                                 unshare_net=self.private_network)[1]
            else:
                result = self.buildroot.doChroot(args, shell=shell, cwd=options.cwd,
                                                 nspawn_args=self._get_nspawn_args(),
                                                 unshare_net=self.private_network,
                                                 printOutput=True, raiseExc=False)[1]
        finally:
            self.state.finish(chrootstate)
        self.plugins.call_hooks("postchroot")
        # intentionally we do not call bootstrap hook here - it does not have sense
        return result

@traceLog()
    def chain(self, args, options, buildroot):
        log = getLog()
        if not options.tmp_prefix:
            try:
                options.tmp_prefix = getpass.getuser()
            except Exception:  # pylint: disable=broad-except
                log.error("Could not find login name for tmp dir prefix add --tmp_prefix")
                sys.exit(1)
        pid = os.getpid()
        self.config['uniqueext'] = '{0}-{1}'.format(options.tmp_prefix, pid)

# create a tempdir for our local info
        if options.localrepo:
            local_tmp_dir = os.path.abspath(options.localrepo)
        else:
            pre = 'mock-chain-{0}-'.format(self.config['uniqueext'])
            with self.uid_manager:
                local_tmp_dir = tempfile.mkdtemp(prefix=pre, dir='/var/tmp')

with self.uid_manager:
            self.config['local_repo_dir'] = os.path.normpath(
                local_tmp_dir + '/results/' + self.config['chroot_name'] + '/')
            file_util.mkdirIfAbsent(self.config['local_repo_dir'])

local_baseurl = "file://{0}".format(self.config['local_repo_dir'])
        log.info("results dir: %s", self.config['local_repo_dir'])
        # modify with localrepo
        util.add_local_repo(self.config, local_baseurl, 'local_build_repo',
                            bootstrap=buildroot.bootstrap_buildroot)

with self.uid_manager:
            util.createrepo(self.config, self.config['local_repo_dir'])

built_pkgs = []
        skipped_pkgs = []
        try_again = True
        to_be_built = args
        return_code = 0
        num_of_tries = 0
        while try_again:
            num_of_tries += 1
            failed = []
            for pkg in to_be_built:
                if failed and not options.cont:
                    log.error("Stopping the --chain build because --continue "
                              "isn't specified and the package '%s' failed "
                              "to build", failed[0])
                    break

if not pkg.endswith('.rpm'):
                    log.error("%s doesn't appear to be an rpm - skipping", pkg)
                    failed.append(pkg)
                    continue

with self.uid_manager:
                    pkg_location = pkg
                    pkg = FileDownloader.get(pkg_location)

if not pkg:
                    failed.append(pkg_location)
                    continue

log.info("Start chain build: %s", pkg_location)
                build_ret_code = 0
                try:
                    s_pkg = os.path.basename(pkg)
                    pdn = s_pkg.replace('.src.rpm', '')
                    resultdir = os.path.join(self.config['local_repo_dir'], pdn)
                    self.buildroot.resultdir = resultdir
                    self.buildroot._resetLogging(force=True)
                    file_util.mkdirIfAbsent(resultdir)
                    success_file = os.path.join(resultdir, 'success')
                    build_ret_code = 0
                    try:
                        if os.path.exists(success_file):
                            build_ret_code = 2
                        else:
                            do_rebuild(self.config, self, buildroot, options, [pkg])
                    except Error as err:
                        log.error(str(err))
                        build_ret_code = 1
                except (RootError,) as e:
                    log.warning(e.msg)
                    failed.append(pkg)
                log.info("End chain build: %s", pkg_location)

with self.uid_manager:
                    if build_ret_code == 1:
                        failed.append(pkg)
                        log.info("Error building %s.", os.path.basename(pkg))
                        if options.recurse:
                            log.info("Will try to build again (if some other package will succeed).")
                        else:
                            log.info("See logs/results in %s", self.config['local_repo_dir'])
                            file_util.touch(os.path.join(resultdir, 'fail'))
                    elif build_ret_code == 0:
                        log.info("Success building %s", os.path.basename(pkg))
                        built_pkgs.append(pkg)
                        file_util.touch(success_file)
                        # createrepo with the new pkgs
                        util.createrepo(self.config, self.config['local_repo_dir'])
                    elif build_ret_code == 2:
                        log.info("Skipping already built pkg %s", os.path.basename(pkg))
                        skipped_pkgs.append(pkg)

if failed and options.recurse:
                if len(failed) != len(to_be_built):
                    to_be_built = failed
                    try_again = True
                    log.info('Some package succeeded, some failed.')
                    log.info('Trying to rebuild %s failed pkgs, because --recurse is set.', len(failed))
                else:
                    log.info("Tried %s times - following pkgs could not be successfully built:", num_of_tries)
                    for pkg in failed:
                        msg = FileDownloader.original_name(pkg)
                        log.info(msg)
                    try_again = False
                    return_code = 4
            else:
                try_again = False
                if failed:
                    return_code = 4

FileDownloader.cleanup()

log.info("Results out to: %s", self.config['local_repo_dir'])
        if skipped_pkgs:
            log.info("Packages skipped: %s", len(skipped_pkgs))
            for pkg in skipped_pkgs:
                log.info(pkg)
        log.info("Packages built: %s", len(built_pkgs))
        if built_pkgs:
            if failed:
                if len(built_pkgs):
                    log.info("Some packages successfully built in this order:")
            else:
                log.info("Packages successfully built in this order:")
            for pkg in built_pkgs:
                log.info(pkg)
        return return_code

#
    # UNPRIVILEGED:
    #   Everything in this function runs as the build user
    #       -> except hooks. :)
    #
    @traceLog()
    def buildsrpm(self, spec, sources, timeout, follow_links):
        """build an srpm, capture log"""

# tell caching we are building
        self.plugins.call_hooks('earlyprebuild')
        # intentionally we do not call bootstrap hook here - it does not have sense

try:
            self.uid_manager.becomeUser(self.buildroot.chrootuid, self.buildroot.chrootgid)
            self.state.start("buildsrpm")
            host_chroot_sources = None

# copy spec/sources
            shutil.copy(spec, self.buildroot.make_chroot_path(self.buildroot.builddir, "SPECS"))

if sources:
                # Resolve any symlinks
                sources = os.path.realpath(sources)
                if os.path.isdir(sources):
                    host_chroot_sources = self.buildroot.make_chroot_path(
                        self.buildroot.builddir, "SOURCES")
                    file_util.rmtree(host_chroot_sources)

shutil.copytree(sources,
                                    host_chroot_sources,
                                    symlinks=(not follow_links))
                else:
                    host_chroot_sources = self.buildroot.make_chroot_path(
                        self.buildroot.builddir, "SOURCES", os.path.basename(sources))
                    shutil.copy(sources, host_chroot_sources)

spec = self.buildroot.make_chroot_path(self.buildroot.builddir, "SPECS", os.path.basename(spec))

self.plugins.call_hooks('pre_srpm_build',
                                    spec,
                                    host_chroot_sources)

# get rid of rootdir prefix
            chrootspec = spec.replace(self.buildroot.make_chroot_path(), '')

self.state.start("rpmbuild -bs")
            try:
                rebuilt_srpm = self.rebuild_installed_srpm(chrootspec, timeout)
            finally:
                self.state.finish("rpmbuild -bs")

srpm_basename = os.path.basename(rebuilt_srpm)

self.buildroot.root_log.debug("Copying package to result dir")
            shutil.copy2(rebuilt_srpm, self.buildroot.resultdir)

return os.path.join(self.buildroot.resultdir, srpm_basename)

finally:
            self.uid_manager.restorePrivs()

# tell caching we are done building
            self.plugins.call_hooks('postbuild')
            # intentionally we do not call bootstrap hook here - it does not have sense
            self.state.finish("buildsrpm")

#
    # UNPRIVILEGED:
    #   Everything in this function runs as the build user
    #
    @traceLog()
    def copy_srpm_into_chroot(self, srpm_path):
        srpmFilename = os.path.basename(srpm_path)
        dest = self.buildroot.make_chroot_path(self.buildroot.builddir, 'originals')
        shutil.copyfile(srpm_path, os.path.join(dest, srpmFilename))
        return os.path.join(self.buildroot.builddir, 'originals', srpmFilename)

@traceLog()
    def copy_spec_into_chroot(self, spec_path):
        specFilename = os.path.basename(spec_path)
        dest = self.buildroot.make_chroot_path(self.buildroot.builddir, 'originals')
        shutil.copy2(spec_path, os.path.join(dest, specFilename))
        return os.path.join(self.buildroot.builddir, 'originals', specFilename)

@traceLog()
    def get_specfile_name(self, srpm_path):
        files = self.buildroot.doChroot([self.config['rpm_command'], "-qpl", srpm_path],
                                        shell=False, uid=self.buildroot.chrootuid, gid=self.buildroot.chrootgid,
                                        nspawn_args=self._get_nspawn_args(),
                                        unshare_net=self.private_network,
                                        user=self.buildroot.chrootuser,
                                        returnOutput=True
                                       )[0]
        specs = [item.rstrip() for item in files.split('\n') if item.rstrip().endswith('.spec')]
        if len(specs) < 1:
            raise PkgError(
                "No specfile found in srpm: " + os.path.basename(srpm_path))
        return specs[0]

@traceLog()
    def install_srpm(self, srpm_path):
        command = [self.config['rpm_command'], "-Uvh", "--nodeps", srpm_path]
        output, return_code = self.buildroot.doChroot(
            command, shell=False, uid=self.buildroot.chrootuid,
            gid=self.buildroot.chrootgid, user=self.buildroot.chrootuser,
            nspawn_args=self._get_nspawn_args(),
            unshare_net=self.private_network, returnOutput=True,
            returnStderr=True, raiseExc=False)
        if return_code:
            raise PkgError("Source RPM is not installable:\n{0}".format(output))

@traceLog()
    def rebuild_installed_srpm(self, spec_path, timeout):
        command = ['{command} -bs --target {0} --nodeps {1}'.format(
            self.rpmbuild_arch, spec_path,
            command=self.config['rpmbuild_command'])]
        command = ["bash", "--login", "-c"] + command
        self.buildroot.doChroot(
            command,
            shell=False, logger=self.buildroot.build_log, timeout=timeout,
            uid=self.buildroot.chrootuid, gid=self.buildroot.chrootgid,
            user=self.buildroot.chrootuser,
            nspawn_args=self._get_nspawn_args(),
            unshare_net=self.private_network,
            printOutput=self.config['print_main_output']
        )
        results = glob.glob("%s/%s/SRPMS/*src.rpm" % (self.make_chroot_path(),
                                                      self.buildroot.builddir))
        if len(results) != 1:
            raise PkgError("Expected to find single rebuilt srpm, found %d in %s"
                           % (len(results), "%s/%s/SRPMS/*src.rpm" % (self.make_chroot_path(),
                                                                      self.buildroot.builddir)))
        return results[0]

@traceLog()
    def rebuild_package(self, spec_path, timeout, check, dynamic_buildrequires):
        # --nodeps because rpm in the root may not be able to read rpmdb
        # created by rpm that created it (outside of chroot)
        check_opt = []
        if not check:
            # this is because EL5/6 does not know --nocheck
            # when EL5/6 targets are not supported, replace it with --nocheck
            check_opt += ["--define", "'__spec_check_template exit 0; '"]

mode = ['-bb']
        sc = self.config.get('short_circuit')
        if sc:
            mode[0] = {'prep': '-bp',
                       'install': '-bi',
                       'build': '-bc',
                       'binary': '-bb'}[sc]
            mode += ['--short-circuit']
        additional_opts = [self.config.get('rpmbuild_opts', '')]
        if additional_opts == ['']:
            additional_opts = []

def get_command(mode):
            command = [self.config['rpmbuild_command']] + mode + \
                      ['--target', self.rpmbuild_arch, '--nodeps'] + \
                      check_opt + [spec_path] + additional_opts
            command = ["bash", "--login", "-c"] + [' '.join(command)]
            return command

bd_out = self.make_chroot_path(self.buildroot.builddir)
        max_loops = int(self.config.get('dynamic_buildrequires_max_loops'))
        success = False
        if dynamic_buildrequires and self.config.get('dynamic_buildrequires'):
            while not success and max_loops > 0:
                # run rpmbuild+installSrpmDeps until
                # * it fails
                # * installSrpmDeps does nothing
                # * or we run out of dynamic_buildrequires_max_loops tries
                packages_before = self.buildroot.all_chroot_packages()
                command = get_command(['-br'])
                (output, returncode) = \
                    self.buildroot.doChroot(command,
                                            shell=False, logger=self.buildroot.build_log, timeout=timeout,
                                            uid=self.buildroot.chrootuid, gid=self.buildroot.chrootgid,
                                            user=self.buildroot.chrootuser,
                                            nspawn_args=self._get_nspawn_args(),
                                            unshare_net=self.private_network, raiseExc=False,
                                            printOutput=self.config['print_main_output'])
                if returncode > 0 and returncode != 11:
                    # we treat exit status 11 as success, as well as exit
                    # status 0, see issue#434
                    raise BuildError("Command failed: \n # %s\n%s" % (command, output))
                max_loops -= 1
                self.buildroot.build_log.info("Dynamic buildrequires detected")
                self.buildroot.build_log.info("Going to install missing buildrequires. See root.log for details.")
                self.buildroot.root_log.info("Going to install missing dynamic buildrequires")
                buildreqs = glob.glob(bd_out + '/SRPMS/*.buildreqs.nosrc.rpm')
                self.installSrpmDeps(*buildreqs)
                packages_after = self.buildroot.all_chroot_packages()
                if packages_after == packages_before:
                    success = True
                for f_buildreqs in buildreqs:
                    os.remove(f_buildreqs)
                if not sc:
                    # We want to (re-)write src.rpm with dynamic BuildRequires,
                    # but with short-circuit it doesn't matter
                    mode = ['-ba']
                # rpmbuild -br already does %prep, so we don't need waste time
                # on re-doing it
                mode += ['--noprep']

self.buildroot.doChroot(get_command(mode),
                                shell=False, logger=self.buildroot.build_log, timeout=timeout,
                                uid=self.buildroot.chrootuid, gid=self.buildroot.chrootgid,
                                user=self.buildroot.chrootuser,
                                nspawn_args=self._get_nspawn_args(),
                                unshare_net=self.private_network,
                                printOutput=self.config['print_main_output'])
        results = glob.glob(bd_out + '/RPMS/*.rpm')
        results += glob.glob(bd_out + '/SRPMS/*.rpm')
        self.buildroot.final_rpm_list = [os.path.basename(result) for result in results]
        return results

@traceLog()
    def copy_build_results(self, results):
        self.buildroot.root_log.debug("Copying packages to result dir")
        ret = []
        for item in results:
            shutil.copy2(item, self.buildroot.resultdir)
            ret.append(os.path.join(self.buildroot.resultdir, os.path.split(item)[1]))
        return ret

@traceLog()
    def install_build_results(self, results):
        self.buildroot.root_log.info("Installing built packages")

# Mount resultdir into bootstrap, so we can later install the build
        # results from there using bootstrap package manager.

results_bindmount = None
        if self.bootstrap_buildroot:
            resultdir = self.buildroot.resultdir
            bootstrap_resultdir = self.bootstrap_buildroot.make_chroot_path(resultdir)
            results_bindmount = BindMountPoint(resultdir, bootstrap_resultdir,
                                               options="private")
        try:
            self.uid_manager.becomeUser(0, 0)
            if results_bindmount:
                results_bindmount.mount()
            pkgs = [pkg for pkg in results if not pkg.endswith("src.rpm")]
            try:
                self.buildroot.install(*pkgs)
            # pylint: disable=bare-except
            except:
                self.buildroot.root_log.warning("Failed install built packages")
        finally:
            if results_bindmount:
                results_bindmount.umount()
            self.uid_manager.restorePrivs()