From b9a8226185f3ab58e3551b315af2b11a8b2f2ebe Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hr=C3=A1zk=C3=BD?= <lhrazky@redhat.com>

Date: Tue, 8 Sep 2020 17:02:59 +0200

Subject: [PATCH 01/17] Add a get_current() method to SwdbInterface

The method returns the transaction that is currently being created in

Swdb, before it is stored to sqlite.

---

 VERSION.cmake     | 2 +-

 dnf.spec          | 2 +-

 dnf/db/history.py | 3 +++

 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/dnf/db/history.py b/dnf/db/history.py

index 4d355f95..994cdb01 100644

--- a/dnf/db/history.py

+++ b/dnf/db/history.py

@@ -381,6 +381,9 @@ class SwdbInterface(object):

                 prev_trans.altered_gt_rpmdb = True

         return result[::-1]

+    def get_current(self):

+        return TransactionWrapper(self.swdb.getCurrent())

+

     def set_reason(self, pkg, reason):

         """Set reason for package"""

         rpm_item = self.rpm._pkg_to_swdb_rpm_item(pkg)

-- 

2.26.2

From 3bcf90aadfea98da1397b570fcb3ecc20a89c15d Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Luk=C3=A1=C5=A1=20Hr=C3=A1zk=C3=BD?= <lhrazky@redhat.com>

Date: Fri, 2 Oct 2020 15:52:19 +0200

Subject: [PATCH 02/17] transaction-sr: Prefer installing from the original

 transaction repository

In case a package exists in the same repo_id as from which it was

originally installed, prefer the package from that repo when replaying

the transaction.

Makes a difference in e.g. the system-upgrade plugin, where it ensures

the package is installed from the same repo from which it was downloaded

during the download step.

---

 dnf/transaction_sr.py | 13 +++++++++++++

 1 file changed, 13 insertions(+)

diff --git a/dnf/transaction_sr.py b/dnf/transaction_sr.py

index 9b9b0749..45ca2ef7 100644

--- a/dnf/transaction_sr.py

+++ b/dnf/transaction_sr.py

@@ -257,6 +257,7 @@ class TransactionReplay(object):

         try:

             action = pkg_data["action"]

             nevra = pkg_data["nevra"]

