Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
for flag in violated_atom.use.enabled:
if flag in avail_pkg.use.mask:
all_use_unmasked = False
break
else:
for flag in violated_atom.use.disabled:
if flag in avail_pkg.use.force and \
flag not in avail_pkg.use.mask:
all_use_unmasked = False
break
else:
# highest (ascending order)
avail_pkg_use = avail_pkg_use[-1]
if avail_pkg_use != avail_pkg:
avail_pkg = avail_pkg_use
avail_slot = Atom("%s:%s" % (atom.cp, avail_pkg.slot))
if downgrade_probe is not None and graph is not None:
highest_in_slot = mydbapi_match_pkgs(avail_slot)
highest_in_slot = (highest_in_slot[-1]
if highest_in_slot else None)
if (avail_pkg and highest_in_slot and
avail_pkg < highest_in_slot and
not downgrade_probe(avail_pkg) and
(highest_in_slot.installed or
highest_in_slot in graph)):
installed_downgrade = True
slot_map[avail_slot] = avail_pkg
slot_atoms[avail_slot].append(atom)
highest_cpv = cp_map.get(avail_pkg.cp)
all_match_current = None
protected_set.update(vardb.cp_all())
if not args_set:
# Try to prune everything that's slotted.
for cp in vardb.cp_all():
if len(vardb.cp_list(cp)) > 1:
args_set.add(cp)
# Remove atoms from world that match installed packages
# that are also matched by argument atoms, but do not remove
# them if they match the highest installed version.
for pkg in vardb:
if spinner is not None:
spinner.update()
pkgs_for_cp = vardb.match_pkgs(Atom(pkg.cp))
if not pkgs_for_cp or pkg not in pkgs_for_cp:
raise AssertionError("package expected in matches: " + \
"cp = %s, cpv = %s matches = %s" % \
(pkg.cp, pkg.cpv, [str(x) for x in pkgs_for_cp]))
highest_version = pkgs_for_cp[-1]
if pkg == highest_version:
# pkg is the highest version
protected_set.add("=" + pkg.cpv)
continue
if len(pkgs_for_cp) <= 1:
raise AssertionError("more packages expected: " + \
"cp = %s, cpv = %s matches = %s" % \
(pkg.cp, pkg.cpv, [str(x) for x in pkgs_for_cp]))
if atom_graph is not None:
atom_graph.add((x, id(x)), graph_parent)
continue
if repoman or not hasattr(portdb, 'match_pkgs') or \
pkg_use_enabled is None:
if portdb.cp_list(x.cp):
newsplit.append(x)
else:
a = []
myvartree = mytrees.get("vartree")
if myvartree is not None:
mysettings._populate_treeVirtuals_if_needed(myvartree)
mychoices = mysettings.getvirtuals().get(mykey, [])
for y in mychoices:
a.append(Atom(x.replace(x.cp, y.cp, 1)))
if not a:
newsplit.append(x)
elif is_disjunction:
newsplit.extend(a)
elif len(a) == 1:
newsplit.append(a[0])
else:
newsplit.append(['||'] + a)
continue
pkgs = []
# Ignore USE deps here, since otherwise we might not
# get any matches. Choices with correct USE settings
# will be preferred in dep_zapdeps().
matches = portdb.match_pkgs(x.without_use)
# Use descending order to prefer higher versions.
elif x.startswith(os.sep):
if not x.startswith(eroot):
writemsg_level(("!!! '%s' does not start with" + \
" $EROOT.\n") % x, level=logging.ERROR, noiselevel=-1)
return 1
# Queue these up since it's most efficient to handle
# multiple files in a single iter_owners() call.
lookup_owners.append(x)
elif x.startswith(SETPREFIX) and action == "deselect":
valid_atoms.append(x)
elif "*" in x:
try:
ext_atom = Atom(x, allow_repo=True, allow_wildcard=True)
except InvalidAtom:
msg = []
msg.append("'%s' is not a valid package atom." % (x,))
msg.append("Please check ebuild(5) for full details.")
writemsg_level("".join("!!! %s\n" % line for line in msg),
level=logging.ERROR, noiselevel=-1)
return 1
for cpv in vardb.cpv_all():
if portage.match_from_list(ext_atom, [cpv]):
require_metadata = False
atom = portage.cpv_getkey(cpv)
if ext_atom.operator == '=*':
atom = "=" + atom + "-" + \
portage.versions.cpv_getversion(cpv)
if ext_atom.slot:
if pkg_info.ordered:
self.counters.restrict_fetch += 1
pkg_info.attr_display.fetch_restrict = True
if not self.portdb.getfetchsizes(pkg.cpv,
useflags=pkg_info.use, myrepo=pkg.repo):
pkg_info.attr_display.fetch_restrict_satisfied = True
if pkg_info.ordered:
self.counters.restrict_fetch_satisfied += 1
else:
if pkg_info.ebuild_path is not None:
self.restrict_fetch_list[pkg] = pkg_info
if self.vardb.cpv_exists(pkg.cpv):
# Do a cpv match first, in case the SLOT has changed.
pkg_info.previous_pkg = self.vardb.match_pkgs(
Atom('=' + pkg.cpv))[0]
else:
cp_slot_matches = self.vardb.match_pkgs(pkg.slot_atom)
if cp_slot_matches:
pkg_info.previous_pkg = cp_slot_matches[0]
else:
cp_matches = self.vardb.match_pkgs(Atom(pkg.cp))
if cp_matches:
# Use highest installed other-slot package instance.
pkg_info.previous_pkg = cp_matches[-1]
return pkg_info
self.impact_text = getText(myroot.getElementsByTagName("impact")[0], format="xml")
self.impact_type = myroot.getElementsByTagName("impact")[0].getAttribute("type")
try:
self.background = getText(myroot.getElementsByTagName("background")[0], format="xml")
except IndexError:
self.background = ""
# finally the interesting tags (product, affected, package)
self.glsatype = myroot.getElementsByTagName("product")[0].getAttribute("type")
self.product = getText(myroot.getElementsByTagName("product")[0], format="strip")
self.affected = myroot.getElementsByTagName("affected")[0]
self.packages = {}
for p in self.affected.getElementsByTagName("package"):
name = p.getAttribute("name")
try:
name = portage.dep.Atom(name)
except portage.exception.InvalidAtom:
raise GlsaFormatException(_("invalid package name: %s") % name)
if name != name.cp:
raise GlsaFormatException(_("invalid package name: %s") % name)
name = name.cp
if name not in self.packages:
self.packages[name] = []
tmp = {}
tmp["arch"] = p.getAttribute("arch")
tmp["auto"] = (p.getAttribute("auto") == "yes")
tmp["vul_vers"] = [makeVersion(v) for v in p.getElementsByTagName("vulnerable")]
tmp["unaff_vers"] = [makeVersion(v) for v in p.getElementsByTagName("unaffected")]
tmp["vul_atoms"] = [makeAtom(name, v) for v in p.getElementsByTagName("vulnerable")]
tmp["unaff_atoms"] = [makeAtom(name, v) for v in p.getElementsByTagName("unaffected")]
self.packages[name].append(tmp)
# TODO: services aren't really used yet
else:
if virt_atom.blocker or \
str(virt_atom) != str(virt_atom.cp):
virt_atom = None
if virt_atom is None:
writemsg(_("--- Invalid virtuals atom in %s: %s\n") % \
(virtuals_file, k), noiselevel=-1)
continue
providers = []
for atom in v:
atom_orig = atom
if atom[:1] == '-':
# allow incrementals
atom = atom[1:]
try:
atom = Atom(atom)
except InvalidAtom:
atom = None
else:
if atom.blocker:
atom = None
if atom is None:
writemsg(_("--- Invalid atom in %s: %s\n") % \
(virtuals_file, atom_orig), noiselevel=-1)
else:
if atom_orig == str(atom):
# normal atom, so return as Atom instance
providers.append(atom)
else:
# atom has special prefix, so return as string
providers.append(atom_orig)
if providers:
myopts = {}
myopts["--selective"] = True
myopts["--deep"] = True
myparams = _emerge.create_depgraph_params.create_depgraph_params(
myopts, "remove")
depgraph = _emerge.depgraph.depgraph(self.pvar.settings,
self.pvar.trees, myopts, myparams, None)
# TODO: atm, using FILTER_INSTALLED because it's quicker
# and we don't want to manage non-installed packages
for cp in self.get_all_cp([FILTER_INSTALLED]):
for cpv in self.get_all_cpv(cp, [FILTER_INSTALLED]):
depgraph._dynamic_config._dep_stack.append(
_emerge.Dependency.Dependency(
atom=portage.dep.Atom('=' + cpv),
root=self.pvar.settings["ROOT"], parent=None))
if not depgraph._complete_graph():
self.error(ERROR_INTERNAL_ERROR, "Error when generating depgraph")
return
def _add_children_to_list(packages_list, node):
for n in depgraph._dynamic_config.digraph.parent_nodes(node):
if n not in packages_list \
and not isinstance(n, _emerge.SetArg.SetArg):
packages_list.append(n)
_add_children_to_list(packages_list, n)
for node in depgraph._dynamic_config.digraph.__iter__():
if isinstance(node, _emerge.SetArg.SetArg):
continue
if (not slot_atom.cp.startswith("virtual/")
and not graph_db.match_pkgs(slot_atom)):
new_slot_count += 1
this_choice = _dep_choice(atoms=atoms, slot_map=slot_map,
cp_map=cp_map, all_available=all_available,
all_installed_slots=False,
new_slot_count=new_slot_count,
all_in_graph=False,
want_update=want_update)
if all_available:
# The "all installed" criterion is not version or slot specific.
# If any version of a package is already in the graph then we
# assume that it is preferred over other possible packages choices.
all_installed = True
for atom in set(Atom(atom.cp) for atom in atoms \
if not atom.blocker):
# New-style virtuals have zero cost to install.
if not vardb.match(atom) and not atom.startswith("virtual/"):
all_installed = False
break
all_installed_slots = False
if all_installed:
all_installed_slots = True
for slot_atom in slot_map:
# New-style virtuals have zero cost to install.
if not vardb.match(slot_atom) and \
not slot_atom.startswith("virtual/"):
all_installed_slots = False
break
this_choice.all_installed_slots = all_installed_slots
if graph_db is None:
def update(self, atoms):
self._load()
modified = False
normal_atoms = []
for a in atoms:
if not isinstance(a, Atom):
try:
a = Atom(a, allow_wildcard=True, allow_repo=True)
except InvalidAtom:
modified = True
self._nonatoms.add(a)
continue
if not self._allow_wildcard and a.extended_syntax:
raise InvalidAtom("extended atom syntax not allowed here")
if not self._allow_repo and a.repo:
raise InvalidAtom("repository specification not allowed here")
normal_atoms.append(a)
if normal_atoms:
modified = True
self._atoms.update(normal_atoms)
self._updateAtomMap(atoms=normal_atoms)
if modified:
self.write()