def __iter__(self):
for glsa, matches in find_vulnerable_repo_pkgs(self.glsa_src,
self.vdb,
grouped=True,
arch=self.arch):
yield packages.KeyedAndRestriction(glsa[0],
restriction.Negate(glsa[1]))
def insert_blockers(self, stack, choices, blocks):
# level blockers.
was_livefs = choices.current_pkg.repo.livefs
for x in blocks:
if not was_livefs:
self._ensure_livefs_is_loaded(x)
rewrote_blocker = self.generate_mangled_blocker(choices, x)
l = self.state.add_blocker(choices, rewrote_blocker, key=x.key)
if l:
# blocker caught something. yay.
self._dprint("%s blocker %s hit %s for atom %s pkg %s",
(stack[-1].mode, x, l, stack[-1].atom,
choices.current_pkg))
if x.weak_blocker:
# note that we use the top frame of the stacks' dbs; this
# is to allow us to upgrade as needed.
# For this to match, it's *only* possible if the blocker is resolved
# since the limiter is already in place.
result = self._rec_add_atom(
packages.KeyedAndRestriction(restriction.Negate(x),
_atom.atom(x.key),
key=x.key), stack,
stack[0].dbs)
if not result:
# ok, inserted a new version. did it take care of the conflict?
# it /may/ not have, via filling a different slot...
result = self.state.match_atom(x)
if not result:
# ignore the blocker, we resolved past it.
continue
return x, l
return None
def iter_dnf_solutions(self, full_solution_expansion=False):
"""
generater yielding DNF (disjunctive normalized form) of this instance.
:param full_solution_expansion: controls whether to expand everything
(break apart atoms for example); this isn't likely what you want
"""
if self.negate:
# raise NotImplementedError("negation for dnf_solutions on "
# "AndRestriction isn't implemented yet")
# hack- this is an experiment
for r in OrRestriction(
node_type=self.type,
*[restriction.Negate(x)
for x in self.restrictions]).iter_dnf_solutions():
yield r
return
if not self.restrictions:
yield []
return
hardreqs = []
optionals = []
for x in self.restrictions:
method = getattr(x, 'dnf_solutions', None)
if method is None:
hardreqs.append(x)
else:
s2 = method(full_solution_expansion)
assert s2
if len(s2) == 1:
hardreqs.extend(s2[0])
else:
optionals.append(s2)
def f(arg, *others):
if others:
for node in arg:
for node2 in f(*others):
yield node + node2
else:
for node in arg:
yield node
for solution in f([hardreqs], *optionals):
assert isinstance(solution, (tuple, list))
yield solution
def iter_dnf_solutions(self, full_solution_expansion=False):
"""returns a list in DNF (disjunctive normalized form) for of this instance
:param full_solution_expansion: controls whether to expand everything
(break apart atoms for example); this isn't likely what you want
"""
if self.negate:
# hack- this is an experiment
for x in AndRestriction(
node_type=self.type,
*[restriction.Negate(x)
for x in self.restrictions]).iter_dnf_solutions():
yield x
if not self.restrictions:
yield []
return
for x in self.restrictions:
method = getattr(x, 'iter_dnf_solutions', None)
if method is None:
yield [x]
else:
for y in method(full_solution_expansion):
yield y