def _viable(self, stack, mode, atom, dbs, drop_cycles, limit_to_vdb):
"""
internal function to discern if an atom is viable, returning
the choicepoint/matches iterator if viable.
:param stack: current stack
:type stack: :obj:`resolver_stack`
:param mode: type of dependency (depends/rdepends)
:type mode: str
:param atom: atom for the current package
:type atom: :obj:`pkgcore.ebuild.atom.atom`
:param dbs: db list to walk
:param drop_cycles: boolean controlling whether to drop dep cycles
:param limit_to_vdb: boolean controlling considering pkgs only from the vdb
:return: 3 possible; None (not viable), True (presolved),
:obj:`caching_iter` (not solved, but viable), :obj:`choice_point`
"""
choices = ret = None
if atom in self.insoluble:
ret = ((False, "globally insoluble"),{})
matches = ()
else:
matches = self.state.match_atom(atom)
if matches:
ret = ((True,), {"pre_solved":True})
else:
# not in the plan thus far.
matches = caching_iter(dbs.itermatch(atom))
if matches:
choices = choice_point(atom, matches)
# ignore what dropped out, at this juncture we don't care.
choices.reduce_atoms(self.insoluble)
if not choices:
# and was intractable because it has a hard dep on an
# unsolvable atom.
ret = ((False, "pruning of insoluble deps "
"left no choices"), {})
else:
ret = ((False, "no matches"), {})
if choices is None:
choices = choice_point(atom, matches)
stack.add_frame(mode, atom, choices, dbs,
self.state.current_state, drop_cycles, vdb_limited=limit_to_vdb)
if not limit_to_vdb and not matches:
self.insoluble.add(atom)
if ret is not None:
self.notify_viable(stack, atom, *ret[0], **ret[1])
if ret[0][0] == True:
state.add_backref_op(choices, choices.current_pkg).apply(self.state)
return True
return None
return choices, matches
def _viable(self, stack, mode, atom, dbs, drop_cycles, limit_to_vdb):
"""
internal function to discern if an atom is viable, returning
the choicepoint/matches iter if viable.
:return: 3 possible; None (not viable), True (presolved),
:obj:`caching_iter` (not solved, but viable), :obj:`choice_point`
"""
choices = ret = None
if atom in self.insoluble:
ret = ((False, "globally insoluble"),{})
matches = ()
else:
matches = self.state.match_atom(atom)
if matches:
ret = ((True,), {"pre_solved":True})
else:
# not in the plan thus far.
matches = caching_iter(dbs.itermatch(atom))
if matches:
choices = choice_point(atom, matches)
# ignore what dropped out, at this juncture we don't care.
choices.reduce_atoms(self.insoluble)
if not choices:
# and was intractable because it has a hard dep on an
# unsolvable atom.
ret = ((False, "pruning of insoluble deps "
"left no choices"), {})
else:
ret = ((False, "no matches"), {})
if choices is None:
choices = choice_point(atom, matches)
stack.add_frame(mode, atom, choices, dbs,
self.state.current_state, drop_cycles, vdb_limited=limit_to_vdb)
if not limit_to_vdb and not matches:
self.insoluble.add(atom)
if ret is not None:
self.notify_viable(stack, atom, *ret[0], **ret[1])
if ret[0][0] == True:
state.add_backref_op(choices, choices.current_pkg).apply(self.state)
return True
return None
return choices, matches
def _ensure_livefs_is_loaded_nonpreloaded(self, restrict):
# do a trick to make the resolver now aware of vdb pkgs if needed
# check for any matches; none, try and insert vdb nodes.
l = self.state.match_atom(restrict)
if not l:
# hmm. ok... no conflicts, so we insert in vdb matches
# to trigger a replace instead of an install
for pkg in self.livefs_dbs.itermatch(restrict):
self._dprint("inserting vdb node for %s %s", (restrict, pkg))
c = choice_point(restrict, [pkg])
state.add_op(c, c.current_pkg, force=True).apply(self.state)
def _ensure_livefs_is_loaded_nonpreloaded(self, restrict):
# do a trick to make the resolver now aware of vdb pkgs if needed
# check for any matches; none, try and insert vdb nodes.
l = self.state.match_atom(restrict)
if not l:
# hmm. ok... no conflicts, so we insert in vdb matches
# to trigger a replace instead of an install
for pkg in self.livefs_dbs.itermatch(restrict):
self._dprint("inserting vdb node for %s %s", (restrict, pkg))
c = choice_point(restrict, [pkg])
state.add_op(c, c.current_pkg, force=True).apply(self.state)
def gen_choice_point():
return choice_point("asdf", [
fake_package(marker=1, depends=OrRestriction(
"ordep1", "ordep2", "dependsordep"),
rdepends=AndRestriction(
OrRestriction("ordep1", "andordep2"),
"anddep1", "anddep2", "pkg1and"),
post_rdepends=OrRestriction("prdep1", "or3")),
fake_package(marker=2, depends=AndRestriction(
"anddep1", "anddep2"),
rdepends=OrRestriction("or1", "or2"),
post_rdepends=OrRestriction("prdep1", "or3"))])
def gen_choice_point():
return choice_point("asdf", [
fake_package(marker=1, depends=OrRestriction(
"ordep1", "ordep2", "dependsordep"),
rdepends=AndRestriction(
OrRestriction("ordep1", "andordep2"),
"anddep1", "anddep2", "pkg1and"),
post_rdepends=OrRestriction("prdep1", "or3")),
fake_package(marker=2, depends=AndRestriction(
"anddep1", "anddep2"),
rdepends=OrRestriction("or1", "or2"),
post_rdepends=OrRestriction("prdep1", "or3"))])
def _viable(self, stack, mode, atom, dbs, drop_cycles, limit_to_vdb):
"""
internal function to discern if an atom is viable, returning
the choicepoint/matches iterator if viable.
:param stack: current stack
:type stack: :obj:`resolver_stack`
:param mode: type of dependency (depends/rdepends)
:type mode: str
:param atom: atom for the current package
:type atom: :obj:`pkgcore.ebuild.atom.atom`
:param dbs: db list to walk
:param drop_cycles: boolean controlling whether to drop dep cycles
:param limit_to_vdb: boolean controlling considering pkgs only from the vdb
:return: 3 possible; None (not viable), True (presolved),
:obj:`caching_iter` (not solved, but viable), :obj:`choice_point`
"""
choices = ret = None
if atom in self.insoluble:
ret = ((False, "globally insoluble"), {})
matches = ()
else:
matches = self.state.match_atom(atom)
if matches:
ret = ((True, ), {"pre_solved": True})
else:
# not in the plan thus far.
matches = caching_iter(dbs.itermatch(atom))
if matches:
choices = choice_point(atom, matches)
# ignore what dropped out, at this juncture we don't care.
choices.reduce_atoms(self.insoluble)
if not choices:
# and was intractable because it has a hard dep on an
# unsolvable atom.
ret = ((False, "pruning of insoluble deps "
"left no choices"), {})
else:
ret = ((False, "no matches"), {})
if choices is None:
choices = choice_point(atom, matches)
stack.add_frame(mode,
atom,
choices,
dbs,
self.state.current_state,
drop_cycles,
vdb_limited=limit_to_vdb)
if not limit_to_vdb and not matches:
self.insoluble.add(atom)
if ret is not None:
self.notify_viable(stack, atom, *ret[0], **ret[1])
if ret[0][0] == True:
state.add_backref_op(choices,
choices.current_pkg).apply(self.state)
return True
return None
return choices, matches
