

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: system_upgrade.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'># -*- coding: utf-8 -*-
#
# Copyright (c) 2015-2020 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program.  If not, see &lt;http://www.gnu.org/licenses/&gt;.
#
# Author(s): Will Woods &lt;wwoods@redhat.com&gt;

&quot;&quot;&quot;system_upgrade.py - DNF plugin to handle major-version system upgrades.&quot;&quot;&quot;

from subprocess import call, Popen, check_output, CalledProcessError
import json
import os
import os.path
import re
import sys
import uuid

from systemd import journal

from dnfpluginscore import _, logger

import dnf
import dnf.cli
from dnf.cli import CliError
from dnf.i18n import ucd
import dnf.transaction
from dnf.transaction_sr import serialize_transaction, TransactionReplay

import libdnf.conf


# Translators: This string is only used in unit tests.
_(&quot;the color of the sky&quot;)

DOWNLOAD_FINISHED_ID = uuid.UUID(&#039;9348174c5cc74001a71ef26bd79d302e&#039;)
REBOOT_REQUESTED_ID = uuid.UUID(&#039;fef1cc509d5047268b83a3a553f54b43&#039;)
UPGRADE_STARTED_ID = uuid.UUID(&#039;3e0a5636d16b4ca4bbe5321d06c6aa62&#039;)
UPGRADE_FINISHED_ID = uuid.UUID(&#039;8cec00a1566f4d3594f116450395f06c&#039;)

ID_TO_IDENTIFY_BOOTS = UPGRADE_STARTED_ID

PLYMOUTH = &#039;/usr/bin/plymouth&#039;

RELEASEVER_MSG = _(
    &quot;Need a --releasever greater than the current system version.&quot;)
DOWNLOAD_FINISHED_MSG = _(  # Translators: do not change &quot;reboot&quot; here
    &quot;Download complete! Use &#039;dnf {command} reboot&#039; to start the upgrade.\n&quot;
    &quot;To remove cached metadata and transaction use &#039;dnf {command} clean&#039;&quot;)
CANT_RESET_RELEASEVER = _(
    &quot;Sorry, you need to use &#039;download --releasever&#039; instead of &#039;--network&#039;&quot;)

STATE_VERSION = 2

# --- Miscellaneous helper functions ------------------------------------------


def reboot():
    if os.getenv(&quot;DNF_SYSTEM_UPGRADE_NO_REBOOT&quot;, default=False):
        logger.info(_(&quot;Reboot turned off, not rebooting.&quot;))
    else:
        Popen([&quot;systemctl&quot;, &quot;reboot&quot;])


def get_url_from_os_release():
    key = &quot;UPGRADE_GUIDE_URL=&quot;
    for path in [&quot;/etc/os-release&quot;, &quot;/usr/lib/os-release&quot;]:
        try:
            with open(path) as release_file:
                for line in release_file:
                    line = line.strip()
                    if line.startswith(key):
                        return line[len(key):].strip(&#039;&quot;&#039;)
        except IOError:
            continue
    return None


# DNF-FIXME: dnf.util.clear_dir() doesn&#039;t delete regular files :/
def clear_dir(path, ignore=[]):
    if not os.path.isdir(path):
        return

    for entry in os.listdir(path):
        fullpath = os.path.join(path, entry)
        if fullpath in ignore:
            continue
        try:
            if os.path.isdir(fullpath):
                dnf.util.rm_rf(fullpath)
            else:
                os.unlink(fullpath)
        except OSError:
            pass


def check_release_ver(conf, target=None):
    if dnf.rpm.detect_releasever(conf.installroot) == conf.releasever:
        raise CliError(RELEASEVER_MSG)
    if target and target != conf.releasever:
        # it&#039;s too late to set releasever here, so this can&#039;t work.
        # (see https://bugzilla.redhat.com/show_bug.cgi?id=1212341)
        raise CliError(CANT_RESET_RELEASEVER)


def disable_blanking():
    try:
        tty = open(&#039;/dev/tty0&#039;, &#039;wb&#039;)
        tty.write(b&#039;\33[9;0]&#039;)
    except Exception as e:
        print(_(&quot;Screen blanking can&#039;t be disabled: %s&quot;) % e)

# --- State object - for tracking upgrade state between runs ------------------


# DNF-INTEGRATION-NOTE: basically the same thing as dnf.persistor.JSONDB
class State(object):
    def __init__(self, statefile):
        self.statefile = statefile
        self._data = {}
        self._read()

    def _read(self):
        try:
            with open(self.statefile) as fp:
                self._data = json.load(fp)
        except IOError:
            self._data = {}
        except ValueError:
            self._data = {}
            logger.warning(_(&quot;Failed loading state file: %s, continuing with &quot;
                             &quot;empty state.&quot;), self.statefile)

    def write(self):
        dnf.util.ensure_dir(os.path.dirname(self.statefile))
        with open(self.statefile, &#039;w&#039;) as outf:
            json.dump(self._data, outf, indent=4, sort_keys=True)

    def clear(self):
        if os.path.exists(self.statefile):
            os.unlink(self.statefile)
        self._read()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type is None:
            self.write()

    # helper function for creating properties. pylint: disable=protected-access
    def _prop(option):  # pylint: disable=no-self-argument
        def setprop(self, value):
            self._data[option] = value

        def getprop(self):
            return self._data.get(option)
        return property(getprop, setprop)

    #  !!! Increase STATE_VERSION for any changes in data structure like a new property or a new
    #  data structure !!!
    state_version = _prop(&quot;state_version&quot;)
    download_status = _prop(&quot;download_status&quot;)
    destdir = _prop(&quot;destdir&quot;)
    target_releasever = _prop(&quot;target_releasever&quot;)
    system_releasever = _prop(&quot;system_releasever&quot;)
    gpgcheck = _prop(&quot;gpgcheck&quot;)
    # list of repos with gpgcheck=True
    gpgcheck_repos = _prop(&quot;gpgcheck_repos&quot;)
    # list of repos with repo_gpgcheck=True
    repo_gpgcheck_repos = _prop(&quot;repo_gpgcheck_repos&quot;)
    upgrade_status = _prop(&quot;upgrade_status&quot;)
    upgrade_command = _prop(&quot;upgrade_command&quot;)
    distro_sync = _prop(&quot;distro_sync&quot;)
    enable_disable_repos = _prop(&quot;enable_disable_repos&quot;)
    module_platform_id = _prop(&quot;module_platform_id&quot;)

# --- Plymouth output helpers -------------------------------------------------


class PlymouthOutput(object):
    &quot;&quot;&quot;A plymouth output helper class.

    Filters duplicate calls, and stops calling the plymouth binary if we
    fail to contact it.
    &quot;&quot;&quot;

    def __init__(self):
        self.alive = True
        self._last_args = dict()
        self._last_msg = None

    def _plymouth(self, cmd, *args):
        dupe_cmd = (args == self._last_args.get(cmd))
        if (self.alive and not dupe_cmd) or cmd == &#039;--ping&#039;:
            try:
                self.alive = (call((PLYMOUTH, cmd) + args) == 0)
            except OSError:
                self.alive = False
            self._last_args[cmd] = args
        return self.alive

    def ping(self):
        return self._plymouth(&quot;--ping&quot;)

    def message(self, msg):
        if self._last_msg and self._last_msg != msg:
            self._plymouth(&quot;hide-message&quot;, &quot;--text&quot;, self._last_msg)
        self._last_msg = msg
        return self._plymouth(&quot;display-message&quot;, &quot;--text&quot;, msg)

    def set_mode(self):
        mode = &#039;updates&#039;
        try:
            s = check_output([PLYMOUTH, &#039;--help&#039;])
            if re.search(&#039;--system-upgrade&#039;, ucd(s)):
                mode = &#039;system-upgrade&#039;
        except (CalledProcessError, OSError):
            pass
        return self._plymouth(&quot;change-mode&quot;, &quot;--&quot; + mode)

    def progress(self, percent):
        return self._plymouth(&quot;system-update&quot;, &quot;--progress&quot;, str(percent))


# A single PlymouthOutput instance for us to use within this module
Plymouth = PlymouthOutput()


# A TransactionProgress class that updates plymouth for us.
class PlymouthTransactionProgress(dnf.callback.TransactionProgress):

    # pylint: disable=too-many-arguments
    def progress(self, package, action, ti_done, ti_total, ts_done, ts_total):
        self._update_plymouth(package, action, ts_done, ts_total)

    def _update_plymouth(self, package, action, current, total):
        # Prevents quick jumps of progressbar when pretrans scriptlets
        # and TRANS_PREPARATION are reported as 1/1
        if total == 1:
            return
        # Verification goes through all the packages again,
        # which resets the &quot;current&quot; param value, this prevents
        # resetting of the progress bar as well. (Rhbug:1809096)
        if action != dnf.callback.PKG_VERIFY:
            Plymouth.progress(int(90.0 * current / total))
        else:
            Plymouth.progress(90 + int(10.0 * current / total))

        Plymouth.message(self._fmt_event(package, action, current, total))

    def _fmt_event(self, package, action, current, total):
        action = dnf.transaction.ACTIONS.get(action, action)
        return &quot;[%d/%d] %s %s...&quot; % (current, total, action, package)

# --- journal helpers -------------------------------------------------


def find_boots(message_id):
    &quot;&quot;&quot;Find all boots with this message id.

    Returns the entries of all found boots.
    &quot;&quot;&quot;
    j = journal.Reader()
    j.add_match(MESSAGE_ID=message_id.hex,  # identify the message
                _UID=0)                     # prevent spoofing of logs

    oldboot = None
    for entry in j:
        boot = entry[&#039;_BOOT_ID&#039;]
        if boot == oldboot:
            continue
        oldboot = boot
        yield entry


def list_logs():
    print(_(&#039;The following boots appear to contain upgrade logs:&#039;))
    n = -1
    for n, entry in enumerate(find_boots(ID_TO_IDENTIFY_BOOTS)):
        print(&#039;{} / {.hex}: {:%Y-%m-%d %H:%M:%S} {}→{}&#039;.format(
            n + 1,
            entry[&#039;_BOOT_ID&#039;],
            entry[&#039;__REALTIME_TIMESTAMP&#039;],
            entry.get(&#039;SYSTEM_RELEASEVER&#039;, &#039;??&#039;),
            entry.get(&#039;TARGET_RELEASEVER&#039;, &#039;??&#039;)))
    if n == -1:
        print(_(&#039;-- no logs were found --&#039;))


def pick_boot(message_id, n):
    boots = list(find_boots(message_id))
    # Positive indices index all found boots starting with 1 and going forward,
    # zero is the current boot, and -1, -2, -3 are previous going backwards.
    # This is the same as journalctl.
    try:
        if n == 0:
            raise IndexError
        if n &gt; 0:
            n -= 1
        return boots[n][&#039;_BOOT_ID&#039;]
    except IndexError:
        raise CliError(_(&quot;Cannot find logs with this index.&quot;))


def show_log(n):
    boot_id = pick_boot(ID_TO_IDENTIFY_BOOTS, n)
    process = Popen([&#039;journalctl&#039;, &#039;--boot&#039;, boot_id.hex])
    process.wait()
    rc = process.returncode
    if rc == 1:
        raise dnf.exceptions.Error(_(&quot;Unable to match systemd journal entry&quot;))


CMDS = [&#039;download&#039;, &#039;clean&#039;, &#039;reboot&#039;, &#039;upgrade&#039;, &#039;log&#039;]

# --- The actual Plugin and Command objects! ----------------------------------


class SystemUpgradePlugin(dnf.Plugin):
    name = &#039;system-upgrade&#039;

    def __init__(self, base, cli):
        super(SystemUpgradePlugin, self).__init__(base, cli)
        if cli:
            cli.register_command(SystemUpgradeCommand)
            cli.register_command(OfflineUpgradeCommand)
            cli.register_command(OfflineDistrosyncCommand)


class SystemUpgradeCommand(dnf.cli.Command):
    aliases = (&#039;system-upgrade&#039;, &#039;fedup&#039;,)
    summary = _(&quot;Prepare system for upgrade to a new release&quot;)

    DATADIR = &#039;var/lib/dnf/system-upgrade&#039;

    def __init__(self, cli):
        super(SystemUpgradeCommand, self).__init__(cli)
        self.datadir = os.path.join(cli.base.conf.installroot, self.DATADIR)
        self.transaction_file = os.path.join(self.datadir, &#039;system-upgrade-transaction.json&#039;)
        self.magic_symlink = os.path.join(cli.base.conf.installroot, &#039;system-update&#039;)

        self.state = State(os.path.join(self.datadir, &#039;system-upgrade-state.json&#039;))

    @staticmethod
    def set_argparser(parser):
        parser.add_argument(&quot;--no-downgrade&quot;, dest=&#039;distro_sync&#039;,
                            action=&#039;store_false&#039;,
                            help=_(&quot;keep installed packages if the new &quot;
                                   &quot;release&#039;s version is older&quot;))
        parser.add_argument(&#039;tid&#039;, nargs=1, choices=CMDS,
                            metavar=&quot;[%s]&quot; % &quot;|&quot;.join(CMDS))
        parser.add_argument(&#039;--number&#039;, type=int, help=_(&#039;which logs to show&#039;))

    def log_status(self, message, message_id):
        &quot;&quot;&quot;Log directly to the journal.&quot;&quot;&quot;
        journal.send(message,
                     MESSAGE_ID=message_id,
                     PRIORITY=journal.LOG_NOTICE,
                     SYSTEM_RELEASEVER=self.state.system_releasever,
                     TARGET_RELEASEVER=self.state.target_releasever,
                     DNF_VERSION=dnf.const.VERSION)

    def pre_configure(self):
        self._call_sub(&quot;check&quot;)
        self._call_sub(&quot;pre_configure&quot;)

    def configure(self):
        self._call_sub(&quot;configure&quot;)

    def run(self):
        self._call_sub(&quot;run&quot;)

    def run_transaction(self):
        self._call_sub(&quot;transaction&quot;)

    def run_resolved(self):
        self._call_sub(&quot;resolved&quot;)

    def _call_sub(self, name):
        subfunc = getattr(self, name + &#039;_&#039; + self.opts.tid[0], None)
        if callable(subfunc):
            subfunc()

    def _check_state_version(self, command):
        if self.state.state_version != STATE_VERSION:
            msg = _(&quot;Incompatible version of data. Rerun &#039;dnf {command} download [OPTIONS]&#039;&quot;
                    &quot;&quot;).format(command=command)
            raise CliError(msg)

    def _set_cachedir(self):
        # set download directories from json state file
        self.base.conf.cachedir = self.datadir
        self.base.conf.destdir = self.state.destdir if self.state.destdir else None

    def _get_forward_reverse_pkg_reason_pairs(self):
        &quot;&quot;&quot;
        forward = {repoid:{pkg_nevra: {tsi.action: tsi.reason}}
        reverse = {pkg_nevra: {tsi.action: tsi.reason}}
        :return: forward, reverse
        &quot;&quot;&quot;
        backward_action = set(dnf.transaction.BACKWARD_ACTIONS + [libdnf.transaction.TransactionItemAction_REINSTALLED])
        forward_actions = set(dnf.transaction.FORWARD_ACTIONS)

        forward = {}
        reverse = {}
        for tsi in self.cli.base.transaction:
            if tsi.action in forward_actions:
                pkg = tsi.pkg
                forward.setdefault(pkg.repo.id, {}).setdefault(
                    str(pkg), {})[tsi.action] = tsi.reason
            elif tsi.action in backward_action:
                reverse.setdefault(str(tsi.pkg), {})[tsi.action] = tsi.reason
        return forward, reverse

    # == pre_configure_*: set up action-specific demands ==========================
    def pre_configure_download(self):
        # only download subcommand accepts --destdir command line option
        self.base.conf.cachedir = self.datadir
        self.base.conf.destdir = self.opts.destdir if self.opts.destdir else None
        if &#039;offline-distrosync&#039; == self.opts.command and not self.opts.distro_sync:
            raise CliError(
                _(&quot;Command &#039;offline-distrosync&#039; cannot be used with --no-downgrade option&quot;))
        elif &#039;offline-upgrade&#039; == self.opts.command:
            self.opts.distro_sync = False

    def pre_configure_reboot(self):
        self._set_cachedir()

    def pre_configure_upgrade(self):
        self._set_cachedir()
        if self.state.enable_disable_repos:
            self.opts.repos_ed = self.state.enable_disable_repos
        self.base.conf.releasever = self.state.target_releasever

    def pre_configure_clean(self):
        self._set_cachedir()

    # == configure_*: set up action-specific demands ==========================

    def configure_download(self):
        if &#039;system-upgrade&#039; == self.opts.command or &#039;fedup&#039; == self.opts.command:
            logger.warning(_(&#039;WARNING: this operation is not supported on the RHEL distribution. &#039;
                             &#039;Proceed at your own risk.&#039;))
            help_url = get_url_from_os_release()
            if help_url:
                msg = _(&#039;Additional information for System Upgrade: {}&#039;)
                logger.info(msg.format(ucd(help_url)))
            if self.base._promptWanted():
                msg = _(&#039;Before you continue ensure that your system is fully upgraded by running &#039;
                        &#039;&quot;dnf --refresh upgrade&quot;. Do you want to continue&#039;)
                if self.base.conf.assumeno or not self.base.output.userconfirm(
                        msg=&#039;{} [y/N]: &#039;.format(msg), defaultyes_msg=&#039;{} [Y/n]: &#039;.format(msg)):
                    logger.error(_(&quot;Operation aborted.&quot;))
                    sys.exit(1)
            check_release_ver(self.base.conf, target=self.opts.releasever)
        elif &#039;offline-upgrade&#039; == self.opts.command:
            self.cli._populate_update_security_filter(self.opts)

        self.cli.demands.root_user = True
        self.cli.demands.resolving = True
        self.cli.demands.available_repos = True
        self.cli.demands.sack_activation = True
        self.cli.demands.freshest_metadata = True
        # We want to do the depsolve / download / transaction-test, but *not*
        # run the actual RPM transaction to install the downloaded packages.
        # Setting the &quot;test&quot; flag makes the RPM transaction a test transaction,
        # so nothing actually gets installed.
        # (It also means that we run two test transactions in a row, which is
        # kind of silly, but that&#039;s something for DNF to fix...)
        self.base.conf.tsflags += [&quot;test&quot;]

    def configure_reboot(self):
        # FUTURE: add a --debug-shell option to enable debug shell:
        # systemctl add-wants system-update.target debug-shell.service
        self.cli.demands.root_user = True

    def configure_upgrade(self):
        # same as the download, but offline and non-interactive. so...
        self.cli.demands.root_user = True
        self.cli.demands.resolving = True
        self.cli.demands.available_repos = True
        self.cli.demands.sack_activation = True
        # use the saved value for --allowerasing, etc.
        self.opts.distro_sync = self.state.distro_sync
        if self.state.gpgcheck is not None:
            self.base.conf.gpgcheck = self.state.gpgcheck
        if self.state.gpgcheck_repos is not None:
            for repo in self.base.repos.values():
                repo.gpgcheck = repo.id in self.state.gpgcheck_repos
        if self.state.repo_gpgcheck_repos is not None:
            for repo in self.base.repos.values():
                repo.repo_gpgcheck = repo.id in self.state.repo_gpgcheck_repos
        self.base.conf.module_platform_id = self.state.module_platform_id
        # don&#039;t try to get new metadata, &#039;cuz we&#039;re offline
        self.cli.demands.cacheonly = True
        # and don&#039;t ask any questions (we confirmed all this beforehand)
        self.base.conf.assumeyes = True
        self.cli.demands.transaction_display = PlymouthTransactionProgress()
        # upgrade operation already removes all element that must be removed. Additional removal
        # could trigger unwanted changes in transaction.
        self.base.conf.clean_requirements_on_remove = False
        self.base.conf.install_weak_deps = False

    def configure_clean(self):
        self.cli.demands.root_user = True

    def configure_log(self):
        pass

    # == check_*: do any action-specific checks ===============================

    def check_reboot(self):
        if not self.state.download_status == &#039;complete&#039;:
            raise CliError(_(&quot;system is not ready for upgrade&quot;))
        self._check_state_version(self.opts.command)
        if self.state.upgrade_command != self.opts.command:
            msg = _(&quot;the transaction was not prepared for &#039;{command}&#039;. &quot;
                    &quot;Rerun &#039;dnf {command} download [OPTIONS]&#039;&quot;).format(command=self.opts.command)
            raise CliError(msg)
        if os.path.lexists(self.magic_symlink):
            raise CliError(_(&quot;upgrade is already scheduled&quot;))
        dnf.util.ensure_dir(self.datadir)
        # FUTURE: checkRPMDBStatus(self.state.download_transaction_id)

    def check_upgrade(self):
        if not os.path.lexists(self.magic_symlink):
            logger.info(_(&quot;trigger file does not exist. exiting quietly.&quot;))
            raise SystemExit(0)
        if os.readlink(self.magic_symlink) != self.datadir:
            logger.info(_(&quot;another upgrade tool is running. exiting quietly.&quot;))
            raise SystemExit(0)
        # Delete symlink ASAP to avoid reboot loops
        dnf.yum.misc.unlink_f(self.magic_symlink)
        command = self.state.upgrade_command
        if not command:
            command = self.opts.command
        self._check_state_version(command)
        if not self.state.upgrade_status == &#039;ready&#039;:
            msg = _(&quot;use &#039;dnf {command} reboot&#039; to begin the upgrade&quot;).format(command=command)
            raise CliError(msg)

    # == run_*: run the action/prep the transaction ===========================

    def run_prepare(self):
        # make the magic symlink
        os.symlink(self.datadir, self.magic_symlink)
        # set upgrade_status so that the upgrade can run
        with self.state as state:
            state.upgrade_status = &#039;ready&#039;

    def run_reboot(self):
        self.run_prepare()

        if not self.opts.tid[0] == &quot;reboot&quot;:
            return

        self.log_status(_(&quot;Rebooting to perform upgrade.&quot;),
                        REBOOT_REQUESTED_ID)
        reboot()

    def run_download(self):
        # Mark everything in the world for upgrade/sync
        if self.opts.distro_sync:
            self.base.distro_sync()
        else:
            self.base.upgrade_all()

        if self.opts.command not in [&#039;offline-upgrade&#039;, &#039;offline-distrosync&#039;]:
            # Mark all installed groups and environments for upgrade
            self.base.read_comps()
            installed_groups = [g.id for g in self.base.comps.groups if self.base.history.group.get(g.id)]
            if installed_groups:
                self.base.env_group_upgrade(installed_groups)
            installed_environments = [g.id for g in self.base.comps.environments if self.base.history.env.get(g.id)]
            if installed_environments:
                self.base.env_group_upgrade(installed_environments)

        with self.state as state:
            state.download_status = &#039;downloading&#039;
            state.target_releasever = self.base.conf.releasever
            state.destdir = self.base.conf.destdir

    def run_upgrade(self):
        # change the upgrade status (so we can detect crashed upgrades later)
        command = &#039;&#039;
        with self.state as state:
            state.upgrade_status = &#039;incomplete&#039;
            command = state.upgrade_command
        if command == &#039;offline-upgrade&#039;:
            msg = _(&quot;Starting offline upgrade. This will take a while.&quot;)
        elif command == &#039;offline-distrosync&#039;:
            msg = _(&quot;Starting offline distrosync. This will take a while.&quot;)
        else:
            msg = _(&quot;Starting system upgrade. This will take a while.&quot;)

        self.log_status(msg, UPGRADE_STARTED_ID)

        # reset the splash mode and let the user know we&#039;re running
        Plymouth.set_mode()
        Plymouth.progress(0)
        Plymouth.message(msg)

        # disable screen blanking
        disable_blanking()

        self.replay = TransactionReplay(self.base, self.transaction_file)
        self.replay.run()

    def run_clean(self):
        logger.info(_(&quot;Cleaning up downloaded data...&quot;))
        # Don&#039;t delete persistor, it contains paths for downloaded packages
        # that are used by dnf during finalizing base to clean them up
        clear_dir(self.base.conf.cachedir,
                  [dnf.persistor.TempfilePersistor(self.base.conf.cachedir).db_path])
        with self.state as state:
            state.download_status = None
            state.state_version = None
            state.upgrade_status = None
            state.upgrade_command = None
            state.destdir = None

    def run_log(self):
        if self.opts.number:
            show_log(self.opts.number)
        else:
            list_logs()

    # == resolved_*: do staff after succesful resolvement =====================

    def resolved_upgrade(self):
        &quot;&quot;&quot;Adjust transaction reasons according to stored values&quot;&quot;&quot;
        self.replay.post_transaction()

    # == transaction_*: do stuff after a successful transaction ===============

    def transaction_download(self):
        transaction = self.base.history.get_current()

        if not transaction.packages():
            logger.info(_(&quot;The system-upgrade transaction is empty, your system is already up-to-date.&quot;))
            return

        data = serialize_transaction(transaction)
        try:
            with open(self.transaction_file, &quot;w&quot;) as f:
                json.dump(data, f, indent=4, sort_keys=True)
                f.write(&quot;\n&quot;)

            print(_(&quot;Transaction saved to {}.&quot;).format(self.transaction_file))

        except OSError as e:
            raise dnf.cli.CliError(_(&#039;Error storing transaction: {}&#039;).format(str(e)))

        # Okay! Write out the state so the upgrade can use it.
        system_ver = dnf.rpm.detect_releasever(self.base.conf.installroot)
        with self.state as state:
            state.download_status = &#039;complete&#039;
            state.state_version = STATE_VERSION
            state.distro_sync = self.opts.distro_sync
            state.gpgcheck = self.base.conf.gpgcheck
            state.gpgcheck_repos = [
                repo.id for repo in self.base.repos.values() if repo.gpgcheck]
            state.repo_gpgcheck_repos = [
                repo.id for repo in self.base.repos.values() if repo.repo_gpgcheck]
            state.system_releasever = system_ver
            state.target_releasever = self.base.conf.releasever
            state.module_platform_id = self.base.conf.module_platform_id
            state.enable_disable_repos = self.opts.repos_ed
            state.destdir = self.base.conf.destdir
            state.upgrade_command = self.opts.command

        msg = DOWNLOAD_FINISHED_MSG.format(command=self.opts.command)
        logger.info(msg)
        self.log_status(_(&quot;Download finished.&quot;), DOWNLOAD_FINISHED_ID)

    def transaction_upgrade(self):
        Plymouth.message(_(&quot;Upgrade complete! Cleaning up and rebooting...&quot;))
        self.log_status(_(&quot;Upgrade complete! Cleaning up and rebooting...&quot;),
                        UPGRADE_FINISHED_ID)
        self.run_clean()
        if self.opts.tid[0] == &quot;upgrade&quot;:
            reboot()


class OfflineUpgradeCommand(SystemUpgradeCommand):
    aliases = (&#039;offline-upgrade&#039;,)
    summary = _(&quot;Prepare offline upgrade of the system&quot;)


class OfflineDistrosyncCommand(SystemUpgradeCommand):
    aliases = (&#039;offline-distrosync&#039;,)
    summary = _(&quot;Prepare offline distrosync of the system&quot;)
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib/python3.6/site-packages/dnf-plugins/system_upgrade.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib%2Fpython3.6%2Fsite-packages%2Fdnf-plugins' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>