Add --nousepkg-atoms, --useoldpkg-atoms and --reinstall-atoms flag to Portage

pym/_emerge/depgraph.py

 # Copyright 1999-2011 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 from __future__ import print_function
 
 import gc
 import logging
 import re
 import sys
 import textwrap
@@ skipping 50 matching lines @@
         basestring = str
         long = int
 
 class _scheduler_graph_config(object):
         def __init__(self, trees, pkg_cache, graph, mergelist):
                 self.trees = trees
                 self.pkg_cache = pkg_cache
                 self.graph = graph
                 self.mergelist = mergelist
 
+def _wildcard_set(atoms):
+        pkgs = InternalPackageSet(allow_wildcard=True)
+        for x in atoms:
+                try:
+                        x = Atom(x, allow_wildcard=True)
+                except portage.exception.InvalidAtom:
+                        x = Atom("*/" + x, allow_wildcard=True)
+                pkgs.add(x)
+        return pkgs
+
 class _frozen_depgraph_config(object):
 
         def __init__(self, settings, trees, myopts, spinner):
                 self.settings = settings
                 self.target_root = settings["ROOT"]
                 self.myopts = myopts
                 self.edebug = 0
                 if settings.get("PORTAGE_DEBUG", "") == "1":
                         self.edebug = 1
                 self.spinner = spinner
@@ skipping 19 matching lines @@
                                 self.trees[myroot][tree] = trees[myroot][tree]
                         self.trees[myroot]["vartree"] = \
                                 FakeVartree(trees[myroot]["root_config"],
                                         pkg_cache=self._pkg_cache,
                                         pkg_root_config=self.roots[myroot])
                         self.pkgsettings[myroot] = portage.config(
                                 clone=self.trees[myroot]["vartree"].settings)
 
                 self._required_set_names = set(["world"])
 
-                self.excluded_pkgs = InternalPackageSet(allow_wildcard=True)
-                for x in ' '.join(myopts.get("--exclude", [])).split():
-                        try:
-                                x = Atom(x, allow_wildcard=True)
-                        except portage.exception.InvalidAtom:
-                                x = Atom("*/" + x, allow_wildcard=True)
-                        self.excluded_pkgs.add(x)
+                atoms = ' '.join(myopts.get("--exclude", [])).split()
+                self.excluded_pkgs = _wildcard_set(atoms)
+                atoms = ' '.join(myopts.get("--reinstall-atoms", [])).split()
+                self.reinstall_atoms = _wildcard_set(atoms)
+                atoms = ' '.join(myopts.get("--nousepkg-atoms", [])).split()
+                self.nousepkg_atoms = _wildcard_set(atoms)
+                atoms = ' '.join(myopts.get("--useoldpkg-atoms", [])).split()
+                self.useoldpkg_atoms = _wildcard_set(atoms)
 
 class _depgraph_sets(object):
         def __init__(self):
                 # contains all sets added to the graph
                 self.sets = {}
                 # contains non-set atoms given as arguments
                 self.sets['__non_set_args__'] = InternalPackageSet()
                 # contains all atoms from all sets added to the graph, including
                 # atoms given as arguments
                 self.atoms = InternalPackageSet()
@@ skipping 1137 matching lines @@
                         raise
 
                 if debug:
                         writemsg_level("Candidates: %s\n" % \
                                 ([str(x) for x in selected_atoms[pkg]],),
                                 noiselevel=-1, level=logging.DEBUG)
 
                 root_config = self._frozen_config.roots[dep_root]
                 vardb = root_config.trees["vartree"].dbapi
 
+                reinstall_atoms = self._frozen_config.reinstall_atoms
                 for atom, child in self._minimize_children(
                         pkg, dep_priority, root_config, selected_atoms[pkg]):
 
                         if ignore_blockers and atom.blocker:
                                 # For --with-bdeps, ignore build-time only blockers
                                 # that originate from built packages.
                                 continue
 
                         mypriority = dep_priority.copy()
                         if not atom.blocker:
-                                inst_pkgs = vardb.match_pkgs(atom)
+                                inst_pkgs = [inst_pkg for inst_pkg in vardb.match_pkgs(atom)
+                                        if not reinstall_atoms.findAtomForPackage(inst_pkg,
+                                                        modified_use=self._pkg_use_enabled(inst_pkg))]
                                 if inst_pkgs:
                                         for inst_pkg in inst_pkgs:
                                                 if self._pkg_visibility_check(inst_pkg):
                                                         # highest visible
                                                         mypriority.satisfied = inst_pkg
                                                         break
                                         if not mypriority.satisfied:
                                                 # none visible, so use highest
                                                 mypriority.satisfied = inst_pkgs[0]
 
@@ skipping 25 matching lines @@
                                 Dependency(atom=Atom('=' + virt_pkg.cpv),
                                 depth=(depth + 1), parent=pkg, priority=dep_priority.copy(),
                                 root=dep_root)):
                                 return 0
 
                         for atom, child in self._minimize_children(
                                 pkg, self._priority(runtime=True), root_config, atoms):
                                 # This is a GLEP 37 virtual, so its deps are all runtime.
                                 mypriority = self._priority(runtime=True)
                                 if not atom.blocker:
-                                        inst_pkgs = vardb.match_pkgs(atom)
+                                        inst_pkgs = [inst_pkg for inst_pkg in vardb.match_pkgs(atom)
+                                                if not reinstall_atoms.findAtomForPackage(inst_pkg,
+                                                                modified_use=self._pkg_use_enabled(inst_pkg))]
                                         if inst_pkgs:
                                                 for inst_pkg in inst_pkgs:
                                                         if self._pkg_visibility_check(inst_pkg):
                                                                 # highest visible
                                                                 mypriority.satisfied = inst_pkg
                                                                 break
                                                 if not mypriority.satisfied:
                                                         # none visible, so use highest
                                                         mypriority.satisfied = inst_pkgs[0]
 
@@ skipping 1498 matching lines @@
                 rebuilt_binaries = 'rebuilt_binaries' in self._dynamic_config.myparams
                 usepkgonly = "--usepkgonly" in self._frozen_config.myopts
                 empty = "empty" in self._dynamic_config.myparams
                 selective = "selective" in self._dynamic_config.myparams
                 reinstall = False
                 noreplace = "--noreplace" in self._frozen_config.myopts
                 avoid_update = "--update" not in self._frozen_config.myopts
                 dont_miss_updates = "--update" in self._frozen_config.myopts
                 use_ebuild_visibility = self._frozen_config.myopts.get(
                         '--use-ebuild-visibility', 'n') != 'n'
+                reinstall_atoms = self._frozen_config.reinstall_atoms
+                nousepkg_atoms = self._frozen_config.nousepkg_atoms
+                useoldpkg_atoms = self._frozen_config.useoldpkg_atoms
+                matched_oldpkg = []
                 # Behavior of the "selective" parameter depends on
                 # whether or not a package matches an argument atom.
                 # If an installed package provides an old-style
                 # virtual that is no longer provided by an available
                 # package, the installed package may match an argument
                 # atom even though none of the available packages do.
                 # Therefore, "selective" logic does not consider
                 # whether or not an installed package matches an
                 # argument atom. It only considers whether or not
                 # available packages match argument atoms, which is
@@ skipping 19 matching lines @@
                                         onlydeps=onlydeps):
                                         if pkg in self._dynamic_config._runtime_pkg_mask:
                                                 # The package has been masked by the backtracking logic
                                                 continue
 
                                         if not pkg.installed and \
                                                 self._frozen_config.excluded_pkgs.findAtomForPackage(pkg, \
                                                         modified_use=self._pkg_use_enabled(pkg)):
                                                 continue
 
-                                        if packages_with_invalid_use_config and \
+                                        if built and not installed and nousepkg_atoms.findAtomForPackage(pkg, \
+                                                modified_use=self._pkg_use_enabled(pkg)):
+                                                break
+
+                                        useoldpkg = useoldpkg_atoms.findAtomForPackage(pkg, \
+                                                modified_use=self._pkg_use_enabled(pkg))
+
+                                        if packages_with_invalid_use_config and (not built or not useoldpkg) and \
                                                 (not pkg.installed or dont_miss_updates):
                                                 # Check if a higher version was rejected due to user
                                                 # USE configuration. The packages_with_invalid_use_config
                                                 # list only contains unbuilt ebuilds since USE can't
                                                 # be changed for built packages.
                                                 higher_version_rejected = False
                                                 for rejected in packages_with_invalid_use_config:
                                                         if rejected.cp != pkg.cp:
                                                                 continue
                                                         if rejected > pkg:
@@ skipping 37 matching lines @@
                                                 # version is masked by KEYWORDS, but never
                                                 # reinstall the same exact version only due
                                                 # to a KEYWORDS mask. See bug #252167.
 
                                                 if pkg.type_name != "ebuild" and matched_packages:
                                                                 # If the ebuild no longer exists or it's
                                                                 # keywords have been dropped, reject built
                                                                 # instances (installed or binary).
                                                                 # If --usepkgonly is enabled, assume that
                                                                 # the ebuild status should be ignored.