+            repo_id = pkg_data["repo_id"]

             reason = libdnf.transaction.StringToTransactionItemReason(pkg_data["reason"])

         except KeyError as e:

             raise TransactionError(

@@ -282,6 +283,18 @@ class TransactionReplay(object):

         epoch = parsed_nevra.epoch if parsed_nevra.epoch is not None else 0

         query = query_na.filter(epoch=epoch, version=parsed_nevra.version, release=parsed_nevra.release)

+        # In case the package is found in the same repo as in the original

+        # transaction, limit the query to that plus installed packages. IOW

+        # remove packages with the same NEVRA in case they are found in

+        # multiple repos and the repo the package came from originally is one

+        # of them.

+        # This can e.g. make a difference in the system-upgrade plugin, in case

+        # the same NEVRA is in two repos, this makes sure the same repo is used

+        # for both download and upgrade steps of the plugin.

+        query_repo = query.filter(reponame=repo_id)

+        if query_repo:

+            query = query_repo.union(query.installed())

+

         if not query:

             self._raise_or_warn(self._skip_unavailable, _('Cannot find rpm nevra "{nevra}".').format(nevra=nevra))

             return

-- 

2.26.2

From acfd6310131769f33165c8de1d064889a80fc259 Mon Sep 17 00:00:00 2001

From: Daniel Mach <dmach@redhat.com>

Date: Tue, 24 Nov 2020 10:57:21 +0100

Subject: [PATCH 03/17] transaction_sr: Enable loading transactions from dict

---

 dnf/cli/commands/history.py |  2 +-

 dnf/transaction_sr.py       | 42 +++++++++++++++++++++++++------------

 2 files changed, 30 insertions(+), 14 deletions(-)

diff --git a/dnf/cli/commands/history.py b/dnf/cli/commands/history.py

index e381f902..0a6dad9b 100644

--- a/dnf/cli/commands/history.py

+++ b/dnf/cli/commands/history.py

@@ -270,7 +270,7 @@ class HistoryCommand(commands.Command):

             self.replay = TransactionReplay(

                 self.base,

-                self.opts.transaction_filename,

+                filename=self.opts.transaction_filename,

                 ignore_installed = self.opts.ignore_installed,

                 ignore_extras = self.opts.ignore_extras,

                 skip_unavailable = self.opts.skip_unavailable

diff --git a/dnf/transaction_sr.py b/dnf/transaction_sr.py

index 45ca2ef7..e6b06665 100644

--- a/dnf/transaction_sr.py

+++ b/dnf/transaction_sr.py

@@ -187,21 +187,23 @@ class TransactionReplay(object):

     def __init__(

         self,

         base,

-        fn,

+        filename="",

+        data=None,

         ignore_extras=False,

         ignore_installed=False,

         skip_unavailable=False

     ):

         """

         :param base: the dnf base

-        :param fn: the filename to load the transaction from

+        :param filename: the filename to load the transaction from (conflicts with the 'data' argument)

+        :param data: the dictionary to load the transaction from (conflicts with the 'filename' argument)

         :param ignore_extras: whether to ignore extra package pulled into the transaction

         :param ignore_installed: whether to ignore installed versions of packages

         :param skip_unavailable: whether to skip transaction packages that aren't available

         """

         self._base = base

-        self._filename = fn

+        self._filename = filename

         self._ignore_installed = ignore_installed

         self._ignore_extras = ignore_extras

         self._skip_unavailable = skip_unavailable

@@ -213,25 +215,39 @@ class TransactionReplay(object):

         self._nevra_reason_cache = {}

         self._warnings = []

+        if filename and data:

+            raise ValueError(_("Conflicting TransactionReplay arguments have been specified: filename, data"))

+        elif filename:

+            self._load_from_file(filename)

+        else:

+            self._load_from_data(data)

+

+

+    def _load_from_file(self, fn):

+        self._filename = fn

         with open(fn, "r") as f:

             try:

-                self._replay_data = json.load(f)

+                replay_data = json.load(f)

             except json.decoder.JSONDecodeError as e:

                 raise TransactionFileError(fn, str(e) + ".")

         try:

-            self._verify_toplevel_json(self._replay_data)

+            self._load_from_data(replay_data)

+        except TransactionError as e:

+            raise TransactionFileError(fn, e)

-            self._rpms = self._replay_data.get("rpms", [])

-            self._assert_type(self._rpms, list, "rpms", "array")

+    def _load_from_data(self, data):

+        self._replay_data = data

+        self._verify_toplevel_json(self._replay_data)

-            self._groups = self._replay_data.get("groups", [])

-            self._assert_type(self._groups, list, "groups", "array")

+        self._rpms = self._replay_data.get("rpms", [])

+        self._assert_type(self._rpms, list, "rpms", "array")

-            self._environments = self._replay_data.get("environments", [])

-            self._assert_type(self._environments, list, "environments", "array")

-        except TransactionError as e:

-            raise TransactionFileError(fn, e)

+        self._groups = self._replay_data.get("groups", [])

+        self._assert_type(self._groups, list, "groups", "array")

+

+        self._environments = self._replay_data.get("environments", [])

+        self._assert_type(self._environments, list, "environments", "array")

     def _raise_or_warn(self, warn_only, msg):

         if warn_only:

-- 

2.26.2

From 90d4a2fd72b30b295adcb6da66b8043a70561b33 Mon Sep 17 00:00:00 2001

From: Daniel Mach <dmach@redhat.com>

Date: Fri, 20 Nov 2020 19:36:49 +0100

Subject: [PATCH 04/17] transaction_sr: Store exception attributes for future

 use

---

 dnf/transaction_sr.py | 4 ++++

 1 file changed, 4 insertions(+)

diff --git a/dnf/transaction_sr.py b/dnf/transaction_sr.py

index e6b06665..36787de4 100644

--- a/dnf/transaction_sr.py

+++ b/dnf/transaction_sr.py

@@ -55,6 +55,10 @@ class TransactionFileError(dnf.exceptions.Error):

         :param errors: a list of error classes or a string with an error description

         """

+        # store args in case someone wants to read them from a caught exception

+        self.filename = filename

+        self.errors = errors

+

         if isinstance(errors, (list, tuple)):

             if len(errors) > 1:

                 msg = _('Errors in "{filename}":').format(filename=filename)

-- 

2.26.2

From 0ffa7ed9ea73035acaec2c4f916d967701fddda2 Mon Sep 17 00:00:00 2001

From: Daniel Mach <dmach@redhat.com>

Date: Fri, 20 Nov 2020 19:04:59 +0100

Subject: [PATCH 05/17] transaction_sr: Handle serialize_transaction(None)

---

 dnf/transaction_sr.py | 3 +++

 1 file changed, 3 insertions(+)

diff --git a/dnf/transaction_sr.py b/dnf/transaction_sr.py

index 36787de4..41ddee1f 100644

--- a/dnf/transaction_sr.py

+++ b/dnf/transaction_sr.py

@@ -120,6 +120,9 @@ def serialize_transaction(transaction):

     groups = []

     environments = []

+    if transaction is None:

+        return data

+

     for tsi in transaction.packages():

         if tsi.is_package():

             rpms.append({

-- 

2.26.2

From c4bae459caef1d5128bd7ed43fcbb749608449f4 Mon Sep 17 00:00:00 2001

From: Daniel Mach <dmach@redhat.com>

Date: Mon, 23 Nov 2020 16:23:53 +0100

Subject: [PATCH 06/17] transaction_sr: Skip preferred repo lookup if repoid is

 empty

---

 dnf/transaction_sr.py | 7 ++++---

 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/dnf/transaction_sr.py b/dnf/transaction_sr.py

index 41ddee1f..9926bebd 100644

--- a/dnf/transaction_sr.py

+++ b/dnf/transaction_sr.py

@@ -314,9 +314,10 @@ class TransactionReplay(object):

         # This can e.g. make a difference in the system-upgrade plugin, in case

         # the same NEVRA is in two repos, this makes sure the same repo is used

         # for both download and upgrade steps of the plugin.

-        query_repo = query.filter(reponame=repo_id)

-        if query_repo:

-            query = query_repo.union(query.installed())

+        if repo_id:

+            query_repo = query.filter(reponame=repo_id)

+            if query_repo:

+                query = query_repo.union(query.installed())

         if not query:

             self._raise_or_warn(self._skip_unavailable, _('Cannot find rpm nevra "{nevra}".').format(nevra=nevra))

-- 

2.26.2

From 3f82f871170be871ce8ec9d509306d751890ac9e Mon Sep 17 00:00:00 2001

From: Daniel Mach <dmach@redhat.com>

Date: Fri, 20 Nov 2020 17:44:28 +0100

Subject: [PATCH 07/17] history: Refactor redo code to use transaction

 store/replay

= changelog =

msg: Support comps groups in history redo

type: enhancement

resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1657123

resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1809565

resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1809639

---

 dnf/cli/commands/history.py | 40 +++++++++++++++----------------------

 1 file changed, 16 insertions(+), 24 deletions(-)

diff --git a/dnf/cli/commands/history.py b/dnf/cli/commands/history.py

index 0a6dad9b..c28a136a 100644

--- a/dnf/cli/commands/history.py

+++ b/dnf/cli/commands/history.py

@@ -120,6 +120,10 @@ class HistoryCommand(commands.Command):

             if not self.opts.transactions:

                 raise dnf.cli.CliError(_('No transaction ID or package name given.'))

         elif self.opts.transactions_action in ['redo', 'undo', 'rollback']:

+            demands.available_repos = True

+            demands.resolving = True

+            demands.root_user = True

+

             self._require_one_transaction_id = True

             if not self.opts.transactions:

                 msg = _('No transaction ID or package name given.')

@@ -157,28 +161,16 @@ class HistoryCommand(commands.Command):

         old = self.base.history_get_transaction(extcmds)

         if old is None:

             return 1, ['Failed history redo']

-        tm = dnf.util.normalize_time(old.beg_timestamp)

-        print('Repeating transaction %u, from %s' % (old.tid, tm))

-        self.output.historyInfoCmdPkgsAltered(old)

-

-        for i in old.packages():

-            pkgs = list(self.base.sack.query().filter(nevra=str(i), reponame=i.from_repo))

-            if i.action in dnf.transaction.FORWARD_ACTIONS:

-                if not pkgs:

-                    logger.info(_('No package %s available.'),

-                    self.output.term.bold(ucd(str(i))))

-                    return 1, ['An operation cannot be redone']

-                pkg = pkgs[0]

-                self.base.install(str(pkg))

-            elif i.action == libdnf.transaction.TransactionItemAction_REMOVE:

-                if not pkgs:

-                    # package was removed already, we can skip removing it again

-                    continue

-                pkg = pkgs[0]

-                self.base.remove(str(pkg))

-

-        self.base.resolve()

-        self.base.do_transaction()

+

+        data = serialize_transaction(old)

+        self.replay = TransactionReplay(

+            self.base,

+            data=data,

+            ignore_installed=True,

+            ignore_extras=True,

+            skip_unavailable=self.opts.skip_unavailable

+        )

+        self.replay.run()

     def _hcmd_undo(self, extcmds):

         try:

@@ -326,13 +318,13 @@ class HistoryCommand(commands.Command):

             raise dnf.exceptions.Error(strs[0])

     def run_resolved(self):

-        if self.opts.transactions_action != "replay":

+        if self.opts.transactions_action not in ("replay", "redo"):

             return

         self.replay.post_transaction()

     def run_transaction(self):

-        if self.opts.transactions_action != "replay":

+        if self.opts.transactions_action not in ("replay", "redo"):

             return

         warnings = self.replay.get_warnings()

-- 

2.26.2

From d1b78ba8449b319121b5208c5b39609b1c6b61de Mon Sep 17 00:00:00 2001

From: Daniel Mach <dmach@redhat.com>

Date: Fri, 20 Nov 2020 19:07:50 +0100

Subject: [PATCH 08/17] history: Refactor rollback code to use transaction

 store/replay

= changelog =

msg: Support comps groups in history rollback

type: enhancement

resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1657123

resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1809565

resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1809639

---

 dnf/cli/cli.py              | 56 -----------------------------

 dnf/cli/commands/history.py | 72 ++++++++++++++++++++++++++++++++++---

 2 files changed, 67 insertions(+), 61 deletions(-)

diff --git a/dnf/cli/cli.py b/dnf/cli/cli.py

index cd720a97..36671fd8 100644

--- a/dnf/cli/cli.py

+++ b/dnf/cli/cli.py

@@ -627,62 +627,6 @@ class BaseCli(dnf.Base):

             logger.critical(_('Found more than one transaction ID!'))

         return old[0]

-    def history_rollback_transaction(self, extcmd):

-        """Rollback given transaction."""

-        old = self.history_get_transaction((extcmd,))

-        if old is None:

-            return 1, ['Failed history rollback, no transaction']

-        last = self.history.last()

-        if last is None:

-            return 1, ['Failed history rollback, no last?']

-        if old.tid == last.tid:

-            return 0, ['Rollback to current, nothing to do']

-

-        mobj = None

-        for trans in self.history.old(list(range(old.tid + 1, last.tid + 1))):

-            if trans.altered_lt_rpmdb:

-                logger.warning(_('Transaction history is incomplete, before %u.'), trans.tid)

-            elif trans.altered_gt_rpmdb:

-                logger.warning(_('Transaction history is incomplete, after %u.'), trans.tid)

-

-            if mobj is None:

-                mobj = dnf.db.history.MergedTransactionWrapper(trans)

-            else:

-                mobj.merge(trans)

-

-        tm = dnf.util.normalize_time(old.beg_timestamp)

-        print("Rollback to transaction %u, from %s" % (old.tid, tm))

-        print(self.output.fmtKeyValFill("  Undoing the following transactions: ",

-                                        ", ".join((str(x) for x in mobj.tids()))))

-        self.output.historyInfoCmdPkgsAltered(mobj)  # :todo

-

-#        history = dnf.history.open_history(self.history)  # :todo

-#        m = libdnf.transaction.MergedTransaction()

-

-#        return

-

-#        operations = dnf.history.NEVRAOperations()

-#        for id_ in range(old.tid + 1, last.tid + 1):

-#            operations += history.transaction_nevra_ops(id_)

-

-        try:

-            self._history_undo_operations(mobj, old.tid + 1, True, strict=self.conf.strict)

-        except dnf.exceptions.PackagesNotInstalledError as err:

-            raise

-            logger.info(_('No package %s installed.'),

-                        self.output.term.bold(ucd(err.pkg_spec)))

-            return 1, ['A transaction cannot be undone']

-        except dnf.exceptions.PackagesNotAvailableError as err:

-            raise

-            logger.info(_('No package %s available.'),

-                        self.output.term.bold(ucd(err.pkg_spec)))

-            return 1, ['A transaction cannot be undone']

-        except dnf.exceptions.MarkingError:

-            raise

-            assert False

-        else:

-            return 2, ["Rollback to transaction %u" % (old.tid,)]

-

     def history_undo_transaction(self, extcmd):

         """Undo given transaction."""

         old = self.history_get_transaction((extcmd,))

diff --git a/dnf/cli/commands/history.py b/dnf/cli/commands/history.py

index c28a136a..a450aaab 100644

--- a/dnf/cli/commands/history.py

+++ b/dnf/cli/commands/history.py

@@ -20,6 +20,7 @@ from __future__ import print_function

 from __future__ import unicode_literals

 import libdnf

+import hawkey

 from dnf.i18n import _, ucd

 from dnf.cli import commands

@@ -33,6 +34,7 @@ import dnf.util

 import json

 import logging

 import os

+import sys

 logger = logging.getLogger('dnf')

@@ -179,10 +181,70 @@ class HistoryCommand(commands.Command):

             return 1, [str(err)]

     def _hcmd_rollback(self, extcmds):

+        old = self.base.history_get_transaction(extcmds)

+        if old is None:

+            return 1, ['Failed history rollback']

+        last = self.base.history.last()

+

+        merged_trans = None

+        if old.tid != last.tid:

+            # history.old([]) returns all transactions and we don't want that

+            # so skip merging the transactions when trying to rollback to the last transaction

+            # which is the current system state and rollback is not applicable

+            for trans in self.base.history.old(list(range(old.tid + 1, last.tid + 1))):

+                if trans.altered_lt_rpmdb:

+                    logger.warning(_('Transaction history is incomplete, before %u.'), trans.tid)

+                elif trans.altered_gt_rpmdb:

+                    logger.warning(_('Transaction history is incomplete, after %u.'), trans.tid)

+

+                if merged_trans is None:

+                    merged_trans = dnf.db.history.MergedTransactionWrapper(trans)

+                else:

+                    merged_trans.merge(trans)

+

+        return self._revert_transaction(merged_trans)

+

+    def _revert_transaction(self, trans):

+        action_map = {

+            "Install": "Removed",

+            "Removed": "Install",

+            "Upgrade": "Downgraded",

+            "Upgraded": "Downgrade",

+            "Downgrade": "Upgraded",

+            "Downgraded": "Upgrade",

+            "Reinstalled": "Reinstall",

+            "Reinstall": "Reinstalled",

+            "Obsoleted": "Install",

+            "Obsolete": "Obsoleted",

+        }

+

+        data = serialize_transaction(trans)

+

+        # revert actions in the serialized transaction data to perform rollback/undo

+        for content_type in ("rpms", "groups", "environments"):

+            for ti in data.get(content_type, []):

+                ti["action"] = action_map[ti["action"]]

+

+                if ti["action"] == "Install" and ti.get("reason", None) == "clean":

+                    ti["reason"] = "dependency"

+

+                if ti.get("repo_id") == hawkey.SYSTEM_REPO_NAME:

+                    # erase repo_id, because it's not possible to perform forward actions from the @System repo

+                    ti["repo_id"] = None

+

+        self.replay = TransactionReplay(

+            self.base,

+            data=data,

+            ignore_installed=True,

+            ignore_extras=True,

+            skip_unavailable=self.opts.skip_unavailable

+        )

         try:

-            return self.base.history_rollback_transaction(extcmds[0])

-        except dnf.exceptions.Error as err:

-            return 1, [str(err)]

+            self.replay.run()

+        except dnf.transaction_sr.TransactionFileError as ex:

+            for error in ex.errors:

+                print(str(error), file=sys.stderr)

+            raise dnf.exceptions.PackageNotFoundError(_('no package matched'))

     def _hcmd_userinstalled(self):

         """Execute history userinstalled command."""

@@ -318,13 +380,13 @@ class HistoryCommand(commands.Command):

             raise dnf.exceptions.Error(strs[0])

     def run_resolved(self):

-        if self.opts.transactions_action not in ("replay", "redo"):

+        if self.opts.transactions_action not in ("replay", "redo", "rollback"):

             return

         self.replay.post_transaction()

     def run_transaction(self):

-        if self.opts.transactions_action not in ("replay", "redo"):

+        if self.opts.transactions_action not in ("replay", "redo", "rollback"):

             return

         warnings = self.replay.get_warnings()

-- 

2.26.2

From a59a57ce456682e85e86ee362aab4eecc19dbc81 Mon Sep 17 00:00:00 2001

From: Daniel Mach <dmach@redhat.com>

Date: Thu, 3 Dec 2020 15:56:52 +0100

Subject: [PATCH 09/17] history: Refactor undo code to use transaction

 store/replay

= changelog =

msg: Support comps groups in history undo

type: enhancement

resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1657123

resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1809565

resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1809639

---

 dnf/cli/cli.py              | 28 ----------------------------

 dnf/cli/commands/history.py | 12 ++++++------

 2 files changed, 6 insertions(+), 34 deletions(-)

diff --git a/dnf/cli/cli.py b/dnf/cli/cli.py

index 36671fd8..e4fd39c6 100644

--- a/dnf/cli/cli.py

+++ b/dnf/cli/cli.py

@@ -627,34 +627,6 @@ class BaseCli(dnf.Base):

             logger.critical(_('Found more than one transaction ID!'))

         return old[0]

-    def history_undo_transaction(self, extcmd):

-        """Undo given transaction."""

-        old = self.history_get_transaction((extcmd,))

-        if old is None:

-            return 1, ['Failed history undo']

-

-        tm = dnf.util.normalize_time(old.beg_timestamp)

-        msg = _("Undoing transaction {}, from {}").format(old.tid, ucd(tm))

-        logger.info(msg)

-        self.output.historyInfoCmdPkgsAltered(old)  # :todo

-

-

-        mobj = dnf.db.history.MergedTransactionWrapper(old)

-

-        try:

-            self._history_undo_operations(mobj, old.tid, strict=self.conf.strict)

-        except dnf.exceptions.PackagesNotInstalledError as err:

-            logger.info(_('No package %s installed.'),

-                        self.output.term.bold(ucd(err.pkg_spec)))

-            return 1, ['An operation cannot be undone']

-        except dnf.exceptions.PackagesNotAvailableError as err:

-            logger.info(_('No package %s available.'),

-                        self.output.term.bold(ucd(err.pkg_spec)))

-            return 1, ['An operation cannot be undone']

-        except dnf.exceptions.MarkingError:

-            raise

-        else:

-            return 2, ["Undoing transaction %u" % (old.tid,)]

 class Cli(object):

     def __init__(self, base):

diff --git a/dnf/cli/commands/history.py b/dnf/cli/commands/history.py

index a450aaab..d60d3f25 100644

--- a/dnf/cli/commands/history.py

+++ b/dnf/cli/commands/history.py

@@ -175,10 +175,10 @@ class HistoryCommand(commands.Command):

         self.replay.run()

     def _hcmd_undo(self, extcmds):

-        try:

-            return self.base.history_undo_transaction(extcmds[0])

-        except dnf.exceptions.Error as err:

-            return 1, [str(err)]

+        old = self.base.history_get_transaction(extcmds)

+        if old is None:

+            return 1, ['Failed history undo']

+        return self._revert_transaction(old)

     def _hcmd_rollback(self, extcmds):

         old = self.base.history_get_transaction(extcmds)

@@ -380,13 +380,13 @@ class HistoryCommand(commands.Command):

             raise dnf.exceptions.Error(strs[0])

     def run_resolved(self):

-        if self.opts.transactions_action not in ("replay", "redo", "rollback"):

+        if self.opts.transactions_action not in ("replay", "redo", "rollback", "undo"):

             return

         self.replay.post_transaction()

     def run_transaction(self):

-        if self.opts.transactions_action not in ("replay", "redo", "rollback"):

+        if self.opts.transactions_action not in ("replay", "redo", "rollback", "undo"):

             return

         warnings = self.replay.get_warnings()

-- 

2.26.2

From 5a0b6cc00420fd6559a1fd611de1417ea90b1bfc Mon Sep 17 00:00:00 2001

From: Daniel Mach <dmach@redhat.com>

Date: Fri, 20 Nov 2020 19:54:54 +0100

Subject: [PATCH 10/17] Remove Base._history_undo_operations() as it was

 replaced with transaction_sr code

---

 dnf/base.py | 59 -----------------------------------------------------

 1 file changed, 59 deletions(-)

diff --git a/dnf/base.py b/dnf/base.py

index ec41ab01..a2955051 100644

--- a/dnf/base.py

+++ b/dnf/base.py

@@ -2218,65 +2218,6 @@ class Base(object):

                                for prefix in ['/bin/', '/sbin/', '/usr/bin/', '/usr/sbin/']]

         return self.sack.query().filterm(file__glob=binary_provides), binary_provides

-    def _history_undo_operations(self, operations, first_trans, rollback=False, strict=True):

-        """Undo the operations on packages by their NEVRAs.

-

-        :param operations: a NEVRAOperations to be undone

-        :param first_trans: first transaction id being undone

-        :param rollback: True if transaction is performing a rollback

-        :param strict: if True, raise an exception on any errors

-        """

-

-        # map actions to their opposites

-        action_map = {

-            libdnf.transaction.TransactionItemAction_DOWNGRADE: None,

-            libdnf.transaction.TransactionItemAction_DOWNGRADED: libdnf.transaction.TransactionItemAction_UPGRADE,

-            libdnf.transaction.TransactionItemAction_INSTALL: libdnf.transaction.TransactionItemAction_REMOVE,

-            libdnf.transaction.TransactionItemAction_OBSOLETE: None,

-            libdnf.transaction.TransactionItemAction_OBSOLETED: libdnf.transaction.TransactionItemAction_INSTALL,

-            libdnf.transaction.TransactionItemAction_REINSTALL: None,

-            # reinstalls are skipped as they are considered as no-operation from history perspective

-            libdnf.transaction.TransactionItemAction_REINSTALLED: None,

-            libdnf.transaction.TransactionItemAction_REMOVE: libdnf.transaction.TransactionItemAction_INSTALL,

-            libdnf.transaction.TransactionItemAction_UPGRADE: None,

-            libdnf.transaction.TransactionItemAction_UPGRADED: libdnf.transaction.TransactionItemAction_DOWNGRADE,

-            libdnf.transaction.TransactionItemAction_REASON_CHANGE: None,

-        }

-

-        failed = False

-        for ti in operations.packages():

-            try:

-                action = action_map[ti.action]

-            except KeyError:

-                raise RuntimeError(_("Action not handled: {}".format(action)))

-

-            if action is None:

-                continue

-

-            if action == libdnf.transaction.TransactionItemAction_REMOVE:

-                query = self.sack.query().installed().filterm(nevra_strict=str(ti))

-                if not query:

-                    logger.error(_('No package %s installed.'), ucd(str(ti)))