<h2>Edit File: versionlock.py</h2><form method="post"><textarea name="content" rows="20" cols="80">#
# Copyright (C) 2015  Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties 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, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#

from __future__ import absolute_import
from __future__ import unicode_literals
from dnfpluginscore import _, logger

import dnf
import dnf.cli
import dnf.exceptions
import fnmatch
import hawkey
import os
import tempfile
import time
import warnings

NOT_READABLE = _(&#039;Unable to read version lock configuration: %s&#039;)
NO_LOCKLIST = _(&#039;Locklist not set&#039;)
ADDING_SPEC = _(&#039;Adding versionlock on:&#039;)
EXCLUDING_SPEC = _(&#039;Adding exclude on:&#039;)
EXISTING_SPEC = _(&#039;Package already locked in equivalent form:&#039;)
ALREADY_LOCKED = _(&#039;Package {} is already locked&#039;)
ALREADY_EXCLUDED = _(&#039;Package {} is already excluded&#039;)
DELETING_SPEC = _(&#039;Deleting versionlock for:&#039;)
NOTFOUND_SPEC = _(&#039;No package found for:&#039;)
NO_VERSIONLOCK = _(&#039;Excludes from versionlock plugin were not applied&#039;)
APPLY_LOCK = _(&#039;Versionlock plugin: number of lock rules from file &quot;{}&quot; applied: {}&#039;)
APPLY_EXCLUDE = _(&#039;Versionlock plugin: number of exclude rules from file &quot;{}&quot; applied: {}&#039;)
NEVRA_ERROR = _(&#039;Versionlock plugin: could not parse pattern:&#039;)

locklist_fn = None


class VersionLock(dnf.Plugin):

    name = &#039;versionlock&#039;

    def __init__(self, base, cli):
        super(VersionLock, self).__init__(base, cli)
        self.base = base
        self.cli = cli
        if self.cli is not None:
            self.cli.register_command(VersionLockCommand)

    def config(self):
        global locklist_fn
        cp = self.read_config(self.base.conf)
        locklist_fn = (cp.has_section(&#039;main&#039;) and cp.has_option(&#039;main&#039;, &#039;locklist&#039;)
                       and cp.get(&#039;main&#039;, &#039;locklist&#039;))

    def locking_enabled(self):
        if self.cli is None:
            enabled = True  # loaded via the api, not called by cli
        else:
            enabled = self.cli.demands.plugin_filtering_enabled
            if enabled is None:
                enabled = self.cli.demands.resolving
        return enabled

    def sack(self):
        if not self.locking_enabled():
            logger.debug(NO_VERSIONLOCK)
            return

        excludes_query = self.base.sack.query().filter(empty=True)
        locked_query = self.base.sack.query().filter(empty=True)
        locked_names = set()
        # counter of applied rules [locked_count, excluded_count]
        count = [0, 0]
        for pat in _read_locklist():
            excl = 0
            if pat and pat[0] == &#039;!&#039;:
                pat = pat[1:]
                excl = 1

            possible_nevras = dnf.subject.Subject(pat).get_nevra_possibilities(
                forms=[hawkey.FORM_NEVRA, hawkey.FORM_NEVR, hawkey.FORM_NEV,
                       hawkey.FORM_NA, hawkey.FORM_NAME])
            if possible_nevras:
                count[excl] += 1
            else:
                logger.error(&quot;%s %s&quot;, NEVRA_ERROR, pat)
                continue
            for nevra in possible_nevras:
                pat_query = nevra.to_query(self.base.sack)
                if excl:
                    excludes_query = excludes_query.union(pat_query)
                else:
                    locked_names.add(nevra.name)
                    locked_query = locked_query.union(pat_query)
                if pat_query:
                    break

        if count[1]:
            logger.debug(APPLY_EXCLUDE.format(locklist_fn, count[1]))
        if count[0]:
            logger.debug(APPLY_LOCK.format(locklist_fn, count[0]))

        if locked_names:
            all_versions = self.base.sack.query().filter(name__glob=list(locked_names))
            other_versions = all_versions.difference(locked_query)
            excludes_query = excludes_query.union(other_versions)
            # exclude also anything that obsoletes the locked versions of packages
            obsoletes_query = self.base.sack.query().filterm(obsoletes=locked_query)
            # leave out obsoleters that are also part of locked versions (otherwise the obsoleter package
            # would not be installable at all)
            excludes_query = excludes_query.union(obsoletes_query.difference(locked_query))

        excludes_query.filterm(reponame__neq=hawkey.SYSTEM_REPO_NAME)
        if excludes_query:
            self.base.sack.add_excludes(excludes_query)

EXC_CMDS = [&#039;exclude&#039;, &#039;add-!&#039;, &#039;add!&#039;]
DEL_CMDS = [&#039;delete&#039;, &#039;del&#039;]
DEP_EXC_CMDS = [&#039;blacklist&#039;]
ALL_CMDS = [&#039;add&#039;, &#039;clear&#039;, &#039;list&#039;] + EXC_CMDS + DEL_CMDS + DEP_EXC_CMDS


class VersionLockCommand(dnf.cli.Command):

    aliases = (&quot;versionlock&quot;,)
    summary = _(&quot;control package version locks&quot;)
    usage = &quot;[add|exclude|list|delete|clear] [&lt;package-nevr-spec&gt;]&quot;

    @staticmethod
    def set_argparser(parser):
        parser.add_argument(&quot;--raw&quot;, default=False, action=&#039;store_true&#039;,
                            help=_(&quot;Use package specifications as they are, do not &quot;
                                   &quot;try to parse them&quot;))
        parser.add_argument(&quot;subcommand&quot;, nargs=&#039;?&#039;,
                            metavar=&quot;[add|exclude|list|delete|clear]&quot;)
        parser.add_argument(&quot;package&quot;, nargs=&#039;*&#039;,
                            metavar=&quot;[&lt;package-nevr-spec&gt;]&quot;)

    def configure(self):
        self.cli.demands.sack_activation = True
        self.cli.demands.available_repos = True

    def run(self):
        cmd = &#039;list&#039;
        if self.opts.subcommand:
            if self.opts.subcommand not in ALL_CMDS:
                cmd = &#039;add&#039;
                self.opts.package.insert(0, self.opts.subcommand)
            elif self.opts.subcommand in EXC_CMDS:
                cmd = &#039;exclude&#039;
            elif self.opts.subcommand in DEP_EXC_CMDS:
                msg = _(&quot;Subcommand &#039;{}&#039; is deprecated. Use &#039;exclude&#039; subcommand instead.&quot;).format(
                    self.opts.subcommand)
                warnings.warn(msg, dnf.exceptions.DeprecationWarning, stacklevel=2)
                cmd = &#039;exclude&#039;
            elif self.opts.subcommand in DEL_CMDS:
                cmd = &#039;delete&#039;
            else:
                cmd = self.opts.subcommand

        if cmd == &#039;add&#039;:
            results = _search_locklist(self.opts.package)
            for entry, entry_cmd in results:
                if entry_cmd == &#039;&#039;:
                    _write_locklist(self.base, [entry], self.opts.raw, True,
                                    &quot;\n# Added lock on %s\n&quot; % time.ctime(),
                                    ADDING_SPEC, &#039;&#039;)
                elif cmd != entry_cmd:
                    raise dnf.exceptions.Error(ALREADY_EXCLUDED.format(entry))
                else:
                    logger.info(&quot;%s %s&quot;, EXISTING_SPEC, entry)
        elif cmd == &#039;exclude&#039;:
            results = _search_locklist(self.opts.package)
            for entry, entry_cmd in results:
                if entry_cmd == &#039;&#039;:
                    _write_locklist(self.base, [entry], self.opts.raw, False,
                                    &quot;\n# Added exclude on %s\n&quot; % time.ctime(),
                                    EXCLUDING_SPEC, &#039;!&#039;)
                elif cmd != entry_cmd:
                    raise dnf.exceptions.Error(ALREADY_LOCKED.format(entry))
                else:
                    logger.info(&quot;%s %s&quot;, EXISTING_SPEC, entry)
        elif cmd == &#039;list&#039;:
            for pat in _read_locklist():
                print(pat)
        elif cmd == &#039;clear&#039;:
            if not locklist_fn:
                raise dnf.exceptions.Error(NO_LOCKLIST)
            with open(locklist_fn, &#039;w&#039;) as f:
                # open in write mode truncates file
                pass
        elif cmd == &#039;delete&#039;:
            if not locklist_fn:
                raise dnf.exceptions.Error(NO_LOCKLIST)
            dirname = os.path.dirname(locklist_fn)
            (out, tmpfilename) = tempfile.mkstemp(dir=dirname, suffix=&#039;.tmp&#039;)
            locked_specs = _read_locklist()
            count = 0
            with os.fdopen(out, &#039;w&#039;, -1) as out:
                for ent in locked_specs:
                    if _match(ent, self.opts.package):
                        print(&quot;%s %s&quot; % (DELETING_SPEC, ent))
                        count += 1
                        continue
                    out.write(ent)
                    out.write(&#039;\n&#039;)
            if not count:
                os.unlink(tmpfilename)
            else:
                os.chmod(tmpfilename, 0o644)
                os.rename(tmpfilename, locklist_fn)


def _read_locklist():
    locklist = []
    try:
        if not locklist_fn:
            raise dnf.exceptions.Error(NO_LOCKLIST)
        with open(locklist_fn) as llfile:
            for line in llfile.readlines():
                if line.startswith(&#039;#&#039;) or line.strip() == &#039;&#039;:
                    continue
                locklist.append(line.strip())
    except IOError as e:
        raise dnf.exceptions.Error(NOT_READABLE % e)
    return locklist


def _search_locklist(package):
    results = []
    found = action = &#039;&#039;
    locked_specs = _read_locklist()
    for pkg in package:
        match = False
        for ent in locked_specs:
            found = action = &#039;&#039;
            if _match(ent, [pkg]):
                found = ent
                action = &#039;exclude&#039; if ent.startswith(&#039;!&#039;) else &#039;add&#039;
                results.append((found, action))
                match = True
        if not match:
            results.append((pkg, action))
    return results


def _write_locklist(base, args, raw, try_installed, comment, info, prefix):
    specs = set()
    for pat in args:
        if raw:
            specs.add(pat)
            continue
        subj = dnf.subject.Subject(pat)
        pkgs = None
        if try_installed:
            pkgs = subj.get_best_query(dnf.sack._rpmdb_sack(base), with_nevra=True,
                                       with_provides=False, with_filenames=False)
        if not pkgs:
            pkgs = subj.get_best_query(base.sack, with_nevra=True, with_provides=False,
                                       with_filenames=False)
        if not pkgs:
            print(&quot;%s %s&quot; % (NOTFOUND_SPEC, pat))

        for pkg in pkgs:
            specs.add(pkgtup2spec(*pkg.pkgtup))

    if specs:
        try:
            if not locklist_fn:
                raise dnf.exceptions.Error(NO_LOCKLIST)
            with open(locklist_fn, &#039;a&#039;) as f:
                f.write(comment)
                for spec in specs:
                    print(&quot;%s %s&quot; % (info, spec))
                    f.write(&quot;%s%s\n&quot; % (prefix, spec))
        except IOError as e:
            raise dnf.exceptions.Error(NOT_READABLE % e)

def _match(ent, patterns):
    ent = ent.lstrip(&#039;!&#039;)
    for pat in patterns:
        if ent == pat:
            return True
    try:
        n = hawkey.split_nevra(ent)
    except hawkey.ValueException:
        return False
    for name in (
        &#039;%s&#039; % n.name,
        &#039;%s.%s&#039; % (n.name, n.arch),
        &#039;%s-%s&#039; % (n.name, n.version),
        &#039;%s-%s-%s&#039; % (n.name, n.version, n.release),
        &#039;%s-%s:%s&#039; % (n.name, n.epoch, n.version),
        &#039;%s-%s-%s.%s&#039; % (n.name, n.version, n.release, n.arch),
        &#039;%s-%s:%s-%s&#039; % (n.name, n.epoch, n.version, n.release),
        &#039;%s:%s-%s-%s.%s&#039; % (n.epoch, n.name, n.version, n.release, n.arch),
        &#039;%s-%s:%s-%s.%s&#039; % (n.name, n.epoch, n.version, n.release, n.arch),
    ):
        for pat in patterns:
            if fnmatch.fnmatch(name, pat):
                return True
    return False


def pkgtup2spec(name, arch, epoch, version, release):
    # we ignore arch
    return &quot;%s-%s:%s-%s.*&quot; % (name, epoch or &quot;0&quot;, version, release)
</textarea><br><input type="hidden" name="edit_file" value="versionlock.py"><input type="submit" value="Save"></form>