consumer=self._metadata_callback,
max_jobs=max_jobs, max_load=max_load)
self.returncode = os.EX_OK
- metadbmodule = portdb.mysettings.load_best_module("portdbapi.metadbmodule")
+ metadbmodule = portdb.settings.load_best_module("portdbapi.metadbmodule")
self._trg_cache = metadbmodule(portdb.porttrees[0],
"metadata/cache", portage.auxdbkeys[:])
if rsync:
if onProgress:
onProgress(maxval, 0)
for i, atom in enumerate(world_atoms):
- if not portage.isvalidatom(atom):
+ if not isinstance(atom, portage.dep.Atom):
if atom.startswith(SETPREFIX):
s = atom[len(SETPREFIX):]
if s in sets:
if onProgress:
onProgress(maxval, i+1)
continue
- cp = portage.dep_getkey(atom)
okay = True
if not vardb.match(atom):
self.not_installed.append(atom)
okay = False
- if portage.catsplit(cp)[0] not in categories:
+ if portage.catsplit(atom.cp)[0] not in categories:
self.invalid_category.append(atom)
okay = False
if okay:
fd1.write("... ")
else:
for pkg in myglsa.packages:
- mylist = vardb.match(portage.dep_getkey(str(pkg)))
+ mylist = vardb.match(pkg)
if len(mylist) > 0:
pkg = color(" ".join(mylist))
fd1.write(" " + pkg + " ")
sys.stdout.write("The following updates will be performed for this GLSA:\n")
for pkg in mergelist:
oldver = None
- for x in vardb.match(portage.dep_getkey(pkg)):
+ for x in vardb.match(portage.cpv_getkey(pkg)):
if vardb.aux_get(x, ["SLOT"]) == portdb.aux_get(pkg, ["SLOT"]):
oldver = x
if oldver == None:
raise ValueError("could not find old version for package %s" % pkg)
- oldver = oldver[len(portage.dep_getkey(oldver))+1:]
+ oldver = oldver[len(portage.cpv_getkey(oldver))+1:]
sys.stdout.write(" " + pkg + " (" + oldver + ")\n")
else:
sys.stdout.write("Nothing to do for this GLSA\n")
except ImportError:
from urllib import urlopen as urllib_request_urlopen
-from io import StringIO
from itertools import chain
from stat import S_ISDIR, ST_CTIME
from portage import os
from portage import _encodings
from portage import _unicode_encode
+from portage import StringIO
from repoman.checks import run_checks
from repoman import utilities
global_pmasklines = portage.util.stack_lists(global_pmasklines, incremental=1)
global_pmaskdict = {}
for x in global_pmasklines:
- global_pmaskdict.setdefault(portage.dep_getkey(x), []).append(x)
+ global_pmaskdict.setdefault(x.cp, []).append(x)
del global_pmasklines
def has_global_mask(pkg):
"%s: '%s' found in thirdpartymirrors" % \
(relative_path, mirror))
+ provide = portage.flatten(portage.dep.use_reduce(
+ portage.dep.paren_reduce(pkg.metadata['PROVIDE']), matchall=1))
+ provide_cps = []
+
# The Package class automatically evaluates USE conditionals.
- for myprovide in portage.flatten(portage.dep.use_reduce(
- portage.dep.paren_reduce(pkg.metadata['PROVIDE']), matchall=1)):
- prov_cp = portage.dep_getkey(myprovide)
+ for myprovide in provide:
+ try:
+ myprovide = portage.dep.Atom(myprovide)
+ except portage.exception.InvalidAtom:
+ stats["PROVIDE.syntax"] = stats["PROVIDE.syntax"] + 1
+ fails["PROVIDE.syntax"].append("%s: %s" % \
+ (relative_path, myprovide))
+ continue
+ prov_cp = myprovide.cp
+ provide_cps.append(prov_cp)
if prov_cp != myprovide:
stats["virtual.versioned"]+=1
fails["virtual.versioned"].append(x+"/"+y+".ebuild: "+myprovide)
- prov_pkg = portage.dep_getkey(
+ prov_pkg = portage.cpv_getkey(
portage.best(portdb.xmatch("match-all", prov_cp)))
if prov_cp == prov_pkg:
stats["virtual.exists"]+=1
if mytype == "DEPEND" and \
not is_blocker and \
not inherited_java_eclass and \
- portage.dep_getkey(atom) == "virtual/jdk":
+ atom.cp == "virtual/jdk":
stats['java.eclassesnotused'] += 1
fails['java.eclassesnotused'].append(relative_path)
elif mytype in ("PDEPEND", "RDEPEND"):
if not is_blocker and \
- portage.dep_getkey(atom) in suspect_rdepend:
+ atom.cp in suspect_rdepend:
stats[mytype + '.suspect'] += 1
fails[mytype + '.suspect'].append(
relative_path + ": '%s'" % atom)
# just in case, prevent config.reset() from nuking these.
dep_settings.backup_changes("ACCEPT_KEYWORDS")
- for myprovide in myaux["PROVIDE"].split():
- prov_cp = portage.dep_getkey(myprovide)
+ for prov_cp in provide_cps:
if prov_cp not in dep_settings.getvirtuals():
stats["virtual.unavailable"]+=1
fails["virtual.unavailable"].append("%s: %s(%s) %s" % \
arg_atom = args_set.findAtomForPackage(pkg)
if not arg_atom:
return None
- cp = portage.dep_getkey(arg_atom)
+ cp = arg_atom.cp
new_world_atom = cp
sets = root_config.sets
portdb = root_config.trees["porttree"].dbapi
# can't be safely excluded from world if they are slotted.
system_atom = sets["system"].findAtomForPackage(pkg)
if system_atom:
- if not portage.dep_getkey(system_atom).startswith("virtual/"):
+ if not system_atom.cp.startswith("virtual/"):
return None
# System virtuals aren't safe to exclude from world since they can
# match multiple old-style virtuals but only one of them will be
# pulled in by update or depclean.
- providers = portdb.settings.getvirtuals().get(
- portage.dep_getkey(system_atom))
+ providers = portdb.settings.getvirtuals().get(system_atom.cp)
if providers and len(providers) == 1 and \
- portage.dep_getkey(providers[0]) == cp:
+ providers[0].cp == arg_atom.cp:
return None
return new_world_atom
from portage.const import EPREFIX
_emerge_log_dir = EPREFIX + '/var/log'
+_disable = False
def emergelog(xterm_titles, mystr, short_msg=None):
+ if _disable:
+ return
+
mystr = portage._unicode_decode(mystr)
if short_msg is not None:
action_regen, action_search, action_uninstall, action_info, action_build, \
adjust_configs, chk_updated_cfg_files, display_missing_pkg_set, \
display_news_notification, getportageversion, load_emerge_config
+import _emerge
from _emerge.emergelog import emergelog
from _emerge._flush_elog_mod_echo import _flush_elog_mod_echo
from _emerge.is_valid_package_atom import is_valid_package_atom
operations. This helps minimize parallel emerge.log entries that can
confuse log parsers. We especially want it disabled during
parallel-fetch, which uses --resume --fetchonly."""
- global emergelog
- def emergelog(*pargs, **kargs):
- pass
+ _emerge.emergelog._disable = True
else:
if 'EMERGE_LOG_DIR' in settings:
# misc variables inherited from the calling environment
_environ_filter += [
- "INFOPATH", "MANPATH",
+ "INFOPATH", "MANPATH", "USER",
"HOST", "GROUP", "LOGNAME", "MAIL", "REMOTEHOST",
"SECURITYSESSIONID",
"TERMINFO", "TERM_PROGRAM", "TERM_PROGRAM_VERSION",
if mycp in settings.pmaskdict:
for x in settings.pmaskdict[mycp]:
if match_from_list(x, cpv_slot_list):
- comment = ""
- l = "\n"
- comment_valid = -1
for pmask in pmasklists:
+ comment = ""
+ comment_valid = -1
pmask_filename = os.path.join(pmask[0], "package.mask")
for i in range(len(pmask[1])):
l = pmask[1][i].strip()
remote_metadata = self.remotepkgs[mypkg]
for k, v in remote_metadata.items():
remote_metadata[k] = v.strip()
+
+ # Eliminate metadata values with names that digestCheck
+ # uses, since they are not valid when using the old
+ # protocol. Typically this is needed for SIZE metadata
+ # which corresponds to the size of the unpacked files
+ # rather than the binpkg file size, triggering digest
+ # verification failures as reported in bug #303211.
+ remote_metadata.pop('SIZE', None)
+ for k in portage.checksum.hashfunc_map:
+ remote_metadata.pop(k, None)
+
self._remotepkgs[fullpkg] = remote_metadata
#print " -- Injected"
except SystemExit as e:
return self.treemap[repository_id]
return None
+ def getRepositoryName(self, canonical_repo_path):
+ """
+ This is the inverse of getRepositoryPath().
+ @param canonical_repo_path: the canonical path of a repository, as
+ resolved by os.path.realpath()
+ @type canonical_repo_path: String
+ @returns: The repo_name for the corresponding repository, or None
+ if the path does not correspond a known repository
+ @rtype: String or None
+ """
+ return self._repository_map.get(canonical_repo_path)
+
def getRepositories(self):
"""
This function is required for GLEP 42 compliance; it will return a list of
else:
return 0
- def cp_all(self):
+ def cp_all(self, categories=None):
"returns a list of all keys in our tree"
d = {}
- for x in self.settings.categories:
+ if categories is None:
+ categories = self.settings.categories
+ for x in categories:
for oroot in self.porttrees:
for y in listdir(oroot+"/"+x, EmptyOnError=1, ignorecvs=1, dirsonly=1):
if not self._pkg_dir_name_re.match(y) or \
import re
import xml.dom.minidom
+import portage
from portage import os
from portage import _encodings
from portage import _unicode_decode
self.packages = {}
for p in self.affected.getElementsByTagName("package"):
name = p.getAttribute("name")
+ try:
+ name = portage.dep.Atom(name)
+ except portage.exception.InvalidAtom:
+ raise GlsaFormatException(_("invalid package name: %s") % name)
+ if name != name.cp:
+ raise GlsaFormatException(_("invalid package name: %s") % name)
+ name = name.cp
if name not in self.packages:
self.packages[name] = []
tmp = {}
projects / portage.git / commitdiff