-                                                                if not use_ebuild_visibility and usepkgonly:
+                                                                if not use_ebuild_visibility and (usepkgonly or useoldpkg):
                                                                         if pkg.installed and pkg.masks:
                                                                                 continue
                                                                 else:
                                                                         try:
                                                                                 pkg_eb = self._pkg(
                                                                                         pkg.cpv, "ebuild", root_config)
                                                                         except portage.exception.PackageNotFound:
                                                                                 continue
                                                                         else:
                                                                                 if not self._pkg_visibility_check(pkg_eb, \
@@ skipping 124 matching lines @@
                                                                 # There is a higher version available in a
                                                                 # different slot, so this existing node is
                                                                 # irrelevant.
                                                                 pass
                                                         else:
                                                                 matched_packages.append(e_pkg)
                                                                 existing_node = e_pkg
                                                 break
                                         # Compare built package to current config and
                                         # reject the built package if necessary.
-                                        if built and (not installed or matched_pkgs_ignore_use) and \
+                                        if built and not useoldpkg and (not installed or matched_pkgs_ignore_use) and \
                                                 ("--newuse" in self._frozen_config.myopts or \
                                                 "--reinstall" in self._frozen_config.myopts or \
                                                 "--binpkg-respect-use" in self._frozen_config.myopts):
                                                 iuses = pkg.iuse.all
                                                 old_use = self._pkg_use_enabled(pkg)
                                                 if myeb:
                                                         pkgsettings.setcpv(myeb)
                                                 else:
                                                         pkgsettings.setcpv(pkg)
                                                 now_use = pkgsettings["PORTAGE_USE"].split()
                                                 forced_flags = set()
                                                 forced_flags.update(pkgsettings.useforce)
                                                 forced_flags.update(pkgsettings.usemask)
                                                 cur_iuse = iuses
-                                                if myeb and not usepkgonly:
+                                                if myeb and not usepkgonly and not useoldpkg:
                                                         cur_iuse = myeb.iuse.all
                                                 if self._reinstall_for_flags(forced_flags,
                                                         old_use, iuses,
                                                         now_use, cur_iuse):
                                                         break
                                         # Compare current config to installed package
                                         # and do not reinstall if possible.
-                                        if not installed and \
+                                        if not installed and not useoldpkg and \
                                                 ("--newuse" in self._frozen_config.myopts or \
                                                 "--reinstall" in self._frozen_config.myopts) and \
                                                 cpv in vardb.match(atom):
                                                 forced_flags = set()
                                                 forced_flags.update(pkg.use.force)
                                                 forced_flags.update(pkg.use.mask)
                                                 inst_pkg = vardb.match_pkgs('=' + pkg.cpv)[0]
                                                 old_use = inst_pkg.use.enabled
                                                 old_iuse = inst_pkg.iuse.all
                                                 cur_use = self._pkg_use_enabled(pkg)
                                                 cur_iuse = pkg.iuse.all
                                                 reinstall_for_flags = \
                                                         self._reinstall_for_flags(
                                                         forced_flags, old_use, old_iuse,
                                                         cur_use, cur_iuse)
                                                 if reinstall_for_flags:
                                                         reinstall = True
+                                        if reinstall_atoms.findAtomForPackage(pkg, \
+                                                        modified_use=self._pkg_use_enabled(pkg)):
+                                                reinstall = True
                                         if not built:
                                                 myeb = pkg
+                                        elif useoldpkg:
+                                                matched_oldpkg.append(pkg)
                                         matched_packages.append(pkg)
                                         if reinstall_for_flags:
                                                 self._dynamic_config._reinstall_nodes[pkg] = \
                                                         reinstall_for_flags
                                         break
 
                 if not matched_packages:
                         return None, None
 
                 if "--debug" in self._frozen_config.myopts:
@@ skipping 63 matching lines @@
                                         matched_packages = [x for x in \
                                                 matched_packages if x is not pkg]
 
                         if avoid_update:
                                 for pkg in matched_packages:
                                         if pkg.installed and self._pkg_visibility_check(pkg, \
                                                 allow_unstable_keywords=allow_unstable_keywords,
                                                 allow_license_changes=allow_license_changes):
                                                 return pkg, existing_node
 
-                        bestmatch = portage.best(
-                                [pkg.cpv for pkg in matched_packages \
+                        visible_matches = []
+                        if matched_oldpkg:
+                                visible_matches = [pkg.cpv for pkg in matched_oldpkg \
                                         if self._pkg_visibility_check(pkg, allow_unstable_keywords=allow_unstable_keywords,
-                                                allow_license_changes=allow_license_changes)])
-                        if not bestmatch:
+                                                allow_license_changes=allow_license_changes)]
+                        if not visible_matches:
+                                visible_matches = [pkg.cpv for pkg in matched_packages \
+                                        if self._pkg_visibility_check(pkg, allow_unstable_keywords=allow_unstable_keywords,
+                                                allow_license_changes=allow_license_changes)]
+                        if visible_matches:
+                                bestmatch = portage.best(visible_matches)
+                        else:
                                 # all are masked, so ignore visibility
-                                bestmatch = portage.best(
-                                        [pkg.cpv for pkg in matched_packages])
+                                bestmatch = portage.best([pkg.cpv for pkg in matched_packages])
                         matched_packages = [pkg for pkg in matched_packages \
                                 if portage.dep.cpvequal(pkg.cpv, bestmatch)]
 
                 # ordered by type preference ("ebuild" type is the last resort)
                 return  matched_packages[-1], existing_node
 
         def _select_pkg_from_graph(self, root, atom, onlydeps=False):
                 """
                 Select packages that have already been added to the graph or
                 those that are installed and have not been scheduled for
@@ skipping 2572 matching lines @@
                 for msg_type, msgs in pkg.invalid.items():
                         for msg in msgs:
                                 mreasons.append(
                                         _MaskReason("invalid", "invalid: %s" % (msg,)))
 
         if not pkg.metadata["SLOT"]:
                 mreasons.append(
                         _MaskReason("invalid", "SLOT: undefined"))
 
         return mreasons