def fix_conflict(config, depgraph): depgraph._slot_conflict_handler = slot_conflict_handler(depgraph) handler = depgraph._slot_conflict_handler for root, slot_atom, pkgs in handler.all_conflicts: print("%s" % (slot_atom,)) for p in pkgs: parents = handler.all_parents.get(p) if not parents: continue collisions = {} for ppkg, atom in parents: if atom.soname: continue for other_pkg in pkgs: atom_without_use_set = \ InternalPackageSet(initial_atoms=(atom.without_use,)) if atom_without_use_set.findAtomForPackage(other_pkg, modified_use=depgraph._pkg_use_enabled(other_pkg)): continue key = (atom.slot, atom.sub_slot, atom.slot_operator) atoms = collisions.get(key, set()) atoms.add((ppkg, atom, other_pkg)) collisions[key] = atoms print("collisions: %s" % collisions) print("") return (config, False)
def _check_solution(self, config, all_involved_flags, all_conflict_atoms_by_slotatom): """ Given a configuartion and all involved flags, all possible settings for the involved flags are checked if they solve the slot conflict. """ _pkg_use_enabled = self.depgraph._pkg_use_enabled if self.debug: #The code is a bit verbose, because the states might not #be a string, but a _value_helper. msg = "Solution candidate: " msg += "[" first = True for involved_flags in all_involved_flags: if first: first = False else: msg += ", " msg += "{" inner_first = True for flag, state in involved_flags.items(): if inner_first: inner_first = False else: msg += ", " msg += flag + ": %s" % (state,) msg += "}" msg += "]\n" writemsg(msg, noiselevel=-1) required_changes = {} for id, pkg in enumerate(config): if not pkg.installed: #We can't change the USE of installed packages. for flag in all_involved_flags[id]: if not pkg.iuse.is_valid_flag(flag): continue state = all_involved_flags[id][flag] self._force_flag_for_package(required_changes, pkg, flag, state) #Go through all (parent, atom) pairs for the current slot conflict. for ppkg, atom in all_conflict_atoms_by_slotatom[id]: use = atom.unevaluated_atom.use if not use: #No need to force something for an atom without USE conditionals. #These atoms are already satisfied. continue for flag in all_involved_flags[id]: state = all_involved_flags[id][flag] if flag not in use.required or not use.conditional: continue if flag in use.conditional.enabled: #[flag?] if state == "enabled": #no need to change anything, the atom won't #force -flag on pkg pass elif state == "disabled": #if flag is enabled we get [flag] -> it must be disabled self._force_flag_for_package(required_changes, ppkg, flag, "disabled") elif flag in use.conditional.disabled: #[!flag?] if state == "enabled": #if flag is enabled we get [-flag] -> it must be disabled self._force_flag_for_package(required_changes, ppkg, flag, "disabled") elif state == "disabled": #no need to change anything, the atom won't #force +flag on pkg pass elif flag in use.conditional.equal: #[flag=] if state == "enabled": #if flag is disabled we get [-flag] -> it must be enabled self._force_flag_for_package(required_changes, ppkg, flag, "enabled") elif state == "disabled": #if flag is enabled we get [flag] -> it must be disabled self._force_flag_for_package(required_changes, ppkg, flag, "disabled") elif flag in use.conditional.not_equal: #[!flag=] if state == "enabled": #if flag is enabled we get [-flag] -> it must be disabled self._force_flag_for_package(required_changes, ppkg, flag, "disabled") elif state == "disabled": #if flag is disabled we get [flag] -> it must be enabled self._force_flag_for_package(required_changes, ppkg, flag, "enabled") is_valid_solution = True for pkg in required_changes: for state in required_changes[pkg].values(): if not state in ("enabled", "disabled"): is_valid_solution = False if not is_valid_solution: return None #Check if all atoms are satisfied after the changes are applied. for id, pkg in enumerate(config): new_use = _pkg_use_enabled(pkg) if pkg in required_changes: old_use = pkg.use.enabled new_use = set(new_use) for flag, state in required_changes[pkg].items(): if state == "enabled": new_use.add(flag) elif state == "disabled": new_use.discard(flag) if not new_use.symmetric_difference(old_use): #avoid copying the package in findAtomForPackage if possible new_use = old_use for ppkg, atom in all_conflict_atoms_by_slotatom[id]: if not hasattr(ppkg, "use"): #It's a SetArg or something like that. continue ppkg_new_use = set(_pkg_use_enabled(ppkg)) if ppkg in required_changes: for flag, state in required_changes[ppkg].items(): if state == "enabled": ppkg_new_use.add(flag) elif state == "disabled": ppkg_new_use.discard(flag) new_atom = atom.unevaluated_atom.evaluate_conditionals(ppkg_new_use) i = InternalPackageSet(initial_atoms=(new_atom,)) if not i.findAtomForPackage(pkg, new_use): #We managed to create a new problem with our changes. is_valid_solution = False if self.debug: writemsg(("new conflict introduced: %s" " does not match %s from %s\n") % (pkg, new_atom, ppkg), noiselevel=-1) break if not is_valid_solution: break #Make sure the changes don't violate REQUIRED_USE for pkg in required_changes: required_use = pkg._metadata.get("REQUIRED_USE") if not required_use: continue use = set(_pkg_use_enabled(pkg)) for flag, state in required_changes[pkg].items(): if state == "enabled": use.add(flag) else: use.discard(flag) if not check_required_use(required_use, use, pkg.iuse.is_valid_flag): is_valid_solution = False break if is_valid_solution and required_changes: return required_changes else: return None
def _check_configuration(self, config, all_conflict_atoms_by_slotatom, conflict_nodes): """ Given a configuartion, required use changes are computed and checked to make sure that no new conflict is introduced. Returns a solution or None. """ _pkg_use_enabled = self.depgraph._pkg_use_enabled #An installed package can only be part of a valid configuration if it has no #pending use changed. Otherwise the ebuild will be pulled in again. for pkg in config: if not pkg.installed: continue for (atom, root), pkgs \ in self.slot_collision_info.items(): if pkg not in pkgs: continue for other_pkg in pkgs: if other_pkg == pkg: continue if pkg.iuse.all.symmetric_difference(other_pkg.iuse.all) \ or _pkg_use_enabled(pkg).symmetric_difference(_pkg_use_enabled(other_pkg)): if self.debug: writemsg(("%s has pending USE changes. " "Rejecting configuration.\n") % (pkg,), noiselevel=-1) return False #A list of dicts. Keeps one dict per slot conflict. [ { flag1: "enabled" }, { flag2: "disabled" } ] all_involved_flags = [] #Go through all slot conflicts for id, pkg in enumerate(config): involved_flags = {} for ppkg, atom in all_conflict_atoms_by_slotatom[id]: if ppkg in conflict_nodes and not ppkg in config: #The parent is part of a slot conflict itself and is #not part of the current config. continue i = InternalPackageSet(initial_atoms=(atom,)) if i.findAtomForPackage(pkg, modified_use=_pkg_use_enabled(pkg)): continue i = InternalPackageSet(initial_atoms=(atom.without_use,)) if not i.findAtomForPackage(pkg, modified_use=_pkg_use_enabled(pkg)): #Version range does not match. if self.debug: writemsg(("%s does not satify all version " "requirements. Rejecting configuration.\n") % (pkg,), noiselevel=-1) return False if not pkg.iuse.is_valid_flag(atom.unevaluated_atom.use.required): #Missing IUSE. #FIXME: This needs to support use dep defaults. if self.debug: writemsg(("%s misses needed flags from IUSE." " Rejecting configuration.\n") % (pkg,), noiselevel=-1) return False if not isinstance(ppkg, Package) or ppkg.installed: #We cannot assume that it's possible to reinstall the package. Do not #check if some of its atom has use.conditional violated_atom = atom.violated_conditionals(_pkg_use_enabled(pkg), \ pkg.iuse.is_valid_flag) else: violated_atom = atom.unevaluated_atom.violated_conditionals(_pkg_use_enabled(pkg), \ pkg.iuse.is_valid_flag, parent_use=_pkg_use_enabled(ppkg)) if violated_atom.use is None: # It's possible for autounmask to change # parent_use such that the unevaluated form # of the atom now matches, even though the # earlier evaluated form (from before # autounmask changed parent_use) does not. # In this case (see bug #374423), it's # expected that violated_atom.use is None. continue if pkg.installed and (violated_atom.use.enabled or violated_atom.use.disabled): #We can't change USE of an installed package (only of an ebuild, but that is already #part of the conflict, isn't it? if self.debug: writemsg(("%s: installed package would need USE" " changes. Rejecting configuration.\n") % (pkg,), noiselevel=-1) return False #Compute the required USE changes. A flag can be forced to "enabled" or "disabled", #it can be in the conditional state "cond" that allows both values or in the #"contradiction" state, which means that some atoms insist on differnt values #for this flag and those kill this configuration. for flag in violated_atom.use.required: state = involved_flags.get(flag, "") if flag in violated_atom.use.enabled: if state in ("", "cond", "enabled"): state = "enabled" else: state = "contradiction" elif flag in violated_atom.use.disabled: if state in ("", "cond", "disabled"): state = "disabled" else: state = "contradiction" else: if state == "": state = "cond" involved_flags[flag] = state if pkg.installed: #We don't change the installed pkg's USE. Force all involved flags #to the same value as the installed package has it. for flag in involved_flags: if involved_flags[flag] == "enabled": if not flag in _pkg_use_enabled(pkg): involved_flags[flag] = "contradiction" elif involved_flags[flag] == "disabled": if flag in _pkg_use_enabled(pkg): involved_flags[flag] = "contradiction" elif involved_flags[flag] == "cond": if flag in _pkg_use_enabled(pkg): involved_flags[flag] = "enabled" else: involved_flags[flag] = "disabled" for flag, state in involved_flags.items(): if state == "contradiction": if self.debug: writemsg("Contradicting requirements found for flag " + \ flag + ". Rejecting configuration.\n", noiselevel=-1) return False all_involved_flags.append(involved_flags) if self.debug: writemsg("All involved flags:\n", noiselevel=-1) for id, involved_flags in enumerate(all_involved_flags): writemsg(" %s\n" % (config[id],), noiselevel=-1) for flag, state in involved_flags.items(): writemsg(" " + flag + ": " + state + "\n", noiselevel=-1) solutions = [] sol_gen = _solution_candidate_generator(all_involved_flags) checked = 0 while True: candidate = sol_gen.get_candidate() if not candidate: break solution = self._check_solution(config, candidate, all_conflict_atoms_by_slotatom) checked += 1 if solution: solutions.append(solution) if checked >= self._check_configuration_max: # TODO: Implement early elimination for candidates that would # change forced or masked flags, and don't count them here. if self.debug: writemsg("\nAborting _check_configuration due to " "excessive number of candidates.\n", noiselevel=-1) break if self.debug: if not solutions: writemsg("No viable solutions. Rejecting configuration.\n", noiselevel=-1) return solutions
def _prepare_conflict_msg_and_check_for_specificity(self): """ Print all slot conflicts in a human readable way. """ _pkg_use_enabled = self.depgraph._pkg_use_enabled verboseconflicts = "--verbose-conflicts" in self.myopts msg = self.conflict_msg indent = " " msg.append("\n!!! Multiple package instances within a single " + \ "package slot have been pulled\n") msg.append("!!! into the dependency graph, resulting" + \ " in a slot conflict:\n\n") for (slot_atom, root), pkgs \ in self.slot_collision_info.items(): msg.append("%s" % (slot_atom,)) if root != self.depgraph._frozen_config._running_root.root: msg.append(" for %s" % (root,)) msg.append("\n\n") for pkg in pkgs: msg.append(indent) msg.append("%s" % (pkg,)) parent_atoms = self.all_parents.get(pkg) if parent_atoms: #Create a list of collision reasons and map them to sets #of atoms. #Possible reasons: # ("version", "ge") for operator >=, > # ("version", "eq") for operator =, ~ # ("version", "le") for operator <=, < # ("use", "<some use flag>") for unmet use conditionals collision_reasons = {} num_all_specific_atoms = 0 for ppkg, atom in parent_atoms: atom_set = InternalPackageSet(initial_atoms=(atom,)) atom_without_use_set = InternalPackageSet(initial_atoms=(atom.without_use,)) for other_pkg in pkgs: if other_pkg == pkg: continue if not atom_without_use_set.findAtomForPackage(other_pkg, \ modified_use=_pkg_use_enabled(other_pkg)): if atom.operator is not None: # The version range does not match. sub_type = None if atom.operator in (">=", ">"): sub_type = "ge" elif atom.operator in ("=", "~"): sub_type = "eq" elif atom.operator in ("<=", "<"): sub_type = "le" key = ("version", sub_type) atoms = collision_reasons.get(key, set()) atoms.add((ppkg, atom, other_pkg)) num_all_specific_atoms += 1 collision_reasons[key] = atoms else: # The sub_slot does not match. key = ("sub-slot", atom.sub_slot) atoms = collision_reasons.get(key, set()) atoms.add((ppkg, atom, other_pkg)) num_all_specific_atoms += 1 collision_reasons[key] = atoms elif not atom_set.findAtomForPackage(other_pkg, \ modified_use=_pkg_use_enabled(other_pkg)): missing_iuse = other_pkg.iuse.get_missing_iuse( atom.unevaluated_atom.use.required) if missing_iuse: for flag in missing_iuse: atoms = collision_reasons.get(("use", flag), set()) atoms.add((ppkg, atom, other_pkg)) collision_reasons[("use", flag)] = atoms num_all_specific_atoms += 1 else: #Use conditionals not met. violated_atom = atom.violated_conditionals(_pkg_use_enabled(other_pkg), \ other_pkg.iuse.is_valid_flag) if violated_atom.use is None: # Something like bug #453400 caused the # above findAtomForPackage call to # return None unexpectedly. msg = ("\n\n!!! BUG: Detected " "USE dep match inconsistency:\n" "\tppkg: %s\n" "\tviolated_atom: %s\n" "\tatom: %s unevaluated: %s\n" "\tother_pkg: %s IUSE: %s USE: %s\n" % (ppkg, violated_atom, atom, atom.unevaluated_atom, other_pkg, sorted(other_pkg.iuse.all), sorted(_pkg_use_enabled(other_pkg)))) writemsg(msg, noiselevel=-2) raise AssertionError( 'BUG: USE dep match inconsistency') for flag in violated_atom.use.enabled.union(violated_atom.use.disabled): atoms = collision_reasons.get(("use", flag), set()) atoms.add((ppkg, atom, other_pkg)) collision_reasons[("use", flag)] = atoms num_all_specific_atoms += 1 msg.append(" pulled in by\n") selected_for_display = set() unconditional_use_deps = set() for (type, sub_type), parents in collision_reasons.items(): #From each (type, sub_type) pair select at least one atom. #Try to select as few atoms as possible if type == "version": #Find the atom with version that is as far away as possible. best_matches = {} for ppkg, atom, other_pkg in parents: if atom.cp in best_matches: cmp = vercmp( \ cpv_getversion(atom.cpv), \ cpv_getversion(best_matches[atom.cp][1].cpv)) if (sub_type == "ge" and cmp > 0) \ or (sub_type == "le" and cmp < 0) \ or (sub_type == "eq" and cmp > 0): best_matches[atom.cp] = (ppkg, atom) else: best_matches[atom.cp] = (ppkg, atom) if verboseconflicts: selected_for_display.add((ppkg, atom)) if not verboseconflicts: selected_for_display.update( best_matches.values()) elif type == "sub-slot": for ppkg, atom, other_pkg in parents: selected_for_display.add((ppkg, atom)) elif type == "use": #Prefer atoms with unconditional use deps over, because it's #not possible to change them on the parent, which means there #are fewer possible solutions. use = sub_type for ppkg, atom, other_pkg in parents: missing_iuse = other_pkg.iuse.get_missing_iuse( atom.unevaluated_atom.use.required) if missing_iuse: unconditional_use_deps.add((ppkg, atom)) else: parent_use = None if isinstance(ppkg, Package): parent_use = _pkg_use_enabled(ppkg) violated_atom = atom.unevaluated_atom.violated_conditionals( _pkg_use_enabled(other_pkg), other_pkg.iuse.is_valid_flag, parent_use=parent_use) # It's possible for autounmask to change # parent_use such that the unevaluated form # of the atom now matches, even though the # earlier evaluated form (from before # autounmask changed parent_use) does not. # In this case (see bug #374423), it's # expected that violated_atom.use is None. # Since the atom now matches, we don't want # to display it in the slot conflict # message, so we simply ignore it and rely # on the autounmask display to communicate # the necessary USE change to the user. if violated_atom.use is None: continue if use in violated_atom.use.enabled or \ use in violated_atom.use.disabled: unconditional_use_deps.add((ppkg, atom)) # When USE flags are removed, it can be # essential to see all broken reverse # dependencies here, so don't omit any. # If the list is long, people can simply # use a pager. selected_for_display.add((ppkg, atom)) def highlight_violations(atom, version, use=[]): """Colorize parts of an atom""" atom_str = "%s" % (atom,) if version: op = atom.operator ver = None if atom.cp != atom.cpv: ver = cpv_getversion(atom.cpv) slot = atom.slot if op == "=*": op = "=" ver += "*" if op is not None: atom_str = atom_str.replace(op, colorize("BAD", op), 1) if ver is not None: start = atom_str.rfind(ver) end = start + len(ver) atom_str = atom_str[:start] + \ colorize("BAD", ver) + \ atom_str[end:] if slot: atom_str = atom_str.replace(":" + slot, colorize("BAD", ":" + slot)) if use and atom.use.tokens: use_part_start = atom_str.find("[") use_part_end = atom_str.find("]") new_tokens = [] for token in atom.use.tokens: if token.lstrip("-!").rstrip("=?") in use: new_tokens.append(colorize("BAD", token)) else: new_tokens.append(token) atom_str = atom_str[:use_part_start] \ + "[%s]" % (",".join(new_tokens),) + \ atom_str[use_part_end+1:] return atom_str # Show unconditional use deps first, since those # are more problematic than the conditional kind. ordered_list = list(unconditional_use_deps) if len(selected_for_display) > len(unconditional_use_deps): for parent_atom in selected_for_display: if parent_atom not in unconditional_use_deps: ordered_list.append(parent_atom) for parent_atom in ordered_list: parent, atom = parent_atom msg.append(2*indent) if isinstance(parent, (PackageArg, AtomArg)): # For PackageArg and AtomArg types, it's # redundant to display the atom attribute. msg.append("%s" % (parent,)) else: # Display the specific atom from SetArg or # Package types. version_violated = False sub_slot_violated = False use = [] for (type, sub_type), parents in collision_reasons.items(): for x in parents: if parent == x[0] and atom == x[1]: if type == "version": version_violated = True elif type == "sub-slot": sub_slot_violated = True elif type == "use": use.append(sub_type) break atom_str = highlight_violations(atom.unevaluated_atom, version_violated, use) if version_violated or sub_slot_violated: self.is_a_version_conflict = True msg.append("%s required by %s" % (atom_str, parent)) msg.append("\n") if not selected_for_display: msg.append(2*indent) msg.append("(no parents that aren't satisfied by other packages in this slot)\n") self.conflict_is_unspecific = True omitted_parents = num_all_specific_atoms - len(selected_for_display) if omitted_parents: msg.append(2*indent) if len(selected_for_display) > 1: msg.append("(and %d more with the same problems)\n" % omitted_parents) else: msg.append("(and %d more with the same problem)\n" % omitted_parents) else: msg.append(" (no parents)\n") msg.append("\n") msg.append("\n")
def format_unmatched_atom(pkg, atom, pkg_use_enabled): """ Returns two strings. The first string contains the 'atom' with parts of the atom colored, which 'pkg' doesn't match. The second string has the same number of characters as the first one, but consists of only white space or ^. The ^ characters have the same position as the colored parts of the first string. """ # Things to check: # 1. Version # 2. cp # 3. slot/sub_slot # 4. repository # 5. USE highlight = set() def perform_coloring(): atom_str = "" marker_str = "" for ii, x in enumerate(atom): if ii in highlight: atom_str += colorize("BAD", x) marker_str += "^" else: atom_str += x marker_str += " " return atom_str, marker_str if atom.cp != pkg.cp: # Highlight the cp part only. ii = atom.find(atom.cp) highlight.update(range(ii, ii + len(atom.cp))) return perform_coloring() version_atom = atom.without_repo.without_slot.without_use version_atom_set = InternalPackageSet(initial_atoms=(version_atom,)) highlight_version = not bool(version_atom_set.findAtomForPackage(pkg, modified_use=pkg_use_enabled(pkg))) highlight_slot = False if (atom.slot and atom.slot != pkg.slot) or \ (atom.sub_slot and atom.sub_slot != pkg.sub_slot): highlight_slot = True if highlight_version: op = atom.operator ver = None if atom.cp != atom.cpv: ver = cpv_getversion(atom.cpv) if op == "=*": op = "=" ver += "*" if op is not None: highlight.update(range(len(op))) if ver is not None: start = atom.rfind(ver) end = start + len(ver) highlight.update(range(start, end)) if highlight_slot: slot_str = ":" + atom.slot if atom.sub_slot: slot_str += "/" + atom.sub_slot if atom.slot_operator: slot_str += atom.slot_operator start = atom.find(slot_str) end = start + len(slot_str) highlight.update(range(start, end)) highlight_use = set() if atom.use: use_atom = "%s[%s]" % (atom.cp, str(atom.use)) use_atom_set = InternalPackageSet(initial_atoms=(use_atom,)) if not use_atom_set.findAtomForPackage(pkg, \ modified_use=pkg_use_enabled(pkg)): missing_iuse = pkg.iuse.get_missing_iuse( atom.unevaluated_atom.use.required) if missing_iuse: highlight_use = set(missing_iuse) else: #Use conditionals not met. violated_atom = atom.violated_conditionals( pkg_use_enabled(pkg), pkg.iuse.is_valid_flag) if violated_atom.use is not None: highlight_use = set(violated_atom.use.enabled.union( violated_atom.use.disabled)) if highlight_use: ii = atom.find("[") + 1 for token in atom.use.tokens: if token.lstrip("-!").rstrip("=?") in highlight_use: highlight.update(range(ii, ii + len(token))) ii += len(token) + 1 return perform_coloring()
def _prepare_conflict_msg_and_check_for_specificity(self): """ Print all slot conflicts in a human readable way. """ _pkg_use_enabled = self.depgraph._pkg_use_enabled msg = self.conflict_msg indent = " " msg.append("\n!!! Multiple package instances within a single " + \ "package slot have been pulled\n") msg.append("!!! into the dependency graph, resulting" + \ " in a slot conflict:\n\n") for (slot_atom, root), pkgs \ in self.slot_collision_info.items(): msg.append(str(slot_atom)) if root != '/': msg.append(" for %s" % (root, )) msg.append("\n\n") for pkg in pkgs: msg.append(indent) msg.append(str(pkg)) parent_atoms = self.all_parents.get(pkg) if parent_atoms: #Create a list of collision reasons and map them to sets #of atoms. #Possible reasons: # ("version", "ge") for operator >=, > # ("version", "eq") for operator =, ~ # ("version", "le") for operator <=, < # ("use", "<some use flag>") for unmet use conditionals collision_reasons = {} num_all_specific_atoms = 0 for ppkg, atom in parent_atoms: atom_set = InternalPackageSet(initial_atoms=(atom, )) atom_without_use_set = InternalPackageSet( initial_atoms=(atom.without_use, )) for other_pkg in pkgs: if other_pkg == pkg: continue if not atom_without_use_set.findAtomForPackage(other_pkg, \ modified_use=_pkg_use_enabled(other_pkg)): #The version range does not match. sub_type = None if atom.operator in (">=", ">"): sub_type = "ge" elif atom.operator in ("=", "~"): sub_type = "eq" elif atom.operator in ("<=", "<"): sub_type = "le" atoms = collision_reasons.get( ("version", sub_type), set()) atoms.add((ppkg, atom, other_pkg)) num_all_specific_atoms += 1 collision_reasons[("version", sub_type)] = atoms elif not atom_set.findAtomForPackage(other_pkg, \ modified_use=_pkg_use_enabled(other_pkg)): #Use conditionals not met. violated_atom = atom.violated_conditionals(_pkg_use_enabled(other_pkg), \ other_pkg.iuse.is_valid_flag) for flag in violated_atom.use.enabled.union( violated_atom.use.disabled): atoms = collision_reasons.get( ("use", flag), set()) atoms.add((ppkg, atom, other_pkg)) collision_reasons[("use", flag)] = atoms num_all_specific_atoms += 1 msg.append(" pulled in by\n") selected_for_display = set() for (type, sub_type), parents in collision_reasons.items(): #From each (type, sub_type) pair select at least one atom. #Try to select as few atoms as possible if type == "version": #Find the atom with version that is as far away as possible. best_matches = {} for ppkg, atom, other_pkg in parents: if atom.cp in best_matches: cmp = vercmp( \ cpv_getversion(atom.cpv), \ cpv_getversion(best_matches[atom.cp][1].cpv)) if (sub_type == "ge" and cmp > 0) \ or (sub_type == "le" and cmp < 0) \ or (sub_type == "eq" and cmp > 0): best_matches[atom.cp] = (ppkg, atom) else: best_matches[atom.cp] = (ppkg, atom) selected_for_display.update(best_matches.values()) elif type == "use": #Prefer atoms with unconditional use deps over, because it's #not possible to change them on the parent, which means there #are fewer possible solutions. use = sub_type hard_matches = set() conditional_matches = set() for ppkg, atom, other_pkg in parents: parent_use = None if isinstance(ppkg, Package): parent_use = _pkg_use_enabled(ppkg) violated_atom = atom.unevaluated_atom.violated_conditionals( \ _pkg_use_enabled(other_pkg), other_pkg.iuse.is_valid_flag, parent_use=parent_use) if use in violated_atom.use.enabled.union( violated_atom.use.disabled): hard_matches.add((ppkg, atom)) else: conditional_matches.add((ppkg, atom)) if hard_matches: matches = hard_matches else: matches = conditional_matches if not selected_for_display.intersection(matches): selected_for_display.add(matches.pop()) def highlight_violations(atom, version, use=[]): """Colorize parts of an atom""" atom_str = str(atom) if version: op = atom.operator ver = cpv_getversion(atom.cpv) slot = atom.slot atom_str = atom_str.replace( op, colorize("BAD", op), 1) start = atom_str.rfind(ver) end = start + len(ver) atom_str = atom_str[:start] + \ colorize("BAD", ver) + \ atom_str[end+1:] if slot: atom_str = atom_str.replace( ":" + slot, colorize("BAD", ":" + slot)) if use and atom.use.tokens: use_part_start = atom_str.find("[") use_part_end = atom_str.find("]") new_tokens = [] for token in atom.use.tokens: if token.lstrip("-!").rstrip("=?") in use: new_tokens.append(colorize("BAD", token)) else: new_tokens.append(token) atom_str = atom_str[:use_part_start] \ + "[%s]" % (",".join(new_tokens),) + \ atom_str[use_part_end+1:] return atom_str for parent_atom in selected_for_display: parent, atom = parent_atom msg.append(2 * indent) if isinstance(parent, (PackageArg, AtomArg)): # For PackageArg and AtomArg types, it's # redundant to display the atom attribute. msg.append(str(parent)) else: # Display the specific atom from SetArg or # Package types. version_violated = False use = [] for type, sub_type in collision_reasons: if type == "version": for x in collision_reasons[(type, sub_type)]: if ppkg == x[0] and atom == x[1]: version_violated = True elif type == "use": use.append(sub_type) atom_str = highlight_violations( atom.unevaluated_atom, version_violated, use) if version_violated: self.is_a_version_conflict = True msg.append("%s required by %s" % (atom_str, parent)) msg.append("\n") if not selected_for_display: msg.append(2 * indent) msg.append( "(no parents that aren't satisfied by other packages in this slot)\n" ) self.conflict_is_unspecific = True omitted_parents = num_all_specific_atoms - len( selected_for_display) if omitted_parents: msg.append(2 * indent) if len(selected_for_display) > 1: msg.append( "(and %d more with the same problems)\n" % omitted_parents) else: msg.append( "(and %d more with the same problem)\n" % omitted_parents) else: msg.append(" (no parents)\n") msg.append("\n") msg.append("\n")
def format_unmatched_atom(pkg, atom, pkg_use_enabled): """ Returns two strings. The first string contains the 'atom' with parts of the atom colored, which 'pkg' doesn't match. The second string has the same number of characters as the first one, but consists of only white space or ^. The ^ characters have the same position as the colored parts of the first string. """ # Things to check: # 1. Version # 2. cp # 3. slot/sub_slot # 4. repository # 5. USE if atom.soname: return "%s" % (atom, ), "" highlight = set() def perform_coloring(): atom_str = "" marker_str = "" for ii, x in enumerate(atom): if ii in highlight: atom_str += colorize("BAD", x) marker_str += "^" else: atom_str += x marker_str += " " return atom_str, marker_str if atom.cp != pkg.cp: # Highlight the cp part only. ii = atom.find(atom.cp) highlight.update(range(ii, ii + len(atom.cp))) return perform_coloring() version_atom = atom.without_repo.without_slot.without_use version_atom_set = InternalPackageSet(initial_atoms=(version_atom, )) highlight_version = not bool( version_atom_set.findAtomForPackage(pkg, modified_use=pkg_use_enabled(pkg))) highlight_slot = False if (atom.slot and atom.slot != pkg.slot) or \ (atom.sub_slot and atom.sub_slot != pkg.sub_slot): highlight_slot = True if highlight_version: op = atom.operator ver = None if atom.cp != atom.cpv: ver = cpv_getversion(atom.cpv) if op == "=*": op = "=" ver += "*" if op is not None: highlight.update(range(len(op))) if ver is not None: start = atom.rfind(ver) end = start + len(ver) highlight.update(range(start, end)) if highlight_slot: slot_str = ":" + atom.slot if atom.sub_slot: slot_str += "/" + atom.sub_slot if atom.slot_operator: slot_str += atom.slot_operator start = atom.find(slot_str) end = start + len(slot_str) highlight.update(range(start, end)) highlight_use = set() if atom.use: use_atom = "%s[%s]" % (atom.cp, str(atom.use)) use_atom_set = InternalPackageSet(initial_atoms=(use_atom, )) if not use_atom_set.findAtomForPackage(pkg, \ modified_use=pkg_use_enabled(pkg)): missing_iuse = pkg.iuse.get_missing_iuse( atom.unevaluated_atom.use.required) if missing_iuse: highlight_use = set(missing_iuse) else: #Use conditionals not met. violated_atom = atom.violated_conditionals( pkg_use_enabled(pkg), pkg.iuse.is_valid_flag) if violated_atom.use is not None: highlight_use = set( violated_atom.use.enabled.union( violated_atom.use.disabled)) if highlight_use: ii = atom.find("[") + 1 for token in atom.use.tokens: if token.lstrip("-!").rstrip("=?") in highlight_use: highlight.update(range(ii, ii + len(token))) ii += len(token) + 1 return perform_coloring()
def fix_conflict(depgraph): # non-supported problems dynamic_config = depgraph._dynamic_config if not have_conflict(dynamic_config): print("skip: no conflict") return [] if dynamic_config._missing_args: print("skip: missing args") return [] if dynamic_config._pprovided_args: print("skip: pprovided args") return [] if dynamic_config._masked_license_updates: print("skip: masked license") return [] if dynamic_config._masked_installed: print("skip: masked installed") return [] # if dynamic_config._needed_unstable_keywords: # print("skip: needed unstable: %s" % dynamic_config._needed_unstable_keywords) # return [] if dynamic_config._needed_p_mask_changes: print("skip: needed package mask") return [] if dynamic_config._needed_use_config_changes.items(): print("skip: needed use config changes") return [] if dynamic_config._needed_license_changes.items(): print("skip: needed license change") return [] if dynamic_config._unsatisfied_deps_for_display: res = [] for pargs, kwargs in dynamic_config._unsatisfied_deps_for_display: print("%s %s" % (pargs, kwargs)) if "myparent" in kwargs and kwargs["myparent"].operation == "nomerge": ppkg = kwargs["myparent"] res.append(ppkg.cp) return res if dynamic_config._unsatisfied_blockers_for_display is not None: newpkg = set() blockers = dynamic_config._unsatisfied_blockers_for_display for blocker in blockers: for pkg in chain(dynamic_config._blocked_pkgs.child_nodes(blocker), dynamic_config._blocker_parents.parent_nodes(blocker)): parent_atoms = dynamic_config._parent_atoms.get(pkg) if not parent_atoms: continue for parent, atom in parent_atoms: if not isinstance(parent, Package): continue if parent.operation != "merge": print("reinstall %s for %s" % (parent, atom)) newpkg.add(parent) if newpkg: return [p.cp for p in newpkg] _pkg_use_enabled = depgraph._pkg_use_enabled depgraph._slot_conflict_handler = slot_conflict_handler(depgraph) handler = depgraph._slot_conflict_handler newpkg = set() print(handler.all_conflicts) for _, _, pkgs in handler.all_conflicts: for pkg in pkgs[1:]: parents = handler.all_parents.get(pkg) if not parents: continue for ppkg, atom in parents: if not isinstance(ppkg, Package): continue if atom.soname: continue for other_pkg in pkgs: if pkg == other_pkg: continue atom_without_use_set = InternalPackageSet( initial_atoms=(atom.without_use,)) atom_without_use_and_slot_set = InternalPackageSet( initial_atoms=(atom.without_use.without_slot,)) if atom_without_use_and_slot_set.findAtomForPackage( other_pkg, modified_use=_pkg_use_enabled(other_pkg)) and \ atom_without_use_set.findAtomForPackage( other_pkg, modified_use=_pkg_use_enabled(other_pkg)): continue if ppkg.operation != "merge": print("reinstall %s for %s" % (ppkg, pkg)) newpkg.add(ppkg) if newpkg: return [p.cp for p in newpkg] # return ["--reinstall-atoms=" + " ".join([pkg.cp for pkg in newpkg])] return []
def _prepare_conflict_msg_and_check_for_specificity(self): """ Print all slot conflicts in a human readable way. """ _pkg_use_enabled = self.depgraph._pkg_use_enabled usepkgonly = "--usepkgonly" in self.myopts need_rebuild = {} verboseconflicts = "--verbose-conflicts" in self.myopts any_omitted_parents = False msg = self.conflict_msg indent = " " msg.append("\n!!! Multiple package instances within a single " + \ "package slot have been pulled\n") msg.append("!!! into the dependency graph, resulting" + \ " in a slot conflict:\n\n") for root, slot_atom, pkgs in self.all_conflicts: msg.append("%s" % (slot_atom,)) if root != self.depgraph._frozen_config._running_root.root: msg.append(" for %s" % (root,)) msg.append("\n\n") for pkg in pkgs: msg.append(indent) msg.append("%s" % (pkg,)) parent_atoms = self.all_parents.get(pkg) if parent_atoms: #Create a list of collision reasons and map them to sets #of atoms. #Possible reasons: # ("version", "ge") for operator >=, > # ("version", "eq") for operator =, ~ # ("version", "le") for operator <=, < # ("use", "<some use flag>") for unmet use conditionals collision_reasons = {} num_all_specific_atoms = 0 for ppkg, atom in parent_atoms: if not atom.soname: atom_set = InternalPackageSet( initial_atoms=(atom,)) atom_without_use_set = InternalPackageSet( initial_atoms=(atom.without_use,)) atom_without_use_and_slot_set = \ InternalPackageSet(initial_atoms=( atom.without_use.without_slot,)) for other_pkg in pkgs: if other_pkg == pkg: continue if atom.soname: # The soname does not match. key = ("soname", atom) atoms = collision_reasons.get(key, set()) atoms.add((ppkg, atom, other_pkg)) num_all_specific_atoms += 1 collision_reasons[key] = atoms elif not atom_without_use_and_slot_set.findAtomForPackage(other_pkg, modified_use=_pkg_use_enabled(other_pkg)): if atom.operator is not None: # The version range does not match. sub_type = None if atom.operator in (">=", ">"): sub_type = "ge" elif atom.operator in ("=", "~"): sub_type = "eq" elif atom.operator in ("<=", "<"): sub_type = "le" key = ("version", sub_type) atoms = collision_reasons.get(key, set()) atoms.add((ppkg, atom, other_pkg)) num_all_specific_atoms += 1 collision_reasons[key] = atoms elif not atom_without_use_set.findAtomForPackage(other_pkg, \ modified_use=_pkg_use_enabled(other_pkg)): # The slot and/or sub_slot does not match. key = ("slot", (atom.slot, atom.sub_slot, atom.slot_operator)) atoms = collision_reasons.get(key, set()) atoms.add((ppkg, atom, other_pkg)) num_all_specific_atoms += 1 collision_reasons[key] = atoms elif not atom_set.findAtomForPackage(other_pkg, \ modified_use=_pkg_use_enabled(other_pkg)): missing_iuse = other_pkg.iuse.get_missing_iuse( atom.unevaluated_atom.use.required) if missing_iuse: for flag in missing_iuse: atoms = collision_reasons.get(("use", flag), set()) atoms.add((ppkg, atom, other_pkg)) collision_reasons[("use", flag)] = atoms num_all_specific_atoms += 1 else: #Use conditionals not met. violated_atom = atom.violated_conditionals(_pkg_use_enabled(other_pkg), \ other_pkg.iuse.is_valid_flag) if violated_atom.use is None: # Something like bug #453400 caused the # above findAtomForPackage call to # return None unexpectedly. msg = ("\n\n!!! BUG: Detected " "USE dep match inconsistency:\n" "\tppkg: %s\n" "\tviolated_atom: %s\n" "\tatom: %s unevaluated: %s\n" "\tother_pkg: %s IUSE: %s USE: %s\n" % (ppkg, violated_atom, atom, atom.unevaluated_atom, other_pkg, sorted(other_pkg.iuse.all), sorted(_pkg_use_enabled(other_pkg)))) writemsg(msg, noiselevel=-2) raise AssertionError( 'BUG: USE dep match inconsistency') for flag in violated_atom.use.enabled.union(violated_atom.use.disabled): atoms = collision_reasons.get(("use", flag), set()) atoms.add((ppkg, atom, other_pkg)) collision_reasons[("use", flag)] = atoms num_all_specific_atoms += 1 elif isinstance(ppkg, AtomArg) and other_pkg.installed: parent_atoms = collision_reasons.get(("AtomArg", None), set()) parent_atoms.add((ppkg, atom)) collision_reasons[("AtomArg", None)] = parent_atoms num_all_specific_atoms += 1 msg.append(" pulled in by\n") selected_for_display = set() unconditional_use_deps = set() for (type, sub_type), parents in collision_reasons.items(): #From each (type, sub_type) pair select at least one atom. #Try to select as few atoms as possible if type == "version": #Find the atom with version that is as far away as possible. best_matches = {} for ppkg, atom, other_pkg in parents: if atom.cp in best_matches: cmp = vercmp( \ cpv_getversion(atom.cpv), \ cpv_getversion(best_matches[atom.cp][1].cpv)) if (sub_type == "ge" and cmp > 0) \ or (sub_type == "le" and cmp < 0) \ or (sub_type == "eq" and cmp > 0): best_matches[atom.cp] = (ppkg, atom) else: best_matches[atom.cp] = (ppkg, atom) if verboseconflicts: selected_for_display.add((ppkg, atom)) if not verboseconflicts: selected_for_display.update( best_matches.values()) elif type in ("soname", "slot"): # Check for packages that might need to # be rebuilt, but cannot be rebuilt for # some reason. for ppkg, atom, other_pkg in parents: if not (isinstance(ppkg, Package) and ppkg.installed): continue if not (atom.soname or atom.slot_operator_built): continue if self.depgraph._frozen_config.excluded_pkgs.findAtomForPackage(ppkg, modified_use=self.depgraph._pkg_use_enabled(ppkg)): selected_for_display.add((ppkg, atom)) need_rebuild[ppkg] = 'matched by --exclude argument' elif self.depgraph._frozen_config.useoldpkg_atoms.findAtomForPackage(ppkg, modified_use=self.depgraph._pkg_use_enabled(ppkg)): selected_for_display.add((ppkg, atom)) need_rebuild[ppkg] = 'matched by --useoldpkg-atoms argument' elif usepkgonly: # This case is tricky, so keep quiet in order to avoid false-positives. pass elif not self.depgraph._equiv_ebuild_visible(ppkg): selected_for_display.add((ppkg, atom)) need_rebuild[ppkg] = 'ebuild is masked or unavailable' for ppkg, atom, other_pkg in parents: selected_for_display.add((ppkg, atom)) if not verboseconflicts: break elif type == "use": #Prefer atoms with unconditional use deps over, because it's #not possible to change them on the parent, which means there #are fewer possible solutions. use = sub_type for ppkg, atom, other_pkg in parents: missing_iuse = other_pkg.iuse.get_missing_iuse( atom.unevaluated_atom.use.required) if missing_iuse: unconditional_use_deps.add((ppkg, atom)) else: parent_use = None if isinstance(ppkg, Package): parent_use = _pkg_use_enabled(ppkg) violated_atom = atom.unevaluated_atom.violated_conditionals( _pkg_use_enabled(other_pkg), other_pkg.iuse.is_valid_flag, parent_use=parent_use) # It's possible for autounmask to change # parent_use such that the unevaluated form # of the atom now matches, even though the # earlier evaluated form (from before # autounmask changed parent_use) does not. # In this case (see bug #374423), it's # expected that violated_atom.use is None. # Since the atom now matches, we don't want # to display it in the slot conflict # message, so we simply ignore it and rely # on the autounmask display to communicate # the necessary USE change to the user. if violated_atom.use is None: continue if use in violated_atom.use.enabled or \ use in violated_atom.use.disabled: unconditional_use_deps.add((ppkg, atom)) # When USE flags are removed, it can be # essential to see all broken reverse # dependencies here, so don't omit any. # If the list is long, people can simply # use a pager. selected_for_display.add((ppkg, atom)) elif type == "AtomArg": for ppkg, atom in parents: selected_for_display.add((ppkg, atom)) def highlight_violations(atom, version, use, slot_violated): """Colorize parts of an atom""" atom_str = "%s" % (atom,) colored_idx = set() if version: op = atom.operator ver = None if atom.cp != atom.cpv: ver = cpv_getversion(atom.cpv) slot = atom.slot sub_slot = atom.sub_slot slot_operator = atom.slot_operator if op == "=*": op = "=" ver += "*" slot_str = "" if slot: slot_str = ":" + slot if sub_slot: slot_str += "/" + sub_slot if slot_operator: slot_str += slot_operator # Compute color_idx before adding the color codes # as these change the indices of the letters. if op is not None: colored_idx.update(range(len(op))) if ver is not None: start = atom_str.rfind(ver) end = start + len(ver) colored_idx.update(range(start, end)) if slot_str: ii = atom_str.find(slot_str) colored_idx.update(range(ii, ii + len(slot_str))) if op is not None: atom_str = atom_str.replace(op, colorize("BAD", op), 1) if ver is not None: start = atom_str.rfind(ver) end = start + len(ver) atom_str = atom_str[:start] + \ colorize("BAD", ver) + \ atom_str[end:] if slot_str: atom_str = atom_str.replace(slot_str, colorize("BAD", slot_str), 1) elif slot_violated: slot = atom.slot sub_slot = atom.sub_slot slot_operator = atom.slot_operator slot_str = "" if slot: slot_str = ":" + slot if sub_slot: slot_str += "/" + sub_slot if slot_operator: slot_str += slot_operator if slot_str: ii = atom_str.find(slot_str) colored_idx.update(range(ii, ii + len(slot_str))) atom_str = atom_str.replace(slot_str, colorize("BAD", slot_str), 1) if use and atom.use.tokens: use_part_start = atom_str.find("[") use_part_end = atom_str.find("]") new_tokens = [] # Compute start index in non-colored atom. ii = str(atom).find("[") + 1 for token in atom.use.tokens: if token.lstrip("-!").rstrip("=?") in use: new_tokens.append(colorize("BAD", token)) colored_idx.update(range(ii, ii + len(token))) else: new_tokens.append(token) ii += 1 + len(token) atom_str = atom_str[:use_part_start] \ + "[%s]" % (",".join(new_tokens),) + \ atom_str[use_part_end+1:] return atom_str, colored_idx # Show unconditional use deps first, since those # are more problematic than the conditional kind. ordered_list = list(unconditional_use_deps) if len(selected_for_display) > len(unconditional_use_deps): for parent_atom in selected_for_display: if parent_atom not in unconditional_use_deps: ordered_list.append(parent_atom) for parent_atom in ordered_list: parent, atom = parent_atom if atom.soname: msg.append("%s required by %s\n" % (atom, parent)) elif isinstance(parent, PackageArg): # For PackageArg it's # redundant to display the atom attribute. msg.append("%s\n" % (parent,)) elif isinstance(parent, AtomArg): msg.append(2*indent) msg.append("%s (Argument)\n" % (atom,)) else: # Display the specific atom from SetArg or # Package types. version_violated = False slot_violated = False use = [] for (type, sub_type), parents in collision_reasons.items(): for x in parents: if parent == x[0] and atom == x[1]: if type == "version": version_violated = True elif type == "slot": slot_violated = True elif type == "use": use.append(sub_type) break atom_str, colored_idx = highlight_violations(atom.unevaluated_atom, version_violated, use, slot_violated) if version_violated or slot_violated: self.is_a_version_conflict = True cur_line = "%s required by %s\n" % (atom_str, parent) marker_line = "" for ii in range(len(cur_line)): if ii in colored_idx: marker_line += "^" else: marker_line += " " marker_line += "\n" msg.append(2*indent) msg.append(cur_line) msg.append(2*indent) msg.append(marker_line) if not selected_for_display: msg.append(2*indent) msg.append("(no parents that aren't satisfied by other packages in this slot)\n") self.conflict_is_unspecific = True omitted_parents = num_all_specific_atoms - len(selected_for_display) if omitted_parents: any_omitted_parents = True msg.append(2*indent) if len(selected_for_display) > 1: msg.append("(and %d more with the same problems)\n" % omitted_parents) else: msg.append("(and %d more with the same problem)\n" % omitted_parents) else: msg.append(" (no parents)\n") msg.append("\n") if any_omitted_parents: msg.append(colorize("INFORM", "NOTE: Use the '--verbose-conflicts'" " option to display parents omitted above")) msg.append("\n") if need_rebuild: msg.append("\n!!! The slot conflict(s) shown above involve package(s) which may need to\n") msg.append("!!! be rebuilt in order to solve the conflict(s). However, the following\n") msg.append("!!! package(s) cannot be rebuilt for the reason(s) shown:\n\n") for ppkg, reason in need_rebuild.items(): msg.append("%s%s: %s\n" % (indent, ppkg, reason)) msg.append("\n") msg.append("\n")
def _prepare_conflict_msg_and_check_for_specificity(self): """ Print all slot conflicts in a human readable way. """ _pkg_use_enabled = self.depgraph._pkg_use_enabled usepkgonly = "--usepkgonly" in self.myopts need_rebuild = {} verboseconflicts = "--verbose-conflicts" in self.myopts any_omitted_parents = False msg = self.conflict_msg indent = " " msg.append("\n!!! Multiple package instances within a single " + \ "package slot have been pulled\n") msg.append("!!! into the dependency graph, resulting" + \ " in a slot conflict:\n\n") for root, slot_atom, pkgs in self.all_conflicts: msg.append("%s" % (slot_atom,)) if root != self.depgraph._frozen_config._running_root.root: msg.append(" for %s" % (root,)) msg.append("\n\n") for pkg in pkgs: msg.append(indent) msg.append("%s %s" % (pkg, pkg_use_display(pkg, self.depgraph._frozen_config.myopts, modified_use=self.depgraph._pkg_use_enabled(pkg)))) parent_atoms = self.all_parents.get(pkg) if parent_atoms: #Create a list of collision reasons and map them to sets #of atoms. #Possible reasons: # ("version", "ge") for operator >=, > # ("version", "eq") for operator =, ~ # ("version", "le") for operator <=, < # ("use", "<some use flag>") for unmet use conditionals collision_reasons = {} num_all_specific_atoms = 0 for ppkg, atom in parent_atoms: if not atom.soname: atom_set = InternalPackageSet( initial_atoms=(atom,)) atom_without_use_set = InternalPackageSet( initial_atoms=(atom.without_use,)) atom_without_use_and_slot_set = \ InternalPackageSet(initial_atoms=( atom.without_use.without_slot,)) for other_pkg in pkgs: if other_pkg == pkg: continue if atom.soname: # The soname does not match. key = ("soname", atom) atoms = collision_reasons.get(key, set()) atoms.add((ppkg, atom, other_pkg)) num_all_specific_atoms += 1 collision_reasons[key] = atoms elif not atom_without_use_and_slot_set.findAtomForPackage(other_pkg, modified_use=_pkg_use_enabled(other_pkg)): if atom.operator is not None: # The version range does not match. sub_type = None if atom.operator in (">=", ">"): sub_type = "ge" elif atom.operator in ("=", "~"): sub_type = "eq" elif atom.operator in ("<=", "<"): sub_type = "le" key = ("version", sub_type) atoms = collision_reasons.get(key, set()) atoms.add((ppkg, atom, other_pkg)) num_all_specific_atoms += 1 collision_reasons[key] = atoms elif not atom_without_use_set.findAtomForPackage(other_pkg, \ modified_use=_pkg_use_enabled(other_pkg)): # The slot and/or sub_slot does not match. key = ("slot", (atom.slot, atom.sub_slot, atom.slot_operator)) atoms = collision_reasons.get(key, set()) atoms.add((ppkg, atom, other_pkg)) num_all_specific_atoms += 1 collision_reasons[key] = atoms elif not atom_set.findAtomForPackage(other_pkg, \ modified_use=_pkg_use_enabled(other_pkg)): missing_iuse = other_pkg.iuse.get_missing_iuse( atom.unevaluated_atom.use.required) if missing_iuse: for flag in missing_iuse: atoms = collision_reasons.get(("use", flag), set()) atoms.add((ppkg, atom, other_pkg)) collision_reasons[("use", flag)] = atoms num_all_specific_atoms += 1 else: #Use conditionals not met. violated_atom = atom.violated_conditionals(_pkg_use_enabled(other_pkg), \ other_pkg.iuse.is_valid_flag) if violated_atom.use is None: # Something like bug #453400 caused the # above findAtomForPackage call to # return None unexpectedly. msg = ("\n\n!!! BUG: Detected " "USE dep match inconsistency:\n" "\tppkg: %s\n" "\tviolated_atom: %s\n" "\tatom: %s unevaluated: %s\n" "\tother_pkg: %s IUSE: %s USE: %s\n" % (ppkg, violated_atom, atom, atom.unevaluated_atom, other_pkg, sorted(other_pkg.iuse.all), sorted(_pkg_use_enabled(other_pkg)))) writemsg(msg, noiselevel=-2) raise AssertionError( 'BUG: USE dep match inconsistency') for flag in violated_atom.use.enabled.union(violated_atom.use.disabled): atoms = collision_reasons.get(("use", flag), set()) atoms.add((ppkg, atom, other_pkg)) collision_reasons[("use", flag)] = atoms num_all_specific_atoms += 1 elif isinstance(ppkg, AtomArg) and other_pkg.installed: parent_atoms = collision_reasons.get(("AtomArg", None), set()) parent_atoms.add((ppkg, atom)) collision_reasons[("AtomArg", None)] = parent_atoms num_all_specific_atoms += 1 msg.append(" pulled in by\n") selected_for_display = set() unconditional_use_deps = set() for (type, sub_type), parents in collision_reasons.items(): #From each (type, sub_type) pair select at least one atom. #Try to select as few atoms as possible if type == "version": #Find the atom with version that is as far away as possible. best_matches = {} for ppkg, atom, other_pkg in parents: if atom.cp in best_matches: cmp = vercmp( \ cpv_getversion(atom.cpv), \ cpv_getversion(best_matches[atom.cp][1].cpv)) if (sub_type == "ge" and cmp > 0) \ or (sub_type == "le" and cmp < 0) \ or (sub_type == "eq" and cmp > 0): best_matches[atom.cp] = (ppkg, atom) else: best_matches[atom.cp] = (ppkg, atom) if verboseconflicts: selected_for_display.add((ppkg, atom)) if not verboseconflicts: selected_for_display.update( best_matches.values()) elif type in ("soname", "slot"): # Check for packages that might need to # be rebuilt, but cannot be rebuilt for # some reason. for ppkg, atom, other_pkg in parents: if not (isinstance(ppkg, Package) and ppkg.installed): continue if not (atom.soname or atom.slot_operator_built): continue if self.depgraph._frozen_config.excluded_pkgs.findAtomForPackage(ppkg, modified_use=self.depgraph._pkg_use_enabled(ppkg)): selected_for_display.add((ppkg, atom)) need_rebuild[ppkg] = 'matched by --exclude argument' elif self.depgraph._frozen_config.useoldpkg_atoms.findAtomForPackage(ppkg, modified_use=self.depgraph._pkg_use_enabled(ppkg)): selected_for_display.add((ppkg, atom)) need_rebuild[ppkg] = 'matched by --useoldpkg-atoms argument' elif usepkgonly: # This case is tricky, so keep quiet in order to avoid false-positives. pass elif not self.depgraph._equiv_ebuild_visible(ppkg): selected_for_display.add((ppkg, atom)) need_rebuild[ppkg] = 'ebuild is masked or unavailable' for ppkg, atom, other_pkg in parents: selected_for_display.add((ppkg, atom)) if not verboseconflicts: break elif type == "use": #Prefer atoms with unconditional use deps over, because it's #not possible to change them on the parent, which means there #are fewer possible solutions. use = sub_type for ppkg, atom, other_pkg in parents: missing_iuse = other_pkg.iuse.get_missing_iuse( atom.unevaluated_atom.use.required) if missing_iuse: unconditional_use_deps.add((ppkg, atom)) else: parent_use = None if isinstance(ppkg, Package): parent_use = _pkg_use_enabled(ppkg) violated_atom = atom.unevaluated_atom.violated_conditionals( _pkg_use_enabled(other_pkg), other_pkg.iuse.is_valid_flag, parent_use=parent_use) # It's possible for autounmask to change # parent_use such that the unevaluated form # of the atom now matches, even though the # earlier evaluated form (from before # autounmask changed parent_use) does not. # In this case (see bug #374423), it's # expected that violated_atom.use is None. # Since the atom now matches, we don't want # to display it in the slot conflict # message, so we simply ignore it and rely # on the autounmask display to communicate # the necessary USE change to the user. if violated_atom.use is None: continue if use in violated_atom.use.enabled or \ use in violated_atom.use.disabled: unconditional_use_deps.add((ppkg, atom)) # When USE flags are removed, it can be # essential to see all broken reverse # dependencies here, so don't omit any. # If the list is long, people can simply # use a pager. selected_for_display.add((ppkg, atom)) elif type == "AtomArg": for ppkg, atom in parents: selected_for_display.add((ppkg, atom)) def highlight_violations(atom, version, use, slot_violated): """Colorize parts of an atom""" atom_str = "%s" % (atom,) colored_idx = set() if version: op = atom.operator ver = None if atom.cp != atom.cpv: ver = cpv_getversion(atom.cpv) slot = atom.slot sub_slot = atom.sub_slot slot_operator = atom.slot_operator if op == "=*": op = "=" ver += "*" slot_str = "" if slot: slot_str = ":" + slot if sub_slot: slot_str += "/" + sub_slot if slot_operator: slot_str += slot_operator # Compute color_idx before adding the color codes # as these change the indices of the letters. if op is not None: colored_idx.update(range(len(op))) if ver is not None: start = atom_str.rfind(ver) end = start + len(ver) colored_idx.update(range(start, end)) if slot_str: ii = atom_str.find(slot_str) colored_idx.update(range(ii, ii + len(slot_str))) if op is not None: atom_str = atom_str.replace(op, colorize("BAD", op), 1) if ver is not None: start = atom_str.rfind(ver) end = start + len(ver) atom_str = atom_str[:start] + \ colorize("BAD", ver) + \ atom_str[end:] if slot_str: atom_str = atom_str.replace(slot_str, colorize("BAD", slot_str), 1) elif slot_violated: slot = atom.slot sub_slot = atom.sub_slot slot_operator = atom.slot_operator slot_str = "" if slot: slot_str = ":" + slot if sub_slot: slot_str += "/" + sub_slot if slot_operator: slot_str += slot_operator if slot_str: ii = atom_str.find(slot_str) colored_idx.update(range(ii, ii + len(slot_str))) atom_str = atom_str.replace(slot_str, colorize("BAD", slot_str), 1) if use and atom.use.tokens: use_part_start = atom_str.find("[") use_part_end = atom_str.find("]") new_tokens = [] # Compute start index in non-colored atom. ii = str(atom).find("[") + 1 for token in atom.use.tokens: if token.lstrip("-!").rstrip("=?") in use: new_tokens.append(colorize("BAD", token)) colored_idx.update(range(ii, ii + len(token))) else: new_tokens.append(token) ii += 1 + len(token) atom_str = atom_str[:use_part_start] \ + "[%s]" % (",".join(new_tokens),) + \ atom_str[use_part_end+1:] return atom_str, colored_idx # Show unconditional use deps first, since those # are more problematic than the conditional kind. ordered_list = list(unconditional_use_deps) if len(selected_for_display) > len(unconditional_use_deps): for parent_atom in selected_for_display: if parent_atom not in unconditional_use_deps: ordered_list.append(parent_atom) for parent_atom in ordered_list: parent, atom = parent_atom if isinstance(parent, Package): use_display = pkg_use_display(parent, self.depgraph._frozen_config.myopts, modified_use=self.depgraph._pkg_use_enabled(parent)) else: use_display = "" if atom.soname: msg.append("%s required by %s %s\n" % (atom, parent, use_display)) elif isinstance(parent, PackageArg): # For PackageArg it's # redundant to display the atom attribute. msg.append("%s\n" % (parent,)) elif isinstance(parent, AtomArg): msg.append(2*indent) msg.append("%s (Argument)\n" % (atom,)) else: # Display the specific atom from SetArg or # Package types. version_violated = False slot_violated = False use = [] for (type, sub_type), parents in collision_reasons.items(): for x in parents: if parent == x[0] and atom == x[1]: if type == "version": version_violated = True elif type == "slot": slot_violated = True elif type == "use": use.append(sub_type) break atom_str, colored_idx = highlight_violations(atom.unevaluated_atom, version_violated, use, slot_violated) if version_violated or slot_violated: self.is_a_version_conflict = True cur_line = "%s required by %s %s\n" % (atom_str, parent, use_display) marker_line = "" for ii in range(len(cur_line)): if ii in colored_idx: marker_line += "^" else: marker_line += " " marker_line += "\n" msg.append(2*indent) msg.append(cur_line) msg.append(2*indent) msg.append(marker_line) if not selected_for_display: msg.append(2*indent) msg.append("(no parents that aren't satisfied by other packages in this slot)\n") self.conflict_is_unspecific = True omitted_parents = num_all_specific_atoms - len(selected_for_display) if omitted_parents: any_omitted_parents = True msg.append(2*indent) if len(selected_for_display) > 1: msg.append("(and %d more with the same problems)\n" % omitted_parents) else: msg.append("(and %d more with the same problem)\n" % omitted_parents) else: msg.append(" (no parents)\n") msg.append("\n") if any_omitted_parents: msg.append(colorize("INFORM", "NOTE: Use the '--verbose-conflicts'" " option to display parents omitted above")) msg.append("\n") if need_rebuild: msg.append("\n!!! The slot conflict(s) shown above involve package(s) which may need to\n") msg.append("!!! be rebuilt in order to solve the conflict(s). However, the following\n") msg.append("!!! package(s) cannot be rebuilt for the reason(s) shown:\n\n") for ppkg, reason in need_rebuild.items(): msg.append("%s%s: %s\n" % (indent, ppkg, reason)) msg.append("\n") msg.append("\n")
def _prepare_conflict_msg_and_check_for_specificity(self): """ Print all slot conflicts in a human readable way. """ _pkg_use_enabled = self.depgraph._pkg_use_enabled msg = self.conflict_msg indent = " " msg.append("\n!!! Multiple package instances within a single " + \ "package slot have been pulled\n") msg.append("!!! into the dependency graph, resulting" + \ " in a slot conflict:\n\n") for (slot_atom, root), pkgs \ in self.slot_collision_info.items(): msg.append(str(slot_atom)) if root != '/': msg.append(" for %s" % (root,)) msg.append("\n\n") for pkg in pkgs: msg.append(indent) msg.append(str(pkg)) parent_atoms = self.all_parents.get(pkg) if parent_atoms: #Create a list of collision reasons and map them to sets #of atoms. #Possible reasons: # ("version", "ge") for operator >=, > # ("version", "eq") for operator =, ~ # ("version", "le") for operator <=, < # ("use", "<some use flag>") for unmet use conditionals collision_reasons = {} num_all_specific_atoms = 0 for ppkg, atom in parent_atoms: atom_set = InternalPackageSet(initial_atoms=(atom,)) atom_without_use_set = InternalPackageSet(initial_atoms=(atom.without_use,)) for other_pkg in pkgs: if other_pkg == pkg: continue if not atom_without_use_set.findAtomForPackage(other_pkg, \ modified_use=_pkg_use_enabled(other_pkg)): #The version range does not match. sub_type = None if atom.operator in (">=", ">"): sub_type = "ge" elif atom.operator in ("=", "~"): sub_type = "eq" elif atom.operator in ("<=", "<"): sub_type = "le" atoms = collision_reasons.get(("version", sub_type), set()) atoms.add((ppkg, atom, other_pkg)) num_all_specific_atoms += 1 collision_reasons[("version", sub_type)] = atoms elif not atom_set.findAtomForPackage(other_pkg, \ modified_use=_pkg_use_enabled(other_pkg)): #Use conditionals not met. violated_atom = atom.violated_conditionals(_pkg_use_enabled(other_pkg), \ other_pkg.iuse.is_valid_flag) for flag in violated_atom.use.enabled.union(violated_atom.use.disabled): atoms = collision_reasons.get(("use", flag), set()) atoms.add((ppkg, atom, other_pkg)) collision_reasons[("use", flag)] = atoms num_all_specific_atoms += 1 msg.append(" pulled in by\n") selected_for_display = set() for (type, sub_type), parents in collision_reasons.items(): #From each (type, sub_type) pair select at least one atom. #Try to select as few atoms as possible if type == "version": #Find the atom with version that is as far away as possible. best_matches = {} for ppkg, atom, other_pkg in parents: if atom.cp in best_matches: cmp = vercmp( \ cpv_getversion(atom.cpv), \ cpv_getversion(best_matches[atom.cp][1].cpv)) if (sub_type == "ge" and cmp > 0) \ or (sub_type == "le" and cmp < 0) \ or (sub_type == "eq" and cmp > 0): best_matches[atom.cp] = (ppkg, atom) else: best_matches[atom.cp] = (ppkg, atom) selected_for_display.update(best_matches.values()) elif type == "use": #Prefer atoms with unconditional use deps over, because it's #not possible to change them on the parent, which means there #are fewer possible solutions. use = sub_type hard_matches = set() conditional_matches = set() for ppkg, atom, other_pkg in parents: parent_use = None if isinstance(ppkg, Package): parent_use = _pkg_use_enabled(ppkg) violated_atom = atom.unevaluated_atom.violated_conditionals( \ _pkg_use_enabled(other_pkg), other_pkg.iuse.is_valid_flag, parent_use=parent_use) if use in violated_atom.use.enabled.union(violated_atom.use.disabled): hard_matches.add((ppkg, atom)) else: conditional_matches.add((ppkg, atom)) if hard_matches: matches = hard_matches else: matches = conditional_matches if not selected_for_display.intersection(matches): selected_for_display.add(matches.pop()) def highlight_violations(atom, version, use=[]): """Colorize parts of an atom""" atom_str = str(atom) if version: op = atom.operator ver = cpv_getversion(atom.cpv) slot = atom.slot atom_str = atom_str.replace(op, colorize("BAD", op), 1) start = atom_str.rfind(ver) end = start + len(ver) atom_str = atom_str[:start] + \ colorize("BAD", ver) + \ atom_str[end+1:] if slot: atom_str = atom_str.replace(":" + slot, colorize("BAD", ":" + slot)) if use and atom.use.tokens: use_part_start = atom_str.find("[") use_part_end = atom_str.find("]") new_tokens = [] for token in atom.use.tokens: if token.lstrip("-!").rstrip("=?") in use: new_tokens.append(colorize("BAD", token)) else: new_tokens.append(token) atom_str = atom_str[:use_part_start] \ + "[%s]" % (",".join(new_tokens),) + \ atom_str[use_part_end+1:] return atom_str for parent_atom in selected_for_display: parent, atom = parent_atom msg.append(2*indent) if isinstance(parent, (PackageArg, AtomArg)): # For PackageArg and AtomArg types, it's # redundant to display the atom attribute. msg.append(str(parent)) else: # Display the specific atom from SetArg or # Package types. version_violated = False use = [] for type, sub_type in collision_reasons: if type == "version": for x in collision_reasons[(type, sub_type)]: if ppkg == x[0] and atom == x[1]: version_violated = True elif type == "use": use.append(sub_type) atom_str = highlight_violations(atom.unevaluated_atom, version_violated, use) if version_violated: self.is_a_version_conflict = True msg.append("%s required by %s" % (atom_str, parent)) msg.append("\n") if not selected_for_display: msg.append(2*indent) msg.append("(no parents that aren't satisfied by other packages in this slot)\n") self.conflict_is_unspecific = True omitted_parents = num_all_specific_atoms - len(selected_for_display) if omitted_parents: msg.append(2*indent) if len(selected_for_display) > 1: msg.append("(and %d more with the same problems)\n" % omitted_parents) else: msg.append("(and %d more with the same problem)\n" % omitted_parents) else: msg.append(" (no parents)\n") msg.append("\n") msg.append("\n")