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
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
def gen_structure(dbapi, repo_name): trees = [getcwd()] ret = {} for cp in dbapi.cp_all(trees=trees): cpvlist = dbapi.cp_list(cp, mytree=trees) category, pkgname = catpkgsplit(cpvlist[0])[:2] cat = ret.setdefault(category, {}) pn = cat.setdefault(pkgname, {}) pn["data"] = dbapi.aux_get(cpvlist[-1], WANT_DATA) pn["versions"] = [cpv_getversion(cpv) for cpv in cpvlist] return ret
def atomVersion(self): """Returns the package version""" return cpv_getversion(self.atom)
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 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
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 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
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 get_build_dict_db(session, config_id, settings, zobcs_settings_dict, pkg): myportdb = portage.portdbapi(mysettings=settings) cpvr_list = catpkgsplit(pkg.cpv, silent=1) categories = cpvr_list[0] package = cpvr_list[1] repo = pkg.repo ebuild_version = cpv_getversion(pkg.cpv) log_msg = "Logging %s:%s" % (pkg.cpv, repo,) add_logs(session, log_msg, "info", config_id) PackageInfo = get_package_info(session, categories, package, repo) build_dict = {} build_dict['ebuild_version'] = ebuild_version build_dict['package_id'] = PackageInfo.PackageId build_dict['cpv'] = pkg.cpv build_dict['categories'] = categories build_dict['package'] = package build_dict['config_id'] = config_id init_useflags = zobcs_use_flags(settings, myportdb, pkg.cpv) iuse_flags_list, final_use_list = init_useflags.get_flags_pkg(pkg, settings) iuse = [] for iuse_line in iuse_flags_list: iuse.append(init_useflags.reduce_flag(iuse_line)) iuse_flags_list2 = list(set(iuse)) use_enable = final_use_list use_disable = list(set(iuse_flags_list2).difference(set(use_enable))) use_flagsDict = {} for x in use_enable: use_id = get_use_id(session, x) use_flagsDict[use_id] = True for x in use_disable: use_id = get_use_id(session, x) use_flagsDict[use_id] = False if use_enable == [] and use_disable == []: build_dict['build_useflags'] = None else: build_dict['build_useflags'] = use_flagsDict pkgdir = myportdb.getRepositoryPath(repo) + "/" + categories + "/" + package ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + package + "-" + ebuild_version + ".ebuild")[0] build_dict['checksum'] = ebuild_version_checksum_tree ebuild_id_list, status = get_ebuild_id_db(session, build_dict['checksum'], build_dict['package_id']) if status: if ebuild_id_list is None: log_msg = "%s:%s Don't have any ebuild_id!" % (pkg.cpv, repo,) add_logs(session, log_msg, "info", config_id) update_manifest_sql(session, build_dict['package_id'], "0") init_package = zobcs_package(session, settings, myportdb, config_id, zobcs_settings_dict) init_package.update_package_db(build_dict['package_id']) ebuild_id_list, status = get_ebuild_id_db(session, build_dict['checksum'], build_dict['package_id']) if status and ebuild_id_list is None: log_msg = "%s:%s Don't have any ebuild_id!" % (pkg.cpv, repo,) add_logs(session, log_msg, "error", config_id) else: old_ebuild_id_list = [] for ebuild_id in ebuild_id_list: log_msg = "%s:%s:%s Dups of checksums" % (pkg.cpv, repo, ebuild_id,) add_logs(session, log_msg, "error", config_id) old_ebuild_id_list.append(ebuild_id) add_old_ebuild(session, old_ebuild_id_list) return build_dict['ebuild_id'] = ebuild_id_list build_job_id = get_build_job_id(session, build_dict) if build_job_id is None: build_dict['build_job_id'] = None else: build_dict['build_job_id'] = build_job_id return build_dict
def __new__(self, cpv): return PMPackageVersion.__new__(self, cpv_getversion(cpv))
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")