from portage import _unicode_decode
from portage.const import PORTAGE_PACKAGE_ATOM
from portage.dbapi import dbapi
-from portage.dbapi.dep_expand import dep_expand
from portage.dep import Atom, extract_affecting_use, check_required_use, human_readable_required_use
from portage.eapi import eapi_has_strong_blocks, eapi_has_required_use
from portage.exception import InvalidAtom
-from portage.output import bold, blue, colorize, create_color_func, darkblue, \
- darkgreen, green, nc_len, red, teal, turquoise, yellow
+from portage.output import colorize, create_color_func, \
+ darkgreen, green
bad = create_color_func("BAD")
from portage.package.ebuild.getmaskingstatus import \
_getmaskingstatus, _MaskReason
from _emerge.Blocker import Blocker
from _emerge.BlockerCache import BlockerCache
from _emerge.BlockerDepPriority import BlockerDepPriority
-from _emerge.changelog import calc_changelog
from _emerge.countdown import countdown
from _emerge.create_world_atom import create_world_atom
from _emerge.Dependency import Dependency
from _emerge.DepPrioritySatisfiedRange import DepPrioritySatisfiedRange
from _emerge.FakeVartree import FakeVartree
from _emerge._find_deep_system_runtime_deps import _find_deep_system_runtime_deps
-from _emerge.format_size import format_size
from _emerge.is_valid_package_atom import is_valid_package_atom
from _emerge.Package import Package
from _emerge.PackageArg import PackageArg
-from _emerge.PackageCounters import PackageCounters
from _emerge.PackageVirtualDbapi import PackageVirtualDbapi
-from _emerge.RepoDisplay import RepoDisplay
from _emerge.RootConfig import RootConfig
from _emerge.search import search
from _emerge.SetArg import SetArg
from _emerge.resolver.slot_collision import slot_conflict_handler
from _emerge.resolver.circular_dependency import circular_dependency_handler
+from _emerge.resolver.output import display, filter_iuse_defaults
if sys.hexversion >= 0x3000000:
basestring = str
# again via _show_merge_list().
self._dynamic_config._displayed_list = mylist
- if verbosity is None:
- verbosity = ("--quiet" in self._frozen_config.myopts and 1 or \
- "--verbose" in self._frozen_config.myopts and 3 or 2)
- favorites_set = InternalPackageSet(favorites)
- oneshot = "--oneshot" in self._frozen_config.myopts or \
- "--onlydeps" in self._frozen_config.myopts
- columns = "--columns" in self._frozen_config.myopts
- tree_display = "--tree" in self._frozen_config.myopts
- changelogs=[]
- p=[]
- blockers = []
-
- counters = PackageCounters()
-
- if verbosity == 1 and "--verbose" not in self._frozen_config.myopts:
- def create_use_string(*args):
- return ""
- else:
- def create_use_string(name, cur_iuse, iuse_forced, cur_use,
- old_iuse, old_use,
- is_new, reinst_flags,
- all_flags=(verbosity == 3 or "--quiet" in self._frozen_config.myopts),
- alphabetical=("--alphabetical" in self._frozen_config.myopts)):
- enabled = []
- if alphabetical:
- disabled = enabled
- removed = enabled
- else:
- disabled = []
- removed = []
- cur_iuse = set(cur_iuse)
- enabled_flags = cur_iuse.intersection(cur_use)
- removed_iuse = set(old_iuse).difference(cur_iuse)
- any_iuse = cur_iuse.union(old_iuse)
- any_iuse = list(any_iuse)
- any_iuse.sort()
- for flag in any_iuse:
- flag_str = None
- isEnabled = False
- reinst_flag = reinst_flags and flag in reinst_flags
- if flag in enabled_flags:
- isEnabled = True
- if is_new or flag in old_use and \
- (all_flags or reinst_flag):
- flag_str = red(flag)
- elif flag not in old_iuse:
- flag_str = yellow(flag) + "%*"
- elif flag not in old_use:
- flag_str = green(flag) + "*"
- elif flag in removed_iuse:
- if all_flags or reinst_flag:
- flag_str = yellow("-" + flag) + "%"
- if flag in old_use:
- flag_str += "*"
- flag_str = "(" + flag_str + ")"
- removed.append(flag_str)
- continue
- else:
- if is_new or flag in old_iuse and \
- flag not in old_use and \
- (all_flags or reinst_flag):
- flag_str = blue("-" + flag)
- elif flag not in old_iuse:
- flag_str = yellow("-" + flag)
- if flag not in iuse_forced:
- flag_str += "%"
- elif flag in old_use:
- flag_str = green("-" + flag) + "*"
- if flag_str:
- if flag in iuse_forced:
- flag_str = "(" + flag_str + ")"
- if isEnabled:
- enabled.append(flag_str)
- else:
- disabled.append(flag_str)
-
- if alphabetical:
- ret = " ".join(enabled)
- else:
- ret = " ".join(enabled + disabled + removed)
- if ret:
- ret = '%s="%s" ' % (name, ret)
- return ret
-
- repo_display = RepoDisplay(self._frozen_config.roots)
- unsatisfied_blockers = []
- ordered_nodes = []
- for x in mylist:
- if isinstance(x, Blocker):
- counters.blocks += 1
- if x.satisfied:
- ordered_nodes.append(x)
- counters.blocks_satisfied += 1
- else:
- unsatisfied_blockers.append(x)
- else:
- ordered_nodes.append(x)
-
- if tree_display:
- display_list = self._tree_display(ordered_nodes)
- else:
- display_list = [(x, 0, True) for x in ordered_nodes]
-
- mylist = display_list
- for x in unsatisfied_blockers:
- mylist.append((x, 0, True))
-
- # files to fetch list - avoids counting a same file twice
- # in size display (verbose mode)
- myfetchlist=[]
-
- # Use this set to detect when all the "repoadd" strings are "[0]"
- # and disable the entire repo display in this case.
- repoadd_set = set()
-
- for mylist_index in range(len(mylist)):
- x, depth, ordered = mylist[mylist_index]
- pkg_type = x[0]
- myroot = x[1]
- pkg_key = x[2]
- portdb = self._frozen_config.trees[myroot]["porttree"].dbapi
- bindb = self._frozen_config.trees[myroot]["bintree"].dbapi
- vardb = self._frozen_config.trees[myroot]["vartree"].dbapi
- vartree = self._frozen_config.trees[myroot]["vartree"]
- pkgsettings = self._frozen_config.pkgsettings[myroot]
-
- fetch=" "
- indent = " " * depth
-
- if isinstance(x, Blocker):
- if x.satisfied:
- blocker_style = "PKG_BLOCKER_SATISFIED"
- addl = "%s %s " % (colorize(blocker_style, "b"), fetch)
- else:
- blocker_style = "PKG_BLOCKER"
- addl = "%s %s " % (colorize(blocker_style, "B"), fetch)
- resolved = dep_expand(
- str(x.atom).lstrip("!"), mydb=vardb, settings=pkgsettings)
- if "--columns" in self._frozen_config.myopts and "--quiet" in self._frozen_config.myopts:
- addl += " " + colorize(blocker_style, str(resolved))
- else:
- addl = "[%s %s] %s%s" % \
- (colorize(blocker_style, "blocks"),
- addl, indent, colorize(blocker_style, str(resolved)))
- block_parents = self._dynamic_config._blocker_parents.parent_nodes(x)
- block_parents = set([pnode[2] for pnode in block_parents])
- block_parents = ", ".join(block_parents)
- if resolved!=x[2]:
- addl += colorize(blocker_style,
- " (\"%s\" is blocking %s)") % \
- (str(x.atom).lstrip("!"), block_parents)
- else:
- addl += colorize(blocker_style,
- " (is blocking %s)") % block_parents
- if isinstance(x, Blocker) and x.satisfied:
- if columns:
- continue
- p.append(addl)
- else:
- blockers.append(addl)
- else:
- pkg_status = x[3]
- pkg_merge = ordered and pkg_status == "merge"
- if not pkg_merge and pkg_status == "merge":
- pkg_status = "nomerge"
- built = pkg_type != "ebuild"
- installed = pkg_type == "installed"
- pkg = x
- metadata = pkg.metadata
- ebuild_path = None
- repo_name = metadata["repository"]
- if pkg.type_name == "ebuild":
- ebuild_path = portdb.findname(pkg.cpv)
- if ebuild_path is None:
- raise AssertionError(
- "ebuild not found for '%s'" % pkg.cpv)
- repo_path_real = os.path.dirname(os.path.dirname(
- os.path.dirname(ebuild_path)))
- else:
- repo_path_real = portdb.getRepositoryPath(repo_name)
- pkg_use = list(self._pkg_use_enabled(pkg))
- if not pkg.built and pkg.operation == 'merge' and \
- 'fetch' in pkg.metadata.restrict:
- fetch = red("F")
- if ordered:
- counters.restrict_fetch += 1
- if portdb.fetch_check(pkg_key, pkg_use):
- fetch = green("f")
- if ordered:
- counters.restrict_fetch_satisfied += 1
-
- #we need to use "--emptrytree" testing here rather than "empty" param testing because "empty"
- #param is used for -u, where you still *do* want to see when something is being upgraded.
- myoldbest = []
- myinslotlist = None
- installed_versions = vardb.match(portage.cpv_getkey(pkg_key))
- if vardb.cpv_exists(pkg_key):
- addl=" "+yellow("R")+fetch+" "
- if ordered:
- if pkg_merge:
- counters.reinst += 1
- if pkg_type == "binary":
- counters.binary += 1
- elif pkg_status == "uninstall":
- counters.uninst += 1
- # filter out old-style virtual matches
- elif installed_versions and \
- portage.cpv_getkey(installed_versions[0]) == \
- portage.cpv_getkey(pkg_key):
- myinslotlist = vardb.match(pkg.slot_atom)
- # If this is the first install of a new-style virtual, we
- # need to filter out old-style virtual matches.
- if myinslotlist and \
- portage.cpv_getkey(myinslotlist[0]) != \
- portage.cpv_getkey(pkg_key):
- myinslotlist = None
- if myinslotlist:
- myoldbest = myinslotlist[:]
- addl = " " + fetch
- if not portage.dep.cpvequal(pkg_key,
- portage.best([pkg_key] + myoldbest)):
- # Downgrade in slot
- addl += turquoise("U")+blue("D")
- if ordered:
- counters.downgrades += 1
- if pkg_type == "binary":
- counters.binary += 1
- else:
- # Update in slot
- addl += turquoise("U") + " "
- if ordered:
- counters.upgrades += 1
- if pkg_type == "binary":
- counters.binary += 1
- else:
- # New slot, mark it new.
- addl = " " + green("NS") + fetch + " "
- myoldbest = vardb.match(portage.cpv_getkey(pkg_key))
- if ordered:
- counters.newslot += 1
- if pkg_type == "binary":
- counters.binary += 1
-
- if "--changelog" in self._frozen_config.myopts:
- inst_matches = vardb.match(pkg.slot_atom)
- if inst_matches:
- ebuild_path_cl = ebuild_path
- if ebuild_path_cl is None:
- # binary package
- ebuild_path_cl = portdb.findname(pkg.cpv)
-
- if ebuild_path_cl is not None:
- changelogs.extend(calc_changelog(
- ebuild_path_cl, inst_matches[0], pkg.cpv))
- else:
- addl = " " + green("N") + " " + fetch + " "
- if ordered:
- counters.new += 1
- if pkg_type == "binary":
- counters.binary += 1
-
- verboseadd = ""
- repoadd = None
-
- if True:
- # USE flag display
- forced_flags = set()
- pkgsettings.setcpv(pkg) # for package.use.{mask,force}
- forced_flags.update(pkgsettings.useforce)
- forced_flags.update(pkgsettings.usemask)
-
- cur_use = [flag for flag in self._pkg_use_enabled(pkg) \
- if flag in pkg.iuse.all]
- cur_iuse = sorted(pkg.iuse.all)
-
- if myoldbest and myinslotlist:
- previous_cpv = myoldbest[0]
- else:
- previous_cpv = pkg.cpv
- if vardb.cpv_exists(previous_cpv):
- old_iuse, old_use = vardb.aux_get(
- previous_cpv, ["IUSE", "USE"])
- old_iuse = list(set(
- filter_iuse_defaults(old_iuse.split())))
- old_iuse.sort()
- old_use = old_use.split()
- is_new = False
- else:
- old_iuse = []
- old_use = []
- is_new = True
-
- old_use = [flag for flag in old_use if flag in old_iuse]
-
- use_expand = pkgsettings["USE_EXPAND"].lower().split()
- use_expand.sort()
- use_expand.reverse()
- use_expand_hidden = \
- pkgsettings["USE_EXPAND_HIDDEN"].lower().split()
-
- def map_to_use_expand(myvals, forcedFlags=False,
- removeHidden=True):
- ret = {}
- forced = {}
- for exp in use_expand:
- ret[exp] = []
- forced[exp] = set()
- for val in myvals[:]:
- if val.startswith(exp.lower()+"_"):
- if val in forced_flags:
- forced[exp].add(val[len(exp)+1:])
- ret[exp].append(val[len(exp)+1:])
- myvals.remove(val)
- ret["USE"] = myvals
- forced["USE"] = [val for val in myvals \
- if val in forced_flags]
- if removeHidden:
- for exp in use_expand_hidden:
- ret.pop(exp, None)
- if forcedFlags:
- return ret, forced
- return ret
-
- # Prevent USE_EXPAND_HIDDEN flags from being hidden if they
- # are the only thing that triggered reinstallation.
- reinst_flags_map = {}
- reinstall_for_flags = self._dynamic_config._reinstall_nodes.get(pkg)
- reinst_expand_map = None
- if reinstall_for_flags:
- reinst_flags_map = map_to_use_expand(
- list(reinstall_for_flags), removeHidden=False)
- for k in list(reinst_flags_map):
- if not reinst_flags_map[k]:
- del reinst_flags_map[k]
- if not reinst_flags_map.get("USE"):
- reinst_expand_map = reinst_flags_map.copy()
- reinst_expand_map.pop("USE", None)
- if reinst_expand_map and \
- not set(reinst_expand_map).difference(
- use_expand_hidden):
- use_expand_hidden = \
- set(use_expand_hidden).difference(
- reinst_expand_map)
-
- cur_iuse_map, iuse_forced = \
- map_to_use_expand(cur_iuse, forcedFlags=True)
- cur_use_map = map_to_use_expand(cur_use)
- old_iuse_map = map_to_use_expand(old_iuse)
- old_use_map = map_to_use_expand(old_use)
-
- use_expand.sort()
- use_expand.insert(0, "USE")
-
- for key in use_expand:
- if key in use_expand_hidden:
- continue
- verboseadd += create_use_string(key.upper(),
- cur_iuse_map[key], iuse_forced[key],
- cur_use_map[key], old_iuse_map[key],
- old_use_map[key], is_new,
- reinst_flags_map.get(key))
-
- if verbosity == 3:
- # size verbose
- mysize=0
- if pkg_type == "ebuild" and pkg_merge:
- try:
- myfilesdict = portdb.getfetchsizes(pkg_key,
- useflags=pkg_use, debug=self._frozen_config.edebug)
- except portage.exception.InvalidDependString as e:
- # should have been masked before it was selected
- raise
- if myfilesdict is None:
- myfilesdict="[empty/missing/bad digest]"
- else:
- for myfetchfile in myfilesdict:
- if myfetchfile not in myfetchlist:
- mysize+=myfilesdict[myfetchfile]
- myfetchlist.append(myfetchfile)
- if ordered:
- counters.totalsize += mysize
- verboseadd += format_size(mysize)
-
- # overlay verbose
- # assign index for a previous version in the same slot
- has_previous = False
- repo_name_prev = None
- slot_matches = vardb.match(pkg.slot_atom)
- if slot_matches:
- has_previous = True
- repo_name_prev = vardb.aux_get(slot_matches[0],
- ["repository"])[0]
-
- # now use the data to generate output
- if pkg.installed or not has_previous:
- repoadd = repo_display.repoStr(repo_path_real)
- else:
- repo_path_prev = None
- if repo_name_prev:
- repo_path_prev = portdb.getRepositoryPath(
- repo_name_prev)
- if repo_path_prev == repo_path_real:
- repoadd = repo_display.repoStr(repo_path_real)
- else:
- repoadd = "%s=>%s" % (
- repo_display.repoStr(repo_path_prev),
- repo_display.repoStr(repo_path_real))
- if repoadd:
- repoadd_set.add(repoadd)
-
- xs = [portage.cpv_getkey(pkg_key)] + \
- list(portage.catpkgsplit(pkg_key)[2:])
- if xs[2] == "r0":
- xs[2] = ""
- else:
- xs[2] = "-" + xs[2]
-
- mywidth = 130
- if "COLUMNWIDTH" in self._frozen_config.settings:
- try:
- mywidth = int(self._frozen_config.settings["COLUMNWIDTH"])
- except ValueError as e:
- portage.writemsg("!!! %s\n" % str(e), noiselevel=-1)
- portage.writemsg(
- "!!! Unable to parse COLUMNWIDTH='%s'\n" % \
- self._frozen_config.settings["COLUMNWIDTH"], noiselevel=-1)
- del e
- oldlp = mywidth - 30
- newlp = oldlp - 30
-
- # Convert myoldbest from a list to a string.
- if not myoldbest:
- myoldbest = ""
- else:
- for pos, key in enumerate(myoldbest):
- key = portage.catpkgsplit(key)[2] + \
- "-" + portage.catpkgsplit(key)[3]
- if key[-3:] == "-r0":
- key = key[:-3]
- myoldbest[pos] = key
- myoldbest = blue("["+", ".join(myoldbest)+"]")
-
- pkg_cp = xs[0]
- root_config = self._frozen_config.roots[myroot]
- system_set = root_config.sets["system"]
- world_set = root_config.sets["selected"]
-
- pkg_system = False
- pkg_world = False
- try:
- pkg_system = system_set.findAtomForPackage(pkg, modified_use=self._pkg_use_enabled(pkg))
- pkg_world = world_set.findAtomForPackage(pkg, modified_use=self._pkg_use_enabled(pkg))
- if not (oneshot or pkg_world) and \
- myroot == self._frozen_config.target_root and \
- favorites_set.findAtomForPackage(pkg, modified_use=self._pkg_use_enabled(pkg)):
- # Maybe it will be added to world now.
- if create_world_atom(pkg, favorites_set, root_config):
- pkg_world = True
- except portage.exception.InvalidDependString:
- # This is reported elsewhere if relevant.
- pass
-
- def pkgprint(pkg_str):
- if pkg_merge:
- if built:
- if pkg_system:
- return colorize("PKG_BINARY_MERGE_SYSTEM", pkg_str)
- elif pkg_world:
- return colorize("PKG_BINARY_MERGE_WORLD", pkg_str)
- else:
- return colorize("PKG_BINARY_MERGE", pkg_str)
- else:
- if pkg_system:
- return colorize("PKG_MERGE_SYSTEM", pkg_str)
- elif pkg_world:
- return colorize("PKG_MERGE_WORLD", pkg_str)
- else:
- return colorize("PKG_MERGE", pkg_str)
- elif pkg_status == "uninstall":
- return colorize("PKG_UNINSTALL", pkg_str)
- else:
- if pkg_system:
- return colorize("PKG_NOMERGE_SYSTEM", pkg_str)
- elif pkg_world:
- return colorize("PKG_NOMERGE_WORLD", pkg_str)
- else:
- return colorize("PKG_NOMERGE", pkg_str)
-
- if 'interactive' in pkg.metadata.properties and \
- pkg.operation == 'merge':
- addl = colorize("WARN", "I") + addl[1:]
- if ordered:
- counters.interactive += 1
-
- if x[1]!="/":
- if myoldbest:
- myoldbest +=" "
- if "--columns" in self._frozen_config.myopts:
- if "--quiet" in self._frozen_config.myopts:
- myprint=addl+" "+indent+pkgprint(pkg_cp)
- myprint=myprint+darkblue(" "+xs[1]+xs[2])+" "
- myprint=myprint+myoldbest
- myprint=myprint+darkgreen("to "+x[1])
- verboseadd = None
- else:
- if not pkg_merge:
- myprint = "[%s] %s%s" % \
- (pkgprint(pkg_status.ljust(13)),
- indent, pkgprint(pkg.cp))
- else:
- myprint = "[%s %s] %s%s" % \
- (pkgprint(pkg.type_name), addl,
- indent, pkgprint(pkg.cp))
- if (newlp-nc_len(myprint)) > 0:
- myprint=myprint+(" "*(newlp-nc_len(myprint)))
- myprint=myprint+"["+darkblue(xs[1]+xs[2])+"] "
- if (oldlp-nc_len(myprint)) > 0:
- myprint=myprint+" "*(oldlp-nc_len(myprint))
- myprint=myprint+myoldbest
- myprint += darkgreen("to " + pkg.root)
- else:
- if not pkg_merge:
- myprint = "[%s] " % pkgprint(pkg_status.ljust(13))
- else:
- myprint = "[%s %s] " % (pkgprint(pkg_type), addl)
- myprint += indent + pkgprint(pkg_key) + " " + \
- myoldbest + darkgreen("to " + myroot)
- else:
- if "--columns" in self._frozen_config.myopts:
- if "--quiet" in self._frozen_config.myopts:
- myprint=addl+" "+indent+pkgprint(pkg_cp)
- myprint=myprint+" "+green(xs[1]+xs[2])+" "
- myprint=myprint+myoldbest
- verboseadd = None
- else:
- if not pkg_merge:
- myprint = "[%s] %s%s" % \
- (pkgprint(pkg_status.ljust(13)),
- indent, pkgprint(pkg.cp))
- else:
- myprint = "[%s %s] %s%s" % \
- (pkgprint(pkg.type_name), addl,
- indent, pkgprint(pkg.cp))
- if (newlp-nc_len(myprint)) > 0:
- myprint=myprint+(" "*(newlp-nc_len(myprint)))
- myprint=myprint+green(" ["+xs[1]+xs[2]+"] ")
- if (oldlp-nc_len(myprint)) > 0:
- myprint=myprint+(" "*(oldlp-nc_len(myprint)))
- myprint += myoldbest
- else:
- if not pkg_merge:
- myprint = "[%s] %s%s %s" % \
- (pkgprint(pkg_status.ljust(13)),
- indent, pkgprint(pkg.cpv),
- myoldbest)
- else:
- myprint = "[%s %s] %s%s %s" % \
- (pkgprint(pkg_type), addl, indent,
- pkgprint(pkg.cpv), myoldbest)
-
- if columns and pkg.operation == "uninstall":
- continue
- p.append((myprint, verboseadd, repoadd))
-
- if "--tree" not in self._frozen_config.myopts and \
- "--quiet" not in self._frozen_config.myopts and \
- not self._frozen_config._opts_no_restart.intersection(self._frozen_config.myopts) and \
- pkg.root == self._frozen_config._running_root.root and \
- portage.match_from_list(
- portage.const.PORTAGE_PACKAGE_ATOM, [pkg]) and \
- "--quiet" not in self._frozen_config.myopts:
- if not vardb.cpv_exists(pkg.cpv) or \
- '9999' in pkg.cpv or \
- 'git' in pkg.inherited:
- if mylist_index < len(mylist) - 1:
- p.append(colorize("WARN", "*** Portage will stop merging at this point and reload itself,"))
- p.append(colorize("WARN", " then resume the merge."))
-
- show_repos = repoadd_set and repoadd_set != set(["0"])
-
- for x in p:
- if isinstance(x, basestring):
- writemsg_stdout("%s\n" % (x,), noiselevel=-1)
- continue
-
- myprint, verboseadd, repoadd = x
-
- if verboseadd:
- myprint += " " + verboseadd
-
- if show_repos and repoadd:
- myprint += " " + teal("[%s]" % repoadd)
-
- writemsg_stdout("%s\n" % (myprint,), noiselevel=-1)
-
- for x in blockers:
- writemsg_stdout("%s\n" % (x,), noiselevel=-1)
-
- if verbosity == 3:
- writemsg_stdout('\n%s\n' % (counters,), noiselevel=-1)
- if show_repos:
- # Use _unicode_decode() to force unicode format string so
- # that RepoDisplay.__unicode__() is called in python2.
- writemsg_stdout(_unicode_decode("%s") % (repo_display,),
- noiselevel=-1)
-
- if "--changelog" in self._frozen_config.myopts:
- writemsg_stdout('\n', noiselevel=-1)
- for revision,text in changelogs:
- writemsg_stdout(bold('*'+revision) + '\n' + text,
- noiselevel=-1)
-
- return os.EX_OK
-
- def _tree_display(self, mylist):
-
- # If there are any Uninstall instances, add the
- # corresponding blockers to the digraph.
- mygraph = self._dynamic_config.digraph.copy()
-
- executed_uninstalls = set(node for node in mylist \
- if isinstance(node, Package) and node.operation == "unmerge")
-
- for uninstall in self._dynamic_config._blocker_uninstalls.leaf_nodes():
- uninstall_parents = \
- self._dynamic_config._blocker_uninstalls.parent_nodes(uninstall)
- if not uninstall_parents:
- continue
-
- # Remove the corresponding "nomerge" node and substitute
- # the Uninstall node.
- inst_pkg = self._pkg(uninstall.cpv, "installed",
- uninstall.root_config, installed=True)
-
- try:
- mygraph.remove(inst_pkg)
- except KeyError:
- pass
-
- try:
- inst_pkg_blockers = self._dynamic_config._blocker_parents.child_nodes(inst_pkg)
- except KeyError:
- inst_pkg_blockers = []
-
- # Break the Package -> Uninstall edges.
- mygraph.remove(uninstall)
-
- # Resolution of a package's blockers
- # depend on it's own uninstallation.
- for blocker in inst_pkg_blockers:
- mygraph.add(uninstall, blocker)
-
- # Expand Package -> Uninstall edges into
- # Package -> Blocker -> Uninstall edges.
- for blocker in uninstall_parents:
- mygraph.add(uninstall, blocker)
- for parent in self._dynamic_config._blocker_parents.parent_nodes(blocker):
- if parent != inst_pkg:
- mygraph.add(blocker, parent)
-
- # If the uninstall task did not need to be executed because
- # of an upgrade, display Blocker -> Upgrade edges since the
- # corresponding Blocker -> Uninstall edges will not be shown.
- upgrade_node = \
- self._dynamic_config._slot_pkg_map[uninstall.root].get(uninstall.slot_atom)
- if upgrade_node is not None and \
- uninstall not in executed_uninstalls:
- for blocker in uninstall_parents:
- mygraph.add(upgrade_node, blocker)
-
- if "--unordered-display" in self._frozen_config.myopts:
- display_list = self._unordered_tree_display(mygraph, mylist)
- else:
- display_list = self._ordered_tree_display(mygraph, mylist)
-
- self._prune_tree_display(display_list)
-
- return display_list
-
- def _unordered_tree_display(self, mygraph, mylist):
- display_list = []
- seen_nodes = set()
-
- def print_node(node, depth):
-
- if node in seen_nodes:
- pass
- else:
- seen_nodes.add(node)
-
- if isinstance(node, (Blocker, Package)):
- display_list.append((node, depth, True))
- else:
- depth = -1
-
- for child_node in mygraph.child_nodes(node):
- print_node(child_node, depth + 1)
-
- for root_node in mygraph.root_nodes():
- print_node(root_node, 0)
-
- return display_list
-
- def _ordered_tree_display(self, mygraph, mylist):
- depth = 0
- shown_edges = set()
- tree_nodes = []
- display_list = []
-
- for x in mylist:
- depth = len(tree_nodes)
- while depth and x not in \
- mygraph.child_nodes(tree_nodes[depth-1]):
- depth -= 1
- if depth:
- tree_nodes = tree_nodes[:depth]
- tree_nodes.append(x)
- display_list.append((x, depth, True))
- shown_edges.add((x, tree_nodes[depth-1]))
- else:
- traversed_nodes = set() # prevent endless circles
- traversed_nodes.add(x)
- def add_parents(current_node, ordered):
- parent_nodes = None
- # Do not traverse to parents if this node is an
- # an argument or a direct member of a set that has
- # been specified as an argument (system or world).
- if current_node not in self._dynamic_config._set_nodes:
- parent_nodes = mygraph.parent_nodes(current_node)
- if parent_nodes:
- child_nodes = set(mygraph.child_nodes(current_node))
- selected_parent = None
- # First, try to avoid a direct cycle.
- for node in parent_nodes:
- if not isinstance(node, (Blocker, Package)):
- continue
- if node not in traversed_nodes and \
- node not in child_nodes:
- edge = (current_node, node)
- if edge in shown_edges:
- continue
- selected_parent = node
- break
- if not selected_parent:
- # A direct cycle is unavoidable.
- for node in parent_nodes:
- if not isinstance(node, (Blocker, Package)):
- continue
- if node not in traversed_nodes:
- edge = (current_node, node)
- if edge in shown_edges:
- continue
- selected_parent = node
- break
- if selected_parent:
- shown_edges.add((current_node, selected_parent))
- traversed_nodes.add(selected_parent)
- add_parents(selected_parent, False)
- display_list.append((current_node,
- len(tree_nodes), ordered))
- tree_nodes.append(current_node)
- tree_nodes = []
- add_parents(x, True)
-
- return display_list
-
- def _prune_tree_display(self, display_list):
- last_merge_depth = 0
- for i in range(len(display_list) - 1, -1, -1):
- node, depth, ordered = display_list[i]
- if not ordered and depth == 0 and i > 0 \
- and node == display_list[i-1][0] and \
- display_list[i-1][1] == 0:
- # An ordered node got a consecutive duplicate
- # when the tree was being filled in.
- del display_list[i]
- continue
- if ordered and isinstance(node, Package) \
- and node.operation in ('merge', 'uninstall'):
- last_merge_depth = depth
- continue
- if depth >= last_merge_depth or \
- i < len(display_list) - 1 and \
- depth >= display_list[i+1][1]:
- del display_list[i]
+ return display(self, mylist, favorites, verbosity)
def display_problems(self):
"""
writemsg_stdout("For more information, see the MASKED PACKAGES section in the emerge\n", noiselevel=-1)
writemsg_stdout("man page or refer to the Gentoo Handbook.\n", noiselevel=-1)
-def filter_iuse_defaults(iuse):
- for flag in iuse:
- if flag.startswith("+") or flag.startswith("-"):
- yield flag[1:]
- else:
- yield flag
-
def show_blocker_docs_link():
writemsg("\nFor more information about " + bad("Blocked Packages") + ", please refer to the following\n", noiselevel=-1)
writemsg("section of the Gentoo Linux x86 Handbook (architecture is irrelevant):\n\n", noiselevel=-1)
projects / portage.git / blobdiff