def _visible(self, cpv, metadata):
eapi = metadata["EAPI"]
if not eapi_is_supported(eapi):
return False
if _eapi_is_deprecated(eapi):
return False
if not metadata["SLOT"]:
return False
settings = self.settings
if settings._getMaskAtom(cpv, metadata):
return False
if settings._getMissingKeywords(cpv, metadata):
return False
if settings.local_config:
metadata['CHOST'] = settings.get('CHOST', '')
if not settings._accept_chost(cpv, metadata):
return False
metadata["USE"] = ""
if "?" in metadata["LICENSE"] or \
"?" in metadata["PROPERTIES"]:
self.doebuild_settings.setcpv(cpv, mydb=metadata)
metadata['USE'] = self.doebuild_settings['PORTAGE_USE']
try:
if settings._getMissingLicenses(cpv, metadata):
return False
if settings._getMissingProperties(cpv, metadata):
return False
if settings._getMissingRestrict(cpv, metadata):
return False
except InvalidDependString:
return False
return True
def _visible(self, cpv, metadata):
eapi = metadata["EAPI"]
if not eapi_is_supported(eapi):
return False
if _eapi_is_deprecated(eapi):
return False
if not metadata["SLOT"]:
return False
settings = self.settings
if settings._getMaskAtom(cpv, metadata):
return False
if settings._getMissingKeywords(cpv, metadata):
return False
if settings.local_config:
metadata['CHOST'] = settings.get('CHOST', '')
if not settings._accept_chost(cpv, metadata):
return False
metadata["USE"] = ""
if "?" in metadata["LICENSE"] or \
"?" in metadata["PROPERTIES"]:
self.doebuild_settings.setcpv(cpv, mydb=metadata)
metadata['USE'] = self.doebuild_settings['PORTAGE_USE']
try:
if settings._getMissingLicenses(cpv, metadata):
return False
if settings._getMissingProperties(cpv, metadata):
return False
if settings._getMissingRestrict(cpv, metadata):
return False
except InvalidDependString:
return False
return True
def _eval_masks(self):
masks = {}
settings = self.root_config.settings
if self.invalid is not False:
masks['invalid'] = self.invalid
if not settings._accept_chost(self.cpv, self._metadata):
masks['CHOST'] = self._metadata['CHOST']
eapi = self.eapi
if not portage.eapi_is_supported(eapi):
masks['EAPI.unsupported'] = eapi
if portage._eapi_is_deprecated(eapi):
masks['EAPI.deprecated'] = eapi
missing_keywords = settings._getMissingKeywords(
self.cpv, self._metadata)
if missing_keywords:
masks['KEYWORDS'] = missing_keywords
try:
missing_properties = settings._getMissingProperties(
self.cpv, self._metadata)
if missing_properties:
masks['PROPERTIES'] = missing_properties
except InvalidDependString:
# already recorded as 'invalid'
pass
try:
missing_restricts = settings._getMissingRestrict(
self.cpv, self._metadata)
if missing_restricts:
masks['RESTRICT'] = missing_restricts
except InvalidDependString:
# already recorded as 'invalid'
pass
mask_atom = settings._getMaskAtom(self.cpv, self._metadata)
if mask_atom is not None:
masks['package.mask'] = mask_atom
try:
missing_licenses = settings._getMissingLicenses(
self.cpv, self._metadata)
if missing_licenses:
masks['LICENSE'] = missing_licenses
except InvalidDependString:
# already recorded as 'invalid'
pass
if not masks:
masks = False
return masks
def _eval_masks(self):
masks = {}
settings = self.root_config.settings
if self.invalid is not False:
masks['invalid'] = self.invalid
if not settings._accept_chost(self.cpv, self._metadata):
masks['CHOST'] = self._metadata['CHOST']
eapi = self.eapi
if not portage.eapi_is_supported(eapi):
masks['EAPI.unsupported'] = eapi
if portage._eapi_is_deprecated(eapi):
masks['EAPI.deprecated'] = eapi
missing_keywords = settings._getMissingKeywords(
self.cpv, self._metadata)
if missing_keywords:
masks['KEYWORDS'] = missing_keywords
try:
missing_properties = settings._getMissingProperties(
self.cpv, self._metadata)
if missing_properties:
masks['PROPERTIES'] = missing_properties
except InvalidDependString:
# already recorded as 'invalid'
pass
try:
missing_restricts = settings._getMissingRestrict(
self.cpv, self._metadata)
if missing_restricts:
masks['RESTRICT'] = missing_restricts
except InvalidDependString:
# already recorded as 'invalid'
pass
mask_atom = settings._getMaskAtom(self.cpv, self._metadata)
if mask_atom is not None:
masks['package.mask'] = mask_atom
try:
missing_licenses = settings._getMissingLicenses(
self.cpv, self._metadata)
if missing_licenses:
masks['LICENSE'] = missing_licenses
except InvalidDependString:
# already recorded as 'invalid'
pass
if not masks:
masks = False
return masks
def _masks(self):
masks = {}
settings = self.root_config.settings
if self.invalid is not None:
masks['invalid'] = self.invalid
if not settings._accept_chost(self.cpv, self.metadata):
masks['CHOST'] = self.metadata['CHOST']
eapi = self.metadata["EAPI"]
if not portage.eapi_is_supported(eapi):
masks['EAPI.unsupported'] = eapi
if portage._eapi_is_deprecated(eapi):
masks['EAPI.deprecated'] = eapi
missing_keywords = settings._getMissingKeywords(
self.cpv, self.metadata)
if missing_keywords:
masks['KEYWORDS'] = missing_keywords
try:
missing_properties = settings._getMissingProperties(
self.cpv, self.metadata)
if missing_properties:
masks['PROPERTIES'] = missing_properties
except portage.exception.InvalidDependString:
# already recorded as 'invalid'
pass
mask_atom = settings._getMaskAtom(self.cpv, self.metadata)
if mask_atom is not None:
masks['package.mask'] = mask_atom
system_mask = settings._getProfileMaskAtom(
self.cpv, self.metadata)
if system_mask is not None:
masks['profile.system'] = system_mask
try:
missing_licenses = settings._getMissingLicenses(
self.cpv, self.metadata)
if missing_licenses:
masks['LICENSE'] = missing_licenses
except portage.exception.InvalidDependString:
# already recorded as 'invalid'
pass
if not masks:
masks = None
return masks
def _masks(self):
masks = {}
settings = self.root_config.settings
if self.invalid is not None:
masks['invalid'] = self.invalid
if not settings._accept_chost(self.cpv, self.metadata):
masks['CHOST'] = self.metadata['CHOST']
eapi = self.metadata["EAPI"]
if not portage.eapi_is_supported(eapi):
masks['EAPI.unsupported'] = eapi
if portage._eapi_is_deprecated(eapi):
masks['EAPI.deprecated'] = eapi
missing_keywords = settings._getMissingKeywords(
self.cpv, self.metadata)
if missing_keywords:
masks['KEYWORDS'] = missing_keywords
try:
missing_properties = settings._getMissingProperties(
self.cpv, self.metadata)
if missing_properties:
masks['PROPERTIES'] = missing_properties
except portage.exception.InvalidDependString:
# already recorded as 'invalid'
pass
mask_atom = settings._getMaskAtom(self.cpv, self.metadata)
if mask_atom is not None:
masks['package.mask'] = mask_atom
system_mask = settings._getProfileMaskAtom(self.cpv, self.metadata)
if system_mask is not None:
masks['profile.system'] = system_mask
try:
missing_licenses = settings._getMissingLicenses(
self.cpv, self.metadata)
if missing_licenses:
masks['LICENSE'] = missing_licenses
except portage.exception.InvalidDependString:
# already recorded as 'invalid'
pass
if not masks:
masks = None
return masks
def gvisible(self,mylist):
"strip out group-masked (not in current group) entries"
if mylist is None:
return []
newlist=[]
aux_keys = list(self._aux_cache_keys)
metadata = {}
local_config = self.settings.local_config
chost = self.settings.get('CHOST', '')
accept_chost = self.settings._accept_chost
for mycpv in mylist:
metadata.clear()
try:
metadata.update(zip(aux_keys, self.aux_get(mycpv, aux_keys)))
except KeyError:
continue
except PortageException as e:
writemsg("!!! Error: aux_get('%s', %s)\n" % (mycpv, aux_keys),
noiselevel=-1)
writemsg("!!! %s\n" % (e,), noiselevel=-1)
del e
continue
eapi = metadata["EAPI"]
if not eapi_is_supported(eapi):
continue
if _eapi_is_deprecated(eapi):
continue
if self.settings._getMissingKeywords(mycpv, metadata):
continue
if local_config:
metadata['CHOST'] = chost
if not accept_chost(mycpv, metadata):
continue
metadata["USE"] = ""
if "?" in metadata["LICENSE"] or "?" in metadata["PROPERTIES"]:
self.doebuild_settings.setcpv(mycpv, mydb=metadata)
metadata['USE'] = self.doebuild_settings['PORTAGE_USE']
try:
if self.settings._getMissingLicenses(mycpv, metadata):
continue
if self.settings._getMissingProperties(mycpv, metadata):
continue
except InvalidDependString:
continue
newlist.append(mycpv)
return newlist
def gvisible(self, mylist):
"strip out group-masked (not in current group) entries"
if mylist is None:
return []
newlist = []
aux_keys = list(self._aux_cache_keys)
metadata = {}
local_config = self.settings.local_config
chost = self.settings.get('CHOST', '')
accept_chost = self.settings._accept_chost
for mycpv in mylist:
metadata.clear()
try:
metadata.update(zip(aux_keys, self.aux_get(mycpv, aux_keys)))
except KeyError:
continue
except PortageException as e:
writemsg("!!! Error: aux_get('%s', %s)\n" % (mycpv, aux_keys),
noiselevel=-1)
writemsg("!!! %s\n" % (e, ), noiselevel=-1)
del e
continue
eapi = metadata["EAPI"]
if not eapi_is_supported(eapi):
continue
if _eapi_is_deprecated(eapi):
continue
if self.settings._getMissingKeywords(mycpv, metadata):
continue
if local_config:
metadata['CHOST'] = chost
if not accept_chost(mycpv, metadata):
continue
metadata["USE"] = ""
if "?" in metadata["LICENSE"] or "?" in metadata["PROPERTIES"]:
self.doebuild_settings.setcpv(mycpv, mydb=metadata)
metadata['USE'] = self.doebuild_settings['PORTAGE_USE']
try:
if self.settings._getMissingLicenses(mycpv, metadata):
continue
if self.settings._getMissingProperties(mycpv, metadata):
continue
except InvalidDependString:
continue
newlist.append(mycpv)
return newlist
def _getmaskingstatus(mycpv, settings, portdb, myrepo=None):
metadata = None
installed = False
if not isinstance(mycpv, str):
# emerge passed in a Package instance
pkg = mycpv
mycpv = pkg.cpv
metadata = pkg._metadata
installed = pkg.installed
if metadata is None:
db_keys = list(portdb._aux_cache_keys)
try:
metadata = dict(
zip(db_keys, portdb.aux_get(mycpv, db_keys, myrepo=myrepo)))
except KeyError:
if not portdb.cpv_exists(mycpv):
raise
return [_MaskReason("corruption", "corruption")]
if "?" in metadata["LICENSE"]:
settings.setcpv(mycpv, mydb=metadata)
metadata["USE"] = settings["PORTAGE_USE"]
else:
metadata["USE"] = ""
try:
mycpv.slot
except AttributeError:
try:
mycpv = _pkg_str(mycpv, metadata=metadata, settings=settings)
except portage.exception.InvalidData:
raise ValueError(_("invalid CPV: %s") % mycpv)
rValue = []
# package.mask checking
if settings._getMaskAtom(mycpv, metadata):
rValue.append(
_MaskReason("package.mask", "package.mask",
_UnmaskHint("p_mask", None)))
# keywords checking
eapi = metadata["EAPI"]
mygroups = settings._getKeywords(mycpv, metadata)
licenses = metadata["LICENSE"]
properties = metadata["PROPERTIES"]
restrict = metadata["RESTRICT"]
if not eapi_is_supported(eapi):
return [_MaskReason("EAPI", "EAPI %s" % eapi)]
if _eapi_is_deprecated(eapi) and not installed:
return [_MaskReason("EAPI", "EAPI %s" % eapi)]
egroups = settings.configdict["backupenv"].get("ACCEPT_KEYWORDS",
"").split()
global_accept_keywords = settings.get("ACCEPT_KEYWORDS", "")
pgroups = global_accept_keywords.split()
myarch = settings["ARCH"]
if pgroups and myarch not in pgroups:
"""For operating systems other than Linux, ARCH is not necessarily a
valid keyword."""
myarch = pgroups[0].lstrip("~")
# NOTE: This logic is copied from KeywordsManager.getMissingKeywords().
unmaskgroups = settings._keywords_manager.getPKeywords(
mycpv, metadata["SLOT"], metadata["repository"],
global_accept_keywords)
pgroups.extend(unmaskgroups)
if unmaskgroups or egroups:
pgroups = settings._keywords_manager._getEgroups(egroups, pgroups)
else:
pgroups = set(pgroups)
kmask = "missing"
kmask_hint = None
if '**' in pgroups:
kmask = None
else:
for keyword in pgroups:
if keyword in mygroups:
kmask = None
break
if kmask:
for gp in mygroups:
if gp == "*":
kmask = None
break
elif gp == "~*":
for x in pgroups:
if x[:1] == "~":
kmask = None
break
if kmask is None:
break
elif gp == "-" + myarch and myarch in pgroups:
kmask = "-" + myarch
break
elif gp == "~" + myarch and myarch in pgroups:
kmask = "~" + myarch
kmask_hint = _UnmaskHint("unstable keyword", kmask)
break
if kmask == "missing":
kmask_hint = _UnmaskHint("unstable keyword", "**")
try:
missing_licenses = settings._getMissingLicenses(mycpv, metadata)
if missing_licenses:
allowed_tokens = set(["||", "(", ")"])
allowed_tokens.update(missing_licenses)
license_split = licenses.split()
license_split = [x for x in license_split \
if x in allowed_tokens]
msg = license_split[:]
msg.append("license(s)")
rValue.append(
_MaskReason("LICENSE", " ".join(msg),
_UnmaskHint("license", set(missing_licenses))))
except portage.exception.InvalidDependString as e:
rValue.append(_MaskReason("invalid", "LICENSE: " + str(e)))
try:
missing_properties = settings._getMissingProperties(mycpv, metadata)
if missing_properties:
allowed_tokens = set(["||", "(", ")"])
allowed_tokens.update(missing_properties)
properties_split = properties.split()
properties_split = [x for x in properties_split \
if x in allowed_tokens]
msg = properties_split[:]
msg.append("properties")
rValue.append(_MaskReason("PROPERTIES", " ".join(msg)))
except portage.exception.InvalidDependString as e:
rValue.append(_MaskReason("invalid", "PROPERTIES: " + str(e)))
try:
missing_restricts = settings._getMissingRestrict(mycpv, metadata)
if missing_restricts:
msg = list(missing_restricts)
msg.append("in RESTRICT")
rValue.append(_MaskReason("RESTRICT", " ".join(msg)))
except InvalidDependString as e:
rValue.append(_MaskReason("invalid", "RESTRICT: %s" % (e, )))
# Only show KEYWORDS masks for installed packages
# if they're not masked for any other reason.
if kmask and (not installed or not rValue):
rValue.append(
_MaskReason("KEYWORDS", kmask + " keyword",
unmask_hint=kmask_hint))
return rValue
def _getmaskingstatus(mycpv, settings, portdb, myrepo=None):
metadata = None
installed = False
if not isinstance(mycpv, basestring):
# emerge passed in a Package instance
pkg = mycpv
mycpv = pkg.cpv
metadata = pkg._metadata
installed = pkg.installed
if metadata is None:
db_keys = list(portdb._aux_cache_keys)
try:
metadata = dict(zip(db_keys, portdb.aux_get(mycpv, db_keys, myrepo=myrepo)))
except KeyError:
if not portdb.cpv_exists(mycpv):
raise
return [_MaskReason("corruption", "corruption")]
if "?" in metadata["LICENSE"]:
settings.setcpv(mycpv, mydb=metadata)
metadata["USE"] = settings["PORTAGE_USE"]
else:
metadata["USE"] = ""
try:
mycpv.slot
except AttributeError:
try:
mycpv = _pkg_str(mycpv, metadata=metadata, settings=settings)
except portage.exception.InvalidData:
raise ValueError(_("invalid CPV: %s") % mycpv)
rValue = []
# package.mask checking
if settings._getMaskAtom(mycpv, metadata):
rValue.append(_MaskReason("package.mask", "package.mask", _UnmaskHint("p_mask", None)))
# keywords checking
eapi = metadata["EAPI"]
mygroups = settings._getKeywords(mycpv, metadata)
licenses = metadata["LICENSE"]
properties = metadata["PROPERTIES"]
restrict = metadata["RESTRICT"]
if not eapi_is_supported(eapi):
return [_MaskReason("EAPI", "EAPI %s" % eapi)]
elif _eapi_is_deprecated(eapi) and not installed:
return [_MaskReason("EAPI", "EAPI %s" % eapi)]
egroups = settings.configdict["backupenv"].get(
"ACCEPT_KEYWORDS", "").split()
global_accept_keywords = settings.get("ACCEPT_KEYWORDS", "")
pgroups = global_accept_keywords.split()
myarch = settings["ARCH"]
if pgroups and myarch not in pgroups:
"""For operating systems other than Linux, ARCH is not necessarily a
valid keyword."""
myarch = pgroups[0].lstrip("~")
# NOTE: This logic is copied from KeywordsManager.getMissingKeywords().
unmaskgroups = settings._keywords_manager.getPKeywords(mycpv,
metadata["SLOT"], metadata["repository"], global_accept_keywords)
pgroups.extend(unmaskgroups)
if unmaskgroups or egroups:
pgroups = settings._keywords_manager._getEgroups(egroups, pgroups)
else:
pgroups = set(pgroups)
kmask = "missing"
kmask_hint = None
if '**' in pgroups:
kmask = None
else:
for keyword in pgroups:
if keyword in mygroups:
kmask = None
break
if kmask:
for gp in mygroups:
if gp=="*":
kmask=None
break
elif gp == "~*":
for x in pgroups:
if x[:1] == "~":
kmask = None
break
if kmask is None:
break
elif gp=="-"+myarch and myarch in pgroups:
kmask="-"+myarch
break
elif gp=="~"+myarch and myarch in pgroups:
kmask="~"+myarch
kmask_hint = _UnmaskHint("unstable keyword", kmask)
break
if kmask == "missing":
kmask_hint = _UnmaskHint("unstable keyword", "**")
try:
missing_licenses = settings._getMissingLicenses(mycpv, metadata)
if missing_licenses:
allowed_tokens = set(["||", "(", ")"])
allowed_tokens.update(missing_licenses)
license_split = licenses.split()
license_split = [x for x in license_split \
if x in allowed_tokens]
msg = license_split[:]
msg.append("license(s)")
rValue.append(_MaskReason("LICENSE", " ".join(msg), _UnmaskHint("license", set(missing_licenses))))
except portage.exception.InvalidDependString as e:
rValue.append(_MaskReason("invalid", "LICENSE: "+str(e)))
try:
missing_properties = settings._getMissingProperties(mycpv, metadata)
if missing_properties:
allowed_tokens = set(["||", "(", ")"])
allowed_tokens.update(missing_properties)
properties_split = properties.split()
properties_split = [x for x in properties_split \
if x in allowed_tokens]
msg = properties_split[:]
msg.append("properties")
rValue.append(_MaskReason("PROPERTIES", " ".join(msg)))
except portage.exception.InvalidDependString as e:
rValue.append(_MaskReason("invalid", "PROPERTIES: "+str(e)))
try:
missing_restricts = settings._getMissingRestrict(mycpv, metadata)
if missing_restricts:
msg = list(missing_restricts)
msg.append("in RESTRICT")
rValue.append(_MaskReason("RESTRICT", " ".join(msg)))
except InvalidDependString as e:
rValue.append(_MaskReason("invalid", "RESTRICT: %s" % (e,)))
# Only show KEYWORDS masks for installed packages
# if they're not masked for any other reason.
if kmask and (not installed or not rValue):
rValue.append(_MaskReason("KEYWORDS",
kmask + " keyword", unmask_hint=kmask_hint))
return rValue
def getmaskingstatus(mycpv, settings=None, portdb=None):
if settings is None:
settings = config(clone=portage.settings)
if portdb is None:
portdb = portage.portdb
metadata = None
installed = False
if not isinstance(mycpv, basestring):
# emerge passed in a Package instance
pkg = mycpv
mycpv = pkg.cpv
metadata = pkg.metadata
installed = pkg.installed
mysplit = catpkgsplit(mycpv)
if not mysplit:
raise ValueError(_("invalid CPV: %s") % mycpv)
if metadata is None:
db_keys = list(portdb._aux_cache_keys)
try:
metadata = dict(zip(db_keys, portdb.aux_get(mycpv, db_keys)))
except KeyError:
if not portdb.cpv_exists(mycpv):
raise
return ["corruption"]
if "?" in metadata["LICENSE"]:
settings.setcpv(mycpv, mydb=metadata)
metadata["USE"] = settings["PORTAGE_USE"]
else:
metadata["USE"] = ""
rValue = []
# profile checking
if settings._getProfileMaskAtom(mycpv, metadata):
rValue.append("profile")
# package.mask checking
if settings._getMaskAtom(mycpv, metadata):
rValue.append("package.mask")
# keywords checking
eapi = metadata["EAPI"]
mygroups = settings._getKeywords(mycpv, metadata)
licenses = metadata["LICENSE"]
properties = metadata["PROPERTIES"]
if eapi.startswith("-"):
eapi = eapi[1:]
if not eapi_is_supported(eapi):
return ["EAPI %s" % eapi]
elif _eapi_is_deprecated(eapi) and not installed:
return ["EAPI %s" % eapi]
egroups = settings.configdict["backupenv"].get("ACCEPT_KEYWORDS",
"").split()
pgroups = settings["ACCEPT_KEYWORDS"].split()
myarch = settings["ARCH"]
if pgroups and myarch not in pgroups:
"""For operating systems other than Linux, ARCH is not necessarily a
valid keyword."""
myarch = pgroups[0].lstrip("~")
cp = cpv_getkey(mycpv)
pkgdict = settings.pkeywordsdict.get(cp)
matches = False
if pkgdict:
cpv_slot_list = ["%s:%s" % (mycpv, metadata["SLOT"])]
for atom, pkgkeywords in pkgdict.items():
if match_from_list(atom, cpv_slot_list):
matches = True
pgroups.extend(pkgkeywords)
if matches or egroups:
pgroups.extend(egroups)
inc_pgroups = set()
for x in pgroups:
if x.startswith("-"):
if x == "-*":
inc_pgroups.clear()
else:
inc_pgroups.discard(x[1:])
else:
inc_pgroups.add(x)
pgroups = inc_pgroups
del inc_pgroups
kmask = "missing"
if '**' in pgroups:
kmask = None
else:
for keyword in pgroups:
if keyword in mygroups:
kmask = None
break
if kmask:
for gp in mygroups:
if gp == "*":
kmask = None
break
elif gp == "-" + myarch and myarch in pgroups:
kmask = "-" + myarch
break
elif gp == "~" + myarch and myarch in pgroups:
kmask = "~" + myarch
break
try:
missing_licenses = settings._getMissingLicenses(mycpv, metadata)
if missing_licenses:
allowed_tokens = set(["||", "(", ")"])
allowed_tokens.update(missing_licenses)
license_split = licenses.split()
license_split = [x for x in license_split \
if x in allowed_tokens]
msg = license_split[:]
msg.append("license(s)")
rValue.append(" ".join(msg))
except portage.exception.InvalidDependString as e:
rValue.append("LICENSE: " + str(e))
try:
missing_properties = settings._getMissingProperties(mycpv, metadata)
if missing_properties:
allowed_tokens = set(["||", "(", ")"])
allowed_tokens.update(missing_properties)
properties_split = properties.split()
properties_split = [x for x in properties_split \
if x in allowed_tokens]
msg = properties_split[:]
msg.append("properties")
rValue.append(" ".join(msg))
except portage.exception.InvalidDependString as e:
rValue.append("PROPERTIES: " + str(e))
# Only show KEYWORDS masks for installed packages
# if they're not masked for any other reason.
if kmask and (not installed or not rValue):
rValue.append(kmask + " keyword")
return rValue
def getmaskingstatus(mycpv, settings=None, portdb=None):
if settings is None:
settings = config(clone=portage.settings)
if portdb is None:
portdb = portage.portdb
metadata = None
installed = False
if not isinstance(mycpv, basestring):
# emerge passed in a Package instance
pkg = mycpv
mycpv = pkg.cpv
metadata = pkg.metadata
installed = pkg.installed
mysplit = catpkgsplit(mycpv)
if not mysplit:
raise ValueError(_("invalid CPV: %s") % mycpv)
if metadata is None:
db_keys = list(portdb._aux_cache_keys)
try:
metadata = dict(zip(db_keys, portdb.aux_get(mycpv, db_keys)))
except KeyError:
if not portdb.cpv_exists(mycpv):
raise
return ["corruption"]
if "?" in metadata["LICENSE"]:
settings.setcpv(mycpv, mydb=metadata)
metadata["USE"] = settings["PORTAGE_USE"]
else:
metadata["USE"] = ""
rValue = []
# profile checking
if settings._getProfileMaskAtom(mycpv, metadata):
rValue.append("profile")
# package.mask checking
if settings._getMaskAtom(mycpv, metadata):
rValue.append("package.mask")
# keywords checking
eapi = metadata["EAPI"]
mygroups = settings._getKeywords(mycpv, metadata)
licenses = metadata["LICENSE"]
properties = metadata["PROPERTIES"]
if eapi.startswith("-"):
eapi = eapi[1:]
if not eapi_is_supported(eapi):
return ["EAPI %s" % eapi]
elif _eapi_is_deprecated(eapi) and not installed:
return ["EAPI %s" % eapi]
egroups = settings.configdict["backupenv"].get(
"ACCEPT_KEYWORDS", "").split()
pgroups = settings["ACCEPT_KEYWORDS"].split()
myarch = settings["ARCH"]
if pgroups and myarch not in pgroups:
"""For operating systems other than Linux, ARCH is not necessarily a
valid keyword."""
myarch = pgroups[0].lstrip("~")
cp = cpv_getkey(mycpv)
pkgdict = settings.pkeywordsdict.get(cp)
matches = False
if pkgdict:
cpv_slot_list = ["%s:%s" % (mycpv, metadata["SLOT"])]
for atom, pkgkeywords in pkgdict.items():
if match_from_list(atom, cpv_slot_list):
matches = True
pgroups.extend(pkgkeywords)
if matches or egroups:
pgroups.extend(egroups)
inc_pgroups = set()
for x in pgroups:
if x.startswith("-"):
if x == "-*":
inc_pgroups.clear()
else:
inc_pgroups.discard(x[1:])
else:
inc_pgroups.add(x)
pgroups = inc_pgroups
del inc_pgroups
kmask = "missing"
if '**' in pgroups:
kmask = None
else:
for keyword in pgroups:
if keyword in mygroups:
kmask = None
break
if kmask:
for gp in mygroups:
if gp=="*":
kmask=None
break
elif gp=="-"+myarch and myarch in pgroups:
kmask="-"+myarch
break
elif gp=="~"+myarch and myarch in pgroups:
kmask="~"+myarch
break
try:
missing_licenses = settings._getMissingLicenses(mycpv, metadata)
if missing_licenses:
allowed_tokens = set(["||", "(", ")"])
allowed_tokens.update(missing_licenses)
license_split = licenses.split()
license_split = [x for x in license_split \
if x in allowed_tokens]
msg = license_split[:]
msg.append("license(s)")
rValue.append(" ".join(msg))
except portage.exception.InvalidDependString as e:
rValue.append("LICENSE: "+str(e))
try:
missing_properties = settings._getMissingProperties(mycpv, metadata)
if missing_properties:
allowed_tokens = set(["||", "(", ")"])
allowed_tokens.update(missing_properties)
properties_split = properties.split()
properties_split = [x for x in properties_split \
if x in allowed_tokens]
msg = properties_split[:]
msg.append("properties")
rValue.append(" ".join(msg))
except portage.exception.InvalidDependString as e:
rValue.append("PROPERTIES: "+str(e))
# Only show KEYWORDS masks for installed packages
# if they're not masked for any other reason.
if kmask and (not installed or not rValue):
rValue.append(kmask+" keyword")
return rValue
def _eval_masks(self):
masks = {}
settings = self.root_config.settings
if self.invalid is not False:
masks['invalid'] = self.invalid
if not settings._accept_chost(self.cpv, self._metadata):
masks['CHOST'] = self._metadata['CHOST']
eapi = self.eapi
if not portage.eapi_is_supported(eapi):
masks['EAPI.unsupported'] = eapi
if portage._eapi_is_deprecated(eapi):
masks['EAPI.deprecated'] = eapi
missing_keywords = settings._getMissingKeywords(
self.cpv, self._metadata)
if missing_keywords:
masks['KEYWORDS'] = missing_keywords
if self.built and not self.installed:
# we can have an old binary which has no EPREFIX information
if "EPREFIX" not in self.metadata:
masks['EPREFIX.missing'] = ''
if len(self.metadata["EPREFIX"].strip()) < len(EPREFIX):
masks['EPREFIX.tooshort'] = self.metadata["EPREFIX"].strip()
try:
missing_properties = settings._getMissingProperties(
self.cpv, self._metadata)
if missing_properties:
masks['PROPERTIES'] = missing_properties
except InvalidDependString:
# already recorded as 'invalid'
pass
try:
missing_restricts = settings._getMissingRestrict(
self.cpv, self._metadata)
if missing_restricts:
masks['RESTRICT'] = missing_restricts
except InvalidDependString:
# already recorded as 'invalid'
pass
mask_atom = settings._getMaskAtom(self.cpv, self._metadata)
if mask_atom is not None:
masks['package.mask'] = mask_atom
try:
missing_licenses = settings._getMissingLicenses(
self.cpv, self._metadata)
if missing_licenses:
masks['LICENSE'] = missing_licenses
except InvalidDependString:
# already recorded as 'invalid'
pass
if not masks:
masks = False
return masks
