# Copyright 2005 Duke University

# Copyright (C) 2012-2018 Red Hat, Inc.

#

# 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; either version 2 of the License, or

# (at your option) any later version.

#

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

"""

Supplies the Base class.

"""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

from __future__ import unicode_literals

import argparse

import dnf

import libdnf.transaction

from dnf.comps import CompsQuery

from dnf.i18n import _, P_, ucd

from dnf.util import _parse_specs

from dnf.db.history import SwdbInterface

from dnf.yum import misc

from functools import reduce

try:

    from collections.abc import Sequence

except ImportError:

    from collections import Sequence

import datetime

import dnf.callback

import dnf.comps

import dnf.conf

import dnf.conf.read

import dnf.crypto

import dnf.dnssec

import dnf.drpm

import dnf.exceptions

import dnf.goal

import dnf.history

import dnf.lock

import dnf.logging

# WITH_MODULES is used by ansible (lib/ansible/modules/packaging/os/dnf.py)

try:

    import dnf.module.module_base

    WITH_MODULES = True

except ImportError:

    WITH_MODULES = False

import dnf.persistor

import dnf.plugin

import dnf.query

import dnf.repo

import dnf.repodict

import dnf.rpm.connection

import dnf.rpm.miscutils

import dnf.rpm.transaction

import dnf.sack

import dnf.selector

import dnf.subject

import dnf.transaction

import dnf.util

import dnf.yum.rpmtrans

import functools

import hawkey

import itertools

import logging

import math

import os

import operator

import re

import rpm

import time

import shutil

logger = logging.getLogger("dnf")

class Base(object):

    def __init__(self, conf=None):

        # :api

        self._closed = False

        self._conf = conf or self._setup_default_conf()

        self._goal = None

        self._repo_persistor = None

        self._sack = None

        self._transaction = None

        self._priv_ts = None

        self._comps = None

        self._comps_trans = dnf.comps.TransactionBunch()

        self._history = None

        self._tempfiles = set()

        self._trans_tempfiles = set()

        self._ds_callback = dnf.callback.Depsolve()

        self._logging = dnf.logging.Logging()

        self._repos = dnf.repodict.RepoDict()

        self._rpm_probfilter = set([rpm.RPMPROB_FILTER_OLDPACKAGE])

        self._plugins = dnf.plugin.Plugins()

        self._trans_success = False

        self._trans_install_set = False

        self._tempfile_persistor = None

        self._update_security_filters = []

        self._allow_erasing = False

        self._repo_set_imported_gpg_keys = set()

        self.output = None

    def __enter__(self):

        return self

    def __exit__(self, *exc_args):

        self.close()

    def __del__(self):

        self.close()

    def _add_tempfiles(self, files):

        if self._transaction:

            self._trans_tempfiles.update(files)

        elif self.conf.destdir:

            pass

        else:

            self._tempfiles.update(files)

    def _add_repo_to_sack(self, repo):

        repo.load()

        mdload_flags = dict(load_filelists=True,

                            load_presto=repo.deltarpm,

                            load_updateinfo=True)

        if repo.load_metadata_other:

            mdload_flags["load_other"] = True

        try:

            self._sack.load_repo(repo._repo, build_cache=True, **mdload_flags)

        except hawkey.Exception as e:

            logger.debug(_("loading repo '{}' failure: {}").format(repo.id, e))

            raise dnf.exceptions.RepoError(

                _("Loading repository '{}' has failed").format(repo.id))

    @staticmethod

    def _setup_default_conf():

        conf = dnf.conf.Conf()

        subst = conf.substitutions

        if 'releasever' not in subst:

            subst['releasever'] = \

                dnf.rpm.detect_releasever(conf.installroot)

        return conf

    def _setup_modular_excludes(self):

        hot_fix_repos = [i.id for i in self.repos.iter_enabled() if i.module_hotfixes]

        try:

            solver_errors = self.sack.filter_modules(

                self._moduleContainer, hot_fix_repos, self.conf.installroot,

                self.conf.module_platform_id, update_only=False, debugsolver=self.conf.debug_solver)

        except hawkey.Exception as e:

            raise dnf.exceptions.Error(ucd(e))

        if solver_errors:

            logger.warning(

                dnf.module.module_base.format_modular_solver_errors(solver_errors[0]))

    def _setup_excludes_includes(self, only_main=False):

        disabled = set(self.conf.disable_excludes)

        if 'all' in disabled and WITH_MODULES:

            self._setup_modular_excludes()

            return

        repo_includes = []

        repo_excludes = []

        # first evaluate repo specific includes/excludes

        if not only_main:

            for r in self.repos.iter_enabled():

                if r.id in disabled:

                    continue

                if len(r.includepkgs) > 0:

                    incl_query = self.sack.query().filterm(empty=True)

                    for incl in set(r.includepkgs):

                        subj = dnf.subject.Subject(incl)

                        incl_query = incl_query.union(subj.get_best_query(

                            self.sack, with_nevra=True, with_provides=False, with_filenames=False))

                    incl_query.filterm(reponame=r.id)

                    repo_includes.append((incl_query.apply(), r.id))

                excl_query = self.sack.query().filterm(empty=True)

                for excl in set(r.excludepkgs):

                    subj = dnf.subject.Subject(excl)

                    excl_query = excl_query.union(subj.get_best_query(

                        self.sack, with_nevra=True, with_provides=False, with_filenames=False))

                excl_query.filterm(reponame=r.id)

                if excl_query:

                    repo_excludes.append((excl_query, r.id))

        # then main (global) includes/excludes because they can mask

        # repo specific settings

        if 'main' not in disabled:

            include_query = self.sack.query().filterm(empty=True)

            if len(self.conf.includepkgs) > 0:

                for incl in set(self.conf.includepkgs):

                    subj = dnf.subject.Subject(incl)

                    include_query = include_query.union(subj.get_best_query(

                        self.sack, with_nevra=True, with_provides=False, with_filenames=False))

            exclude_query = self.sack.query().filterm(empty=True)

            for excl in set(self.conf.excludepkgs):

                subj = dnf.subject.Subject(excl)

                exclude_query = exclude_query.union(subj.get_best_query(

                    self.sack, with_nevra=True, with_provides=False, with_filenames=False))

            if len(self.conf.includepkgs) > 0:

                self.sack.add_includes(include_query)

                self.sack.set_use_includes(True)

            if exclude_query:

                self.sack.add_excludes(exclude_query)

        if repo_includes:

            for query, repoid in repo_includes:

                self.sack.add_includes(query)

                self.sack.set_use_includes(True, repoid)

        if repo_excludes:

            for query, repoid in repo_excludes:

                self.sack.add_excludes(query)

        if not only_main and WITH_MODULES:

            self._setup_modular_excludes()

    def _store_persistent_data(self):

        if self._repo_persistor and not self.conf.cacheonly:

            expired = [r.id for r in self.repos.iter_enabled()

                       if (r.metadata and r._repo.isExpired())]

            self._repo_persistor.expired_to_add.update(expired)

            self._repo_persistor.save()

        if self._tempfile_persistor:

            self._tempfile_persistor.save()

    @property

    def comps(self):

        # :api

        return self._comps

    @property

    def conf(self):

        # :api

        return self._conf

    @property

    def repos(self):

        # :api

        return self._repos

    @repos.deleter

    def repos(self):

        # :api

        self._repos = None

    @property

    @dnf.util.lazyattr("_priv_rpmconn")

    def _rpmconn(self):

        return dnf.rpm.connection.RpmConnection(self.conf.installroot)

    @property

    def sack(self):

        # :api

        return self._sack

    @property

    def _moduleContainer(self):

        if self.sack is None:

            raise dnf.exceptions.Error("Sack was not initialized")

        if self.sack._moduleContainer is None:

            self.sack._moduleContainer = libdnf.module.ModulePackageContainer(

                False, self.conf.installroot, self.conf.substitutions["arch"], self.conf.persistdir)

        return self.sack._moduleContainer

    @property

    def transaction(self):

        # :api

        return self._transaction

    @transaction.setter

    def transaction(self, value):

        # :api

        if self._transaction:

            raise ValueError('transaction already set')

        self._transaction = value

    def _activate_persistor(self):

        self._repo_persistor = dnf.persistor.RepoPersistor(self.conf.cachedir)

    def init_plugins(self, disabled_glob=(), enable_plugins=(), cli=None):

        # :api

        """Load plugins and run their __init__()."""

        if self.conf.plugins:

            self._plugins._load(self.conf, disabled_glob, enable_plugins)

        self._plugins._run_init(self, cli)

    def pre_configure_plugins(self):

        # :api

        """Run plugins pre_configure() method."""

        self._plugins._run_pre_config()

    def configure_plugins(self):

        # :api

        """Run plugins configure() method."""

        self._plugins._run_config()

    def update_cache(self, timer=False):

        # :api

        period = self.conf.metadata_timer_sync

        persistor = self._repo_persistor

        if timer:

            if dnf.util.on_metered_connection():

                msg = _('Metadata timer caching disabled '

                        'when running on metered connection.')

                logger.info(msg)

                return False

            if dnf.util.on_ac_power() is False:

                msg = _('Metadata timer caching disabled '

                        'when running on a battery.')

                logger.info(msg)

                return False

            if period <= 0:

                msg = _('Metadata timer caching disabled.')

                logger.info(msg)

                return False

            since_last_makecache = persistor.since_last_makecache()

            if since_last_makecache is not None and since_last_makecache < period:

                logger.info(_('Metadata cache refreshed recently.'))

                return False

            for repo in self.repos.values():

                repo._repo.setMaxMirrorTries(1)

        if not self.repos._any_enabled():

            logger.info(_('There are no enabled repositories in "{}".').format(

                '", "'.join(self.conf.reposdir)))

            return False

        for r in self.repos.iter_enabled():

            (is_cache, expires_in) = r._metadata_expire_in()

            if expires_in is None:

                logger.info(_('%s: will never be expired and will not be refreshed.'), r.id)

            elif not is_cache or expires_in <= 0:

                logger.debug(_('%s: has expired and will be refreshed.'), r.id)

                r._repo.expire()

            elif timer and expires_in < period:

                # expires within the checking period:

                msg = _("%s: metadata will expire after %d seconds and will be refreshed now")

                logger.debug(msg, r.id, expires_in)

                r._repo.expire()

            else:

                logger.debug(_('%s: will expire after %d seconds.'), r.id,

                             expires_in)

        if timer:

            persistor.reset_last_makecache = True

        self.fill_sack(load_system_repo=False, load_available_repos=True)  # performs the md sync

        logger.info(_('Metadata cache created.'))

        return True

    def fill_sack(self, load_system_repo=True, load_available_repos=True):

        # :api

        """Prepare the Sack and the Goal objects. """

        timer = dnf.logging.Timer('sack setup')

        self.reset(sack=True, goal=True)

        self._sack = dnf.sack._build_sack(self)

        lock = dnf.lock.build_metadata_lock(self.conf.cachedir, self.conf.exit_on_lock)

        with lock:

            if load_system_repo is not False:

                try:

                    # FIXME: If build_cache=True, @System.solv is incorrectly updated in install-

                    # remove loops

                    self._sack.load_system_repo(build_cache=False)

                except IOError:

                    if load_system_repo != 'auto':

                        raise

            if load_available_repos:

                error_repos = []

                mts = 0

                age = time.time()

                # Iterate over installed GPG keys and check their validity using DNSSEC

                if self.conf.gpgkey_dns_verification:

                    dnf.dnssec.RpmImportedKeys.check_imported_keys_validity()

                for r in self.repos.iter_enabled():

                    try:

                        self._add_repo_to_sack(r)

                        if r._repo.getTimestamp() > mts:

                            mts = r._repo.getTimestamp()

                        if r._repo.getAge() < age:

                            age = r._repo.getAge()

                        logger.debug(_("%s: using metadata from %s."), r.id,

                                     dnf.util.normalize_time(

                                         r._repo.getMaxTimestamp()))

                    except dnf.exceptions.RepoError as e:

                        r._repo.expire()

                        if r.skip_if_unavailable is False:

                            raise

                        logger.warning("Error: %s", e)

                        error_repos.append(r.id)

                        r.disable()

                if error_repos:

                    logger.warning(

                        _("Ignoring repositories: %s"), ', '.join(error_repos))

                if self.repos._any_enabled():

                    if age != 0 and mts != 0:

                        logger.info(_("Last metadata expiration check: %s ago on %s."),

                                    datetime.timedelta(seconds=int(age)),

                                    dnf.util.normalize_time(mts))

            else:

                self.repos.all().disable()

        conf = self.conf

        self._sack._configure(conf.installonlypkgs, conf.installonly_limit, conf.allow_vendor_change)

        self._setup_excludes_includes()

        timer()

        self._goal = dnf.goal.Goal(self._sack)

        self._goal.protect_running_kernel = conf.protect_running_kernel

        self._plugins.run_sack()

        return self._sack

    def _finalize_base(self):

        self._tempfile_persistor = dnf.persistor.TempfilePersistor(

            self.conf.cachedir)

        if not self.conf.keepcache:

            self._clean_packages(self._tempfiles)

            if self._trans_success:

                self._trans_tempfiles.update(

                    self._tempfile_persistor.get_saved_tempfiles())

                self._tempfile_persistor.empty()

                if self._trans_install_set:

                    self._clean_packages(self._trans_tempfiles)

            else:

                self._tempfile_persistor.tempfiles_to_add.update(

                    self._trans_tempfiles)

        if self._tempfile_persistor.tempfiles_to_add:

            logger.info(_("The downloaded packages were saved in cache "

                          "until the next successful transaction."))

            logger.info(_("You can remove cached packages by executing "

                          "'%s'."), "{prog} clean packages".format(prog=dnf.util.MAIN_PROG))

        # Do not trigger the lazy creation:

        if self._history is not None:

            self.history.close()

        self._store_persistent_data()

        self._closeRpmDB()

        self._trans_success = False

    def close(self):

        # :api

        """Close all potential handles and clean cache.

        Typically the handles are to data sources and sinks.

        """

        if self._closed:

            return

        logger.log(dnf.logging.DDEBUG, 'Cleaning up.')

        self._closed = True

        self._finalize_base()

        self.reset(sack=True, repos=True, goal=True)

    def read_all_repos(self, opts=None):

        # :api

        """Read repositories from the main conf file and from .repo files."""

        reader = dnf.conf.read.RepoReader(self.conf, opts)

        for repo in reader:

            try:

                self.repos.add(repo)

            except dnf.exceptions.ConfigError as e:

                logger.warning(e)

    def reset(self, sack=False, repos=False, goal=False):

        # :api

        """Make the Base object forget about various things."""

        if sack:

            self._sack = None

        if repos:

            self._repos = dnf.repodict.RepoDict()

        if goal:

            self._goal = None

            if self._sack is not None:

                self._goal = dnf.goal.Goal(self._sack)

                self._goal.protect_running_kernel = self.conf.protect_running_kernel

            if self._sack and self._moduleContainer:

                # sack must be set to enable operations on moduleContainer

                self._moduleContainer.rollback()

            if self._history is not None:

                self.history.close()

            self._comps_trans = dnf.comps.TransactionBunch()

            self._transaction = None

    def _closeRpmDB(self):

        """Closes down the instances of rpmdb that could be open."""

        del self._ts

    _TS_FLAGS_TO_RPM = {'noscripts': rpm.RPMTRANS_FLAG_NOSCRIPTS,

                        'notriggers': rpm.RPMTRANS_FLAG_NOTRIGGERS,

                        'nodocs': rpm.RPMTRANS_FLAG_NODOCS,

                        'test': rpm.RPMTRANS_FLAG_TEST,

                        'justdb': rpm.RPMTRANS_FLAG_JUSTDB,

                        'nocontexts': rpm.RPMTRANS_FLAG_NOCONTEXTS,

                        'nocrypto': rpm.RPMTRANS_FLAG_NOFILEDIGEST}

    if hasattr(rpm, 'RPMTRANS_FLAG_NOCAPS'):

        # Introduced in rpm-4.14

        _TS_FLAGS_TO_RPM['nocaps'] = rpm.RPMTRANS_FLAG_NOCAPS

    _TS_VSFLAGS_TO_RPM = {'nocrypto': rpm._RPMVSF_NOSIGNATURES |

                          rpm._RPMVSF_NODIGESTS}

    @property

    def goal(self):

        return self._goal

    @property

    def _ts(self):

        """Set up the RPM transaction set that will be used

           for all the work."""

        if self._priv_ts is not None:

            return self._priv_ts

        self._priv_ts = dnf.rpm.transaction.TransactionWrapper(

            self.conf.installroot)

        self._priv_ts.setFlags(0)  # reset everything.

        for flag in self.conf.tsflags:

            rpm_flag = self._TS_FLAGS_TO_RPM.get(flag)

            if rpm_flag is None:

                logger.critical(_('Invalid tsflag in config file: %s'), flag)

                continue

            self._priv_ts.addTsFlag(rpm_flag)

            vs_flag = self._TS_VSFLAGS_TO_RPM.get(flag)

            if vs_flag is not None:

                self._priv_ts.pushVSFlags(vs_flag)

        if not self.conf.diskspacecheck:

            self._rpm_probfilter.add(rpm.RPMPROB_FILTER_DISKSPACE)

        if self.conf.ignorearch:

            self._rpm_probfilter.add(rpm.RPMPROB_FILTER_IGNOREARCH)

        probfilter = reduce(operator.or_, self._rpm_probfilter, 0)

        self._priv_ts.setProbFilter(probfilter)

        return self._priv_ts

    @_ts.deleter

    def _ts(self):

        """Releases the RPM transaction set. """

        if self._priv_ts is None:

            return

        self._priv_ts.close()

        del self._priv_ts

        self._priv_ts = None

    def read_comps(self, arch_filter=False):

        # :api

        """Create the groups object to access the comps metadata."""

        timer = dnf.logging.Timer('loading comps')

        self._comps = dnf.comps.Comps()

        logger.log(dnf.logging.DDEBUG, 'Getting group metadata')

        for repo in self.repos.iter_enabled():

            if not repo.enablegroups:

                continue

            if not repo.metadata:

                continue

            comps_fn = repo._repo.getCompsFn()

            if not comps_fn:

                continue

            logger.log(dnf.logging.DDEBUG,

                       'Adding group file from repository: %s', repo.id)

            if repo._repo.getSyncStrategy() == dnf.repo.SYNC_ONLY_CACHE:

                decompressed = misc.calculate_repo_gen_dest(comps_fn,

                                                            'groups.xml')

                if not os.path.exists(decompressed):

                    # root privileges are needed for comps decompression

                    continue

            else:

                decompressed = misc.repo_gen_decompress(comps_fn, 'groups.xml')

            try:

                self._comps._add_from_xml_filename(decompressed)

            except dnf.exceptions.CompsError as e:

                msg = _('Failed to add groups file for repository: %s - %s')

                logger.critical(msg, repo.id, e)

        if arch_filter:

            self._comps._i.arch_filter(

                [self._conf.substitutions['basearch']])

        timer()

        return self._comps

    def _getHistory(self):

        """auto create the history object that to access/append the transaction

           history information. """

        if self._history is None:

            releasever = self.conf.releasever

            self._history = SwdbInterface(self.conf.persistdir, releasever=releasever)

        return self._history

    history = property(fget=lambda self: self._getHistory(),

                       fset=lambda self, value: setattr(

                           self, "_history", value),

                       fdel=lambda self: setattr(self, "_history", None),

                       doc="DNF SWDB Interface Object")

    def _goal2transaction(self, goal):

        ts = self.history.rpm

        all_obsoleted = set(goal.list_obsoleted())

        installonly_query = self._get_installonly_query()

        for pkg in goal.list_downgrades():

            obs = goal.obsoleted_by_package(pkg)

            downgraded = obs[0]

            self._ds_callback.pkg_added(downgraded, 'dd')

            self._ds_callback.pkg_added(pkg, 'd')

            ts.add_downgrade(pkg, downgraded, obs[1:])

        for pkg in goal.list_reinstalls():

            self._ds_callback.pkg_added(pkg, 'r')

            obs = goal.obsoleted_by_package(pkg)

            nevra_pkg = str(pkg)

            # reinstall could obsolete multiple packages with the same NEVRA or different NEVRA

            # Set the package with the same NEVRA as reinstalled

            obsoletes = []

            for obs_pkg in obs:

                if str(obs_pkg) == nevra_pkg:

                    obsoletes.insert(0, obs_pkg)

                else:

                    obsoletes.append(obs_pkg)

            reinstalled = obsoletes[0]

            ts.add_reinstall(pkg, reinstalled, obsoletes[1:])

        for pkg in goal.list_installs():

            self._ds_callback.pkg_added(pkg, 'i')

            obs = goal.obsoleted_by_package(pkg)

            # Skip obsoleted packages that are not part of all_obsoleted,

            # they are handled as upgrades/downgrades.

            # Also keep RPMs with the same name - they're not always in all_obsoleted.

            obs = [i for i in obs if i in all_obsoleted or i.name == pkg.name]

            reason = goal.get_reason(pkg)

            if pkg in installonly_query:

                reason_installonly = ts.get_reason(pkg)

                if libdnf.transaction.TransactionItemReasonCompare(

                        reason, reason_installonly) == -1:

                    reason = reason_installonly

            # inherit the best reason from obsoleted packages

            for obsolete in obs:

                reason_obsolete = ts.get_reason(obsolete)

                if libdnf.transaction.TransactionItemReasonCompare(reason, reason_obsolete) == -1:

                    reason = reason_obsolete

            ts.add_install(pkg, obs, reason)

            cb = lambda pkg: self._ds_callback.pkg_added(pkg, 'od')

            dnf.util.mapall(cb, obs)

        for pkg in goal.list_upgrades():

            obs = goal.obsoleted_by_package(pkg)

            upgraded = None

            for i in obs:

                # try to find a package with matching name as the upgrade

                if i.name == pkg.name:

                    upgraded = i

                    break

            if upgraded is None:

                # no matching name -> pick the first one

                upgraded = obs.pop(0)

            else:

                obs.remove(upgraded)

            # Skip obsoleted packages that are not part of all_obsoleted,

            # they are handled as upgrades/downgrades.

            # Also keep RPMs with the same name - they're not always in all_obsoleted.

            obs = [i for i in obs if i in all_obsoleted or i.name == pkg.name]

            cb = lambda pkg: self._ds_callback.pkg_added(pkg, 'od')

            dnf.util.mapall(cb, obs)

            if pkg in installonly_query:

                ts.add_install(pkg, obs)

            else:

                ts.add_upgrade(pkg, upgraded, obs)

                self._ds_callback.pkg_added(upgraded, 'ud')

            self._ds_callback.pkg_added(pkg, 'u')

        for pkg in goal.list_erasures():

            self._ds_callback.pkg_added(pkg, 'e')

            reason = goal.get_reason(pkg)

            ts.add_erase(pkg, reason)

        return ts

    def _query_matches_installed(self, q):

        """ See what packages in the query match packages (also in older

            versions, but always same architecture) that are already installed.

            Unlike in case of _sltr_matches_installed(), it is practical here

            to know even the packages in the original query that can still be

            installed.

        """

        inst = q.installed()

        inst_per_arch = inst._na_dict()

        avail_per_arch = q.available()._na_dict()

        avail_l = []

        inst_l = []

        for na in avail_per_arch:

            if na in inst_per_arch:

                inst_l.append(inst_per_arch[na][0])

            else:

                avail_l.append(avail_per_arch[na])

        return inst_l, avail_l

    def _sltr_matches_installed(self, sltr):

        """ See if sltr matches a patches that is (in older version or different

            architecture perhaps) already installed.

        """

        inst = self.sack.query().installed().filterm(pkg=sltr.matches())

        return list(inst)

    def iter_userinstalled(self):

        """Get iterator over the packages installed by the user."""

        return (pkg for pkg in self.sack.query().installed()

                if self.history.user_installed(pkg))

    def _run_hawkey_goal(self, goal, allow_erasing):

        ret = goal.run(

            allow_uninstall=allow_erasing, force_best=self.conf.best,

            ignore_weak_deps=(not self.conf.install_weak_deps))

        if self.conf.debug_solver:

            goal.write_debugdata('./debugdata/rpms')

        return ret

    def resolve(self, allow_erasing=False):

        # :api

        """Build the transaction set."""

        exc = None

        self._finalize_comps_trans()

        timer = dnf.logging.Timer('depsolve')

        self._ds_callback.start()

        goal = self._goal

        if goal.req_has_erase():

            goal.push_userinstalled(self.sack.query().installed(),

                                    self.history)

        elif not self.conf.upgrade_group_objects_upgrade:

            # exclude packages installed from groups

            # these packages will be marked to installation

            # which could prevent them from upgrade, downgrade

            # to prevent "conflicting job" error it's not applied

            # to "remove" and "reinstall" commands

            solver = self._build_comps_solver()

            solver._exclude_packages_from_installed_groups(self)

        goal.add_protected(self.sack.query().filterm(

            name=self.conf.protected_packages))

        if not self._run_hawkey_goal(goal, allow_erasing):

            if self.conf.debuglevel >= 6:

                goal.log_decisions()

            msg = dnf.util._format_resolve_problems(goal.problem_rules())

            exc = dnf.exceptions.DepsolveError(msg)

        else:

            self._transaction = self._goal2transaction(goal)

        self._ds_callback.end()

        timer()

        got_transaction = self._transaction is not None and \

            len(self._transaction) > 0

        if got_transaction:

            msg = self._transaction._rpm_limitations()

            if msg:

                exc = dnf.exceptions.Error(msg)

        if exc is not None:

            raise exc

        self._plugins.run_resolved()

        # auto-enable module streams based on installed RPMs

        new_pkgs = self._goal.list_installs()

        new_pkgs += self._goal.list_upgrades()

        new_pkgs += self._goal.list_downgrades()

        new_pkgs += self._goal.list_reinstalls()

        self.sack.set_modules_enabled_by_pkgset(self._moduleContainer, new_pkgs)

        return got_transaction

    def do_transaction(self, display=()):

        # :api

        if not isinstance(display, Sequence):

            display = [display]

        display = \

            [dnf.yum.rpmtrans.LoggingTransactionDisplay()] + list(display)

        if not self.transaction:

            # packages are not changed, but comps and modules changes need to be committed

            self._moduleContainer.save()

            self._moduleContainer.updateFailSafeData()

            if self._history and (self._history.group or self._history.env):

                cmdline = None

                if hasattr(self, 'args') and self.args:

                    cmdline = ' '.join(self.args)

                elif hasattr(self, 'cmds') and self.cmds:

                    cmdline = ' '.join(self.cmds)

                old = self.history.last()

                if old is None:

                    rpmdb_version = self.sack._rpmdb_version()

                else:

                    rpmdb_version = old.end_rpmdb_version

                self.history.beg(rpmdb_version, [], [], cmdline)

                self.history.end(rpmdb_version)

            self._plugins.run_pre_transaction()

            self._plugins.run_transaction()

            self._trans_success = True

            return

        tid = None

        logger.info(_('Running transaction check'))

        lock = dnf.lock.build_rpmdb_lock(self.conf.persistdir,

                                         self.conf.exit_on_lock)

        with lock:

            self.transaction._populate_rpm_ts(self._ts)

            msgs = self._run_rpm_check()

            if msgs:

                msg = _('Error: transaction check vs depsolve:')

                logger.error(msg)

                for msg in msgs:

                    logger.error(msg)

                raise dnf.exceptions.TransactionCheckError(msg)

            logger.info(_('Transaction check succeeded.'))

            timer = dnf.logging.Timer('transaction test')

            logger.info(_('Running transaction test'))

            self._ts.order()  # order the transaction

            self._ts.clean()  # release memory not needed beyond this point

            testcb = dnf.yum.rpmtrans.RPMTransaction(self, test=True)

            tserrors = self._ts.test(testcb)

            if len(tserrors) > 0:

                for msg in testcb.messages():

                    logger.critical(_('RPM: {}').format(msg))

                errstring = _('Transaction test error:') + '\n'

                for descr in tserrors:

                    errstring += '  %s\n' % ucd(descr)

                summary = self._trans_error_summary(errstring)

                if summary:

                    errstring += '\n' + summary

                raise dnf.exceptions.Error(errstring)

            del testcb

            logger.info(_('Transaction test succeeded.'))

            #  With RPMTRANS_FLAG_TEST return just before anything is stored permanently

            if self._ts.isTsFlagSet(rpm.RPMTRANS_FLAG_TEST):

                return

            timer()

            # save module states on disk right before entering rpm transaction,

            # because we want system in recoverable state if transaction gets interrupted

            self._moduleContainer.save()

            self._moduleContainer.updateFailSafeData()

            # unset the sigquit handler

            timer = dnf.logging.Timer('transaction')

            # setup our rpm ts callback

            cb = dnf.yum.rpmtrans.RPMTransaction(self, displays=display)

            if self.conf.debuglevel < 2:

                for display_ in cb.displays:

                    display_.output = False