def _aux_get_wrapper(self, pkg, wants, myrepo=None):
if pkg in self._aux_get_history:
return self._aux_get(pkg, wants)
self._aux_get_history.add(pkg)
# We need to check the EAPI, and this also raises
# a KeyError to the caller if appropriate.
pkg_obj = self.dbapi._cpv_map[pkg]
installed_eapi = pkg_obj.metadata['EAPI']
repo = pkg_obj.metadata['repository']
eapi_attrs = _get_eapi_attrs(installed_eapi)
built_slot_operator_atoms = None
if eapi_attrs.slot_operator and not self._ignore_built_slot_operator_deps:
try:
built_slot_operator_atoms = find_built_slot_operator_atoms(
pkg_obj)
except InvalidDependString:
pass
try:
# Use the live ebuild metadata if possible.
repo = _gen_valid_repo(repo)
live_metadata = dict(
zip(self._portdb_keys,
self._portdb.aux_get(pkg, self._portdb_keys, myrepo=repo)))
# Use the metadata from the installed instance if the EAPI
# of either instance is unsupported, since if the installed
# instance has an unsupported or corrupt EAPI then we don't
# want to attempt to do complex operations such as execute
# pkg_config, pkg_prerm or pkg_postrm phases. If both EAPIs
# are supported then go ahead and use the live_metadata, in
# order to respect dep updates without revision bump or EAPI
# bump, as in bug #368725.
if not (portage.eapi_is_supported(live_metadata["EAPI"]) and \
portage.eapi_is_supported(installed_eapi)):
raise KeyError(pkg)
# preserve built slot/sub-slot := operator deps
if built_slot_operator_atoms:
live_eapi_attrs = _get_eapi_attrs(live_metadata["EAPI"])
if not live_eapi_attrs.slot_operator:
raise KeyError(pkg)
for k, v in built_slot_operator_atoms.items():
live_metadata[k] += (
" " + " ".join(_unicode(atom) for atom in v))
self.dbapi.aux_update(pkg, live_metadata)
except (KeyError, portage.exception.PortageException):
if self._global_updates is None:
self._global_updates = \
grab_global_updates(self._portdb)
perform_global_updates(pkg, self.dbapi, self._global_updates)
return self._aux_get(pkg, wants)
def _aux_get_wrapper(self, pkg, wants, myrepo=None):
if pkg in self._aux_get_history:
return self._aux_get(pkg, wants)
self._aux_get_history.add(pkg)
# We need to check the EAPI, and this also raises
# a KeyError to the caller if appropriate.
pkg_obj = self.dbapi._cpv_map[pkg]
installed_eapi = pkg_obj.metadata['EAPI']
repo = pkg_obj.metadata['repository']
eapi_attrs = _get_eapi_attrs(installed_eapi)
built_slot_operator_atoms = None
if eapi_attrs.slot_operator and not self._ignore_built_slot_operator_deps:
try:
built_slot_operator_atoms = find_built_slot_operator_atoms(pkg_obj)
except InvalidDependString:
pass
try:
# Use the live ebuild metadata if possible.
repo = _gen_valid_repo(repo)
live_metadata = dict(zip(self._portdb_keys,
self._portdb.aux_get(pkg, self._portdb_keys, myrepo=repo)))
# Use the metadata from the installed instance if the EAPI
# of either instance is unsupported, since if the installed
# instance has an unsupported or corrupt EAPI then we don't
# want to attempt to do complex operations such as execute
# pkg_config, pkg_prerm or pkg_postrm phases. If both EAPIs
# are supported then go ahead and use the live_metadata, in
# order to respect dep updates without revision bump or EAPI
# bump, as in bug #368725.
if not (portage.eapi_is_supported(live_metadata["EAPI"]) and \
portage.eapi_is_supported(installed_eapi)):
raise KeyError(pkg)
# preserve built slot/sub-slot := operator deps
if built_slot_operator_atoms:
live_eapi_attrs = _get_eapi_attrs(live_metadata["EAPI"])
if not live_eapi_attrs.slot_operator:
raise KeyError(pkg)
for k, v in built_slot_operator_atoms.items():
live_metadata[k] += (" " +
" ".join(_unicode(atom) for atom in v))
self.dbapi.aux_update(pkg, live_metadata)
except (KeyError, portage.exception.PortageException):
if self._global_updates is None:
self._global_updates = \
grab_global_updates(self._portdb)
perform_global_updates(
pkg, self.dbapi, self._global_updates)
return self._aux_get(pkg, wants)
def __init__(self, **kwargs):
metadata = _PackageMetadataWrapperBase(kwargs.pop('metadata'))
Task.__init__(self, **kwargs)
# the SlotObject constructor assigns self.root_config from keyword args
# and is an instance of a '_emerge.RootConfig.RootConfig class
self.root = self.root_config.root
self._raw_metadata = metadata
self._metadata = _PackageMetadataWrapper(self, metadata)
if not self.built:
self._metadata['CHOST'] = self.root_config.settings.get(
'CHOST', '')
eapi_attrs = _get_eapi_attrs(self.eapi)
self.cpv = _pkg_str(self.cpv,
metadata=self._metadata,
settings=self.root_config.settings)
if hasattr(self.cpv, 'slot_invalid'):
self._invalid_metadata(
'SLOT.invalid',
"SLOT: invalid value: '%s'" % self._metadata["SLOT"])
self.cpv_split = self.cpv.cpv_split
self.category, self.pf = portage.catsplit(self.cpv)
self.cp = self.cpv.cp
self.version = self.cpv.version
self.slot = self.cpv.slot
self.sub_slot = self.cpv.sub_slot
self.slot_atom = Atom("%s%s%s" % (self.cp, _slot_separator, self.slot))
# sync metadata with validated repo (may be UNKNOWN_REPO)
self._metadata['repository'] = self.cpv.repo
if eapi_attrs.iuse_effective:
implicit_match = self.root_config.settings._iuse_effective_match
else:
implicit_match = self.root_config.settings._iuse_implicit_match
usealiases = self.root_config.settings._use_manager.getUseAliases(self)
self.iuse = self._iuse(self, self._metadata["IUSE"].split(),
implicit_match, usealiases, self.eapi)
if (self.iuse.enabled or self.iuse.disabled) and \
not eapi_attrs.iuse_defaults:
if not self.installed:
self._invalid_metadata(
'EAPI.incompatible',
"IUSE contains defaults, but EAPI doesn't allow them")
if self.inherited is None:
self.inherited = frozenset()
if self.operation is None:
if self.onlydeps or self.installed:
self.operation = "nomerge"
else:
self.operation = "merge"
self._hash_key = Package._gen_hash_key(cpv=self.cpv,
installed=self.installed,
onlydeps=self.onlydeps,
operation=self.operation,
repo_name=self.cpv.repo,
root_config=self.root_config,
type_name=self.type_name)
self._hash_value = hash(self._hash_key)
def __init__(self, cpv, metadata=None, settings=None, eapi=None,
repo=None, slot=None, build_time=None, build_id=None,
file_size=None, mtime=None):
if not isinstance(cpv, _unicode):
# Avoid TypeError from _unicode.__init__ with PyPy.
cpv = _unicode_decode(cpv)
_unicode.__init__(cpv)
if metadata is not None:
self.__dict__['_metadata'] = metadata
slot = metadata.get('SLOT', slot)
repo = metadata.get('repository', repo)
eapi = metadata.get('EAPI', eapi)
build_time = metadata.get('BUILD_TIME', build_time)
file_size = metadata.get('SIZE', file_size)
build_id = metadata.get('BUILD_ID', build_id)
mtime = metadata.get('_mtime_', mtime)
if settings is not None:
self.__dict__['_settings'] = settings
if eapi is not None:
self.__dict__['eapi'] = eapi
self.__dict__['build_time'] = self._long(build_time, 0)
self.__dict__['file_size'] = self._long(file_size, None)
self.__dict__['build_id'] = self._long(build_id, None)
self.__dict__['mtime'] = self._long(mtime, None)
self.__dict__['cpv_split'] = catpkgsplit(cpv, eapi=eapi)
if self.cpv_split is None:
raise InvalidData(cpv)
self.__dict__['cp'] = self.cpv_split[0] + '/' + self.cpv_split[1]
if self.cpv_split[-1] == "r0" and cpv[-3:] != "-r0":
self.__dict__['version'] = "-".join(self.cpv_split[2:-1])
else:
self.__dict__['version'] = "-".join(self.cpv_split[2:])
# for match_from_list introspection
self.__dict__['cpv'] = self
if slot is not None:
eapi_attrs = _get_eapi_attrs(eapi)
slot_match = _get_slot_re(eapi_attrs).match(slot)
if slot_match is None:
# Avoid an InvalidAtom exception when creating SLOT atoms
self.__dict__['slot'] = '0'
self.__dict__['sub_slot'] = '0'
self.__dict__['slot_invalid'] = slot
else:
if eapi_attrs.slot_operator:
slot_split = slot.split("/")
self.__dict__['slot'] = slot_split[0]
if len(slot_split) > 1:
self.__dict__['sub_slot'] = slot_split[1]
else:
self.__dict__['sub_slot'] = slot_split[0]
else:
self.__dict__['slot'] = slot
self.__dict__['sub_slot'] = slot
if repo is not None:
repo = _gen_valid_repo(repo)
if not repo:
repo = _unknown_repo
self.__dict__['repo'] = repo
def evaluate_slot_operator_equal_deps(settings, use, trees):
metadata = settings.configdict['pkg']
eapi = metadata['EAPI']
eapi_attrs = _get_eapi_attrs(eapi)
running_vardb = trees[trees._running_eroot]["vartree"].dbapi
target_vardb = trees[trees._target_eroot]["vartree"].dbapi
vardbs = [target_vardb]
deps = {}
for k in Package._dep_keys:
deps[k] = use_reduce(metadata[k],
uselist=use, eapi=eapi, token_class=Atom)
for k in Package._runtime_keys:
_eval_deps(deps[k], vardbs)
if eapi_attrs.bdepend:
_eval_deps(deps["BDEPEND"], [running_vardb])
_eval_deps(deps["DEPEND"], [target_vardb])
else:
if running_vardb is not target_vardb:
vardbs.append(running_vardb)
_eval_deps(deps["DEPEND"], vardbs)
result = {}
for k, v in deps.items():
result[k] = paren_enclose(v)
return result
def _apply_dynamic_deps(self, pkg, live_metadata):
try:
if live_metadata is None:
raise _DynamicDepsNotApplicable()
# Use the metadata from the installed instance if the EAPI
# of either instance is unsupported, since if the installed
# instance has an unsupported or corrupt EAPI then we don't
# want to attempt to do complex operations such as execute
# pkg_config, pkg_prerm or pkg_postrm phases. If both EAPIs
# are supported then go ahead and use the live_metadata, in
# order to respect dep updates without revision bump or EAPI
# bump, as in bug #368725.
if not (portage.eapi_is_supported(live_metadata["EAPI"]) and \
portage.eapi_is_supported(pkg.eapi)):
raise _DynamicDepsNotApplicable()
# preserve built slot/sub-slot := operator deps
built_slot_operator_atoms = None
if not self._ignore_built_slot_operator_deps and \
_get_eapi_attrs(pkg.eapi).slot_operator:
try:
built_slot_operator_atoms = \
find_built_slot_operator_atoms(pkg)
except InvalidDependString:
pass
if built_slot_operator_atoms:
live_eapi_attrs = _get_eapi_attrs(live_metadata["EAPI"])
if not live_eapi_attrs.slot_operator:
raise _DynamicDepsNotApplicable()
for k, v in built_slot_operator_atoms.items():
live_metadata[k] += (" " +
" ".join(_unicode(atom) for atom in v))
self.dbapi.aux_update(pkg.cpv, live_metadata)
except _DynamicDepsNotApplicable:
if self._global_updates is None:
self._global_updates = \
grab_global_updates(self._portdb)
# Bypass _aux_get_wrapper, since calling that
# here would trigger infinite recursion.
aux_keys = Package._dep_keys + self.dbapi._pkg_str_aux_keys
aux_dict = dict(zip(aux_keys, self._aux_get(pkg.cpv, aux_keys)))
perform_global_updates(
pkg.cpv, aux_dict, self.dbapi, self._global_updates)
def _apply_dynamic_deps(self, pkg, live_metadata):
try:
if live_metadata is None:
raise _DynamicDepsNotApplicable()
# Use the metadata from the installed instance if the EAPI
# of either instance is unsupported, since if the installed
# instance has an unsupported or corrupt EAPI then we don't
# want to attempt to do complex operations such as execute
# pkg_config, pkg_prerm or pkg_postrm phases. If both EAPIs
# are supported then go ahead and use the live_metadata, in
# order to respect dep updates without revision bump or EAPI
# bump, as in bug #368725.
if not (portage.eapi_is_supported(live_metadata["EAPI"]) and \
portage.eapi_is_supported(pkg.eapi)):
raise _DynamicDepsNotApplicable()
# preserve built slot/sub-slot := operator deps
built_slot_operator_atoms = None
if not self._ignore_built_slot_operator_deps and \
_get_eapi_attrs(pkg.eapi).slot_operator:
try:
built_slot_operator_atoms = \
find_built_slot_operator_atoms(pkg)
except InvalidDependString:
pass
if built_slot_operator_atoms:
live_eapi_attrs = _get_eapi_attrs(live_metadata["EAPI"])
if not live_eapi_attrs.slot_operator:
raise _DynamicDepsNotApplicable()
for k, v in built_slot_operator_atoms.items():
live_metadata[k] += (" " +
" ".join(_unicode(atom) for atom in v))
self.dbapi.aux_update(pkg.cpv, live_metadata)
except _DynamicDepsNotApplicable:
if self._global_updates is None:
self._global_updates = \
grab_global_updates(self._portdb)
# Bypass _aux_get_wrapper, since calling that
# here would trigger infinite recursion.
aux_keys = Package._dep_keys + self.dbapi._pkg_str_aux_keys
aux_dict = dict(zip(aux_keys, self._aux_get(pkg.cpv, aux_keys)))
perform_global_updates(
pkg.cpv, aux_dict, self.dbapi, self._global_updates)
def __init__(self, **kwargs):
metadata = _PackageMetadataWrapperBase(kwargs.pop('metadata'))
Task.__init__(self, **kwargs)
# the SlotObject constructor assigns self.root_config from keyword args
# and is an instance of a '_emerge.RootConfig.RootConfig class
self.root = self.root_config.root
self._raw_metadata = metadata
self._metadata = _PackageMetadataWrapper(self, metadata)
if not self.built:
self._metadata['CHOST'] = self.root_config.settings.get('CHOST', '')
eapi_attrs = _get_eapi_attrs(self.eapi)
self.cpv = _pkg_str(self.cpv, metadata=self._metadata,
settings=self.root_config.settings)
if hasattr(self.cpv, 'slot_invalid'):
self._invalid_metadata('SLOT.invalid',
"SLOT: invalid value: '%s'" % self._metadata["SLOT"])
self.cpv_split = self.cpv.cpv_split
self.category, self.pf = portage.catsplit(self.cpv)
self.cp = self.cpv.cp
self.version = self.cpv.version
self.slot = self.cpv.slot
self.sub_slot = self.cpv.sub_slot
self.slot_atom = Atom("%s%s%s" % (self.cp, _slot_separator, self.slot))
# sync metadata with validated repo (may be UNKNOWN_REPO)
self._metadata['repository'] = self.cpv.repo
if eapi_attrs.iuse_effective:
implicit_match = self.root_config.settings._iuse_effective_match
if self.built:
implicit_match = functools.partial(
self._built_iuse_effective_match,
implicit_match, frozenset(self._metadata['USE'].split()))
else:
implicit_match = self.root_config.settings._iuse_implicit_match
usealiases = self.root_config.settings._use_manager.getUseAliases(self)
self.iuse = self._iuse(self, self._metadata["IUSE"].split(), implicit_match,
usealiases, self.eapi)
if (self.iuse.enabled or self.iuse.disabled) and \
not eapi_attrs.iuse_defaults:
if not self.installed:
self._invalid_metadata('EAPI.incompatible',
"IUSE contains defaults, but EAPI doesn't allow them")
if self.inherited is None:
self.inherited = frozenset()
if self.operation is None:
if self.onlydeps or self.installed:
self.operation = "nomerge"
else:
self.operation = "merge"
self._hash_key = Package._gen_hash_key(cpv=self.cpv,
installed=self.installed, onlydeps=self.onlydeps,
operation=self.operation, repo_name=self.cpv.repo,
root_config=self.root_config,
type_name=self.type_name)
self._hash_value = hash(self._hash_key)
def __init__(self,
cpv,
metadata=None,
settings=None,
eapi=None,
repo=None,
slot=None):
if not isinstance(cpv, _unicode):
# Avoid TypeError from _unicode.__init__ with PyPy.
cpv = _unicode_decode(cpv)
_unicode.__init__(cpv)
if metadata is not None:
self.__dict__['_metadata'] = metadata
slot = metadata.get('SLOT', slot)
repo = metadata.get('repository', repo)
eapi = metadata.get('EAPI', eapi)
if settings is not None:
self.__dict__['_settings'] = settings
if eapi is not None:
self.__dict__['eapi'] = eapi
self.__dict__['cpv_split'] = catpkgsplit(cpv, eapi=eapi)
if self.cpv_split is None:
raise InvalidData(cpv)
self.__dict__['cp'] = self.cpv_split[0] + '/' + self.cpv_split[1]
if self.cpv_split[-1] == "r0" and cpv[-3:] != "-r0":
self.__dict__['version'] = "-".join(self.cpv_split[2:-1])
else:
self.__dict__['version'] = "-".join(self.cpv_split[2:])
# for match_from_list introspection
self.__dict__['cpv'] = self
if slot is not None:
eapi_attrs = _get_eapi_attrs(eapi)
slot_match = _get_slot_re(eapi_attrs).match(slot)
if slot_match is None:
# Avoid an InvalidAtom exception when creating SLOT atoms
self.__dict__['slot'] = '0'
self.__dict__['sub_slot'] = '0'
self.__dict__['slot_invalid'] = slot
else:
if eapi_attrs.slot_operator:
slot_split = slot.split("/")
self.__dict__['slot'] = slot_split[0]
if len(slot_split) > 1:
self.__dict__['sub_slot'] = slot_split[1]
else:
self.__dict__['sub_slot'] = slot_split[0]
else:
self.__dict__['slot'] = slot
self.__dict__['sub_slot'] = slot
if repo is not None:
repo = _gen_valid_repo(repo)
if not repo:
repo = _unknown_repo
self.__dict__['repo'] = repo
def _repoman_iuse_implicit_cnstr(self, pkg, metadata): """ In repoman's version of _iuse_implicit_cnstr, account for modifications of the self.settings reference between calls. """ eapi_attrs = _get_eapi_attrs(metadata["EAPI"]) if eapi_attrs.iuse_effective: iuse_implicit_match = lambda flag: self.settings._iuse_effective_match(flag) else: iuse_implicit_match = lambda flag: self.settings._iuse_implicit_match(flag) return iuse_implicit_match
def _repoman_iuse_implicit_cnstr(self, pkg, metadata): """ In repoman's version of _iuse_implicit_cnstr, account for modifications of the self.settings reference between calls. """ eapi_attrs = _get_eapi_attrs(metadata["EAPI"]) if eapi_attrs.iuse_effective: iuse_implicit_match = lambda flag: self.settings._iuse_effective_match(flag) else: iuse_implicit_match = lambda flag: self.settings._iuse_implicit_match(flag) return iuse_implicit_match
def __init__(self, cpv, metadata=None, settings=None, eapi=None, repo=None, slot=None):
if not isinstance(cpv, _unicode):
# Avoid TypeError from _unicode.__init__ with PyPy.
cpv = _unicode_decode(cpv)
_unicode.__init__(cpv)
if metadata is not None:
self.__dict__["_metadata"] = metadata
slot = metadata.get("SLOT", slot)
repo = metadata.get("repository", repo)
eapi = metadata.get("EAPI", eapi)
if settings is not None:
self.__dict__["_settings"] = settings
if eapi is not None:
self.__dict__["eapi"] = eapi
self.__dict__["cpv_split"] = catpkgsplit(cpv, eapi=eapi)
if self.cpv_split is None:
raise InvalidData(cpv)
self.__dict__["cp"] = self.cpv_split[0] + "/" + self.cpv_split[1]
if self.cpv_split[-1] == "r0" and cpv[-3:] != "-r0":
self.__dict__["version"] = "-".join(self.cpv_split[2:-1])
else:
self.__dict__["version"] = "-".join(self.cpv_split[2:])
# for match_from_list introspection
self.__dict__["cpv"] = self
if slot is not None:
eapi_attrs = _get_eapi_attrs(eapi)
slot_match = _get_slot_re(eapi_attrs).match(slot)
if slot_match is None:
# Avoid an InvalidAtom exception when creating SLOT atoms
self.__dict__["slot"] = "0"
self.__dict__["sub_slot"] = "0"
self.__dict__["slot_invalid"] = slot
else:
if eapi_attrs.slot_operator:
slot_split = slot.split("/")
self.__dict__["slot"] = slot_split[0]
if len(slot_split) > 1:
self.__dict__["sub_slot"] = slot_split[1]
else:
self.__dict__["sub_slot"] = slot_split[0]
else:
self.__dict__["slot"] = slot
self.__dict__["sub_slot"] = slot
if repo is not None:
repo = _gen_valid_repo(repo)
if not repo:
repo = _unknown_repo
self.__dict__["repo"] = repo
def recheck_hidden(self, pkg):
""" Prevent USE_EXPAND_HIDDEN flags from being hidden if they
are the only thing that triggered reinstallation.
@param pkg: _emerge.Package.Package instance
Modifies self.use_expand_hidden, self.use_expand, self.verboseadd
"""
reinst_flags_map = {}
reinstall_for_flags = self.conf.reinstall_nodes.get(pkg)
reinst_expand_map = None
if reinstall_for_flags:
reinst_flags_map = self.map_to_use_expand(
list(reinstall_for_flags), remove_hidden=False)
for k in list(reinst_flags_map):
if not reinst_flags_map[k]:
del reinst_flags_map[k]
if not reinst_flags_map.get("USE"):
reinst_expand_map = reinst_flags_map.copy()
reinst_expand_map.pop("USE", None)
if reinst_expand_map and \
not set(reinst_expand_map).difference(
self.use_expand_hidden):
self.use_expand_hidden = \
set(self.use_expand_hidden).difference(
reinst_expand_map)
cur_iuse_map, iuse_forced = \
self.map_to_use_expand(self.cur_iuse, forced_flags=True)
cur_use_map = self.map_to_use_expand(self.cur_use)
old_iuse_map = self.map_to_use_expand(self.old_iuse)
old_use_map = self.map_to_use_expand(self.old_use)
use_expand = sorted(self.use_expand)
use_expand.insert(0, "USE")
feature_flags = _get_feature_flags(
_get_eapi_attrs(pkg.metadata["EAPI"]))
for key in use_expand:
if key in self.use_expand_hidden:
continue
self.verboseadd += _create_use_string(
self.conf, key.upper(), cur_iuse_map[key], iuse_forced[key],
cur_use_map[key], old_iuse_map[key], old_use_map[key],
self.is_new, feature_flags, reinst_flags_map.get(key))
return
def recheck_hidden(self, pkg):
""" Prevent USE_EXPAND_HIDDEN flags from being hidden if they
are the only thing that triggered reinstallation.
@param pkg: _emerge.Package.Package instance
Modifies self.use_expand_hidden, self.use_expand, self.verboseadd
"""
reinst_flags_map = {}
reinstall_for_flags = self.conf.reinstall_nodes.get(pkg)
reinst_expand_map = None
if reinstall_for_flags:
reinst_flags_map = self.map_to_use_expand(
list(reinstall_for_flags), remove_hidden=False)
for k in list(reinst_flags_map):
if not reinst_flags_map[k]:
del reinst_flags_map[k]
if not reinst_flags_map.get("USE"):
reinst_expand_map = reinst_flags_map.copy()
reinst_expand_map.pop("USE", None)
if reinst_expand_map and \
not set(reinst_expand_map).difference(
self.use_expand_hidden):
self.use_expand_hidden = \
set(self.use_expand_hidden).difference(
reinst_expand_map)
cur_iuse_map, iuse_forced = \
self.map_to_use_expand(self.cur_iuse, forced_flags=True)
cur_use_map = self.map_to_use_expand(self.cur_use)
old_iuse_map = self.map_to_use_expand(self.old_iuse)
old_use_map = self.map_to_use_expand(self.old_use)
use_expand = sorted(self.use_expand)
use_expand.insert(0, "USE")
feature_flags = _get_feature_flags(_get_eapi_attrs(pkg.metadata["EAPI"]))
for key in use_expand:
if key in self.use_expand_hidden:
continue
self.verboseadd += _create_use_string(self.conf, key.upper(),
cur_iuse_map[key], iuse_forced[key],
cur_use_map[key], old_iuse_map[key],
old_use_map[key], self.is_new, feature_flags,
reinst_flags_map.get(key))
return
def _pkgsplit(mypkg, eapi=None):
"""
@param mypkg: pv
@return:
1. None if input is invalid.
2. (pn, ver, rev) if input is pv
"""
m = _get_pv_re(_get_eapi_attrs(eapi)).match(mypkg)
if m is None:
return None
if m.group('pn_inval') is not None:
# package name appears to have a version-like suffix
return None
rev = m.group('rev')
if rev is None:
rev = '0'
rev = 'r' + rev
return (m.group('pn'), m.group('ver'), rev)
def _pkgsplit(mypkg, eapi=None):
"""
@param mypkg: pv
@return:
1. None if input is invalid.
2. (pn, ver, rev) if input is pv
"""
m = _get_pv_re(_get_eapi_attrs(eapi)).match(mypkg)
if m is None:
return None
if m.group('pn_inval') is not None:
# package name appears to have a version-like suffix
return None
rev = m.group('rev')
if rev is None:
rev = '0'
rev = 'r' + rev
return (m.group('pn'), m.group('ver'), rev)
def _iuse_implicit_cnstr(self, pkg, metadata): """ Construct a callable that checks if a given USE flag should be considered to be a member of the implicit IUSE for the given package. @param pkg: package @type pkg: _pkg_str @param metadata: package metadata @type metadata: Mapping @return: a callable that accepts a single USE flag argument, and returns True only if the USE flag should be considered to be a member of the implicit IUSE for the given package. @rtype: callable """ eapi_attrs = _get_eapi_attrs(metadata["EAPI"]) if eapi_attrs.iuse_effective: iuse_implicit_match = self.settings._iuse_effective_match else: iuse_implicit_match = self.settings._iuse_implicit_match if not self._use_mutable and eapi_attrs.iuse_effective: # For built packages, it is desirable for the built USE setting to # be independent of the profile's current IUSE_IMPLICIT state, since # the profile's IUSE_IMPLICT setting may have diverged. Therefore, # any member of the built USE setting is considered to be a valid # member of IUSE_EFFECTIVE. Note that the binary package may be # remote, so it's only possible to rely on metadata that is available # in the remote Packages file, and the IUSE_IMPLICIT header in the # Packages file is vulnerable to mutation (see bug 640318). # # This behavior is only used for EAPIs that support IUSE_EFFECTIVE, # since built USE settings for earlier EAPIs may contain a large # number of irrelevant flags. prof_iuse = iuse_implicit_match enabled = frozenset(metadata["USE"].split()).__contains__ iuse_implicit_match = lambda flag: prof_iuse(flag) or enabled(flag) return iuse_implicit_match
def _iuse_implicit_cnstr(self, pkg, metadata):
"""
Construct a callable that checks if a given USE flag should
be considered to be a member of the implicit IUSE for the
given package.
@param pkg: package
@type pkg: _pkg_str
@param metadata: package metadata
@type metadata: Mapping
@return: a callable that accepts a single USE flag argument,
and returns True only if the USE flag should be considered
to be a member of the implicit IUSE for the given package.
@rtype: callable
"""
eapi_attrs = _get_eapi_attrs(metadata["EAPI"])
if eapi_attrs.iuse_effective:
iuse_implicit_match = self.settings._iuse_effective_match
else:
iuse_implicit_match = self.settings._iuse_implicit_match
if not self._use_mutable and eapi_attrs.iuse_effective:
# For built packages, it is desirable for the built USE setting to
# be independent of the profile's current IUSE_IMPLICIT state, since
# the profile's IUSE_IMPLICT setting may have diverged. Therefore,
# any member of the built USE setting is considered to be a valid
# member of IUSE_EFFECTIVE. Note that the binary package may be
# remote, so it's only possible to rely on metadata that is available
# in the remote Packages file, and the IUSE_IMPLICIT header in the
# Packages file is vulnerable to mutation (see bug 640318).
#
# This behavior is only used for EAPIs that support IUSE_EFFECTIVE,
# since built USE settings for earlier EAPIs may contain a large
# number of irrelevant flags.
prof_iuse = iuse_implicit_match
enabled = frozenset(metadata["USE"].split()).__contains__
iuse_implicit_match = lambda flag: prof_iuse(flag) or enabled(flag)
return iuse_implicit_match
def __init__(self, **kwargs):
metadata = _PackageMetadataWrapperBase(kwargs.pop("metadata"))
Task.__init__(self, **kwargs)
# the SlotObject constructor assigns self.root_config from keyword args
# and is an instance of a '_emerge.RootConfig.RootConfig class
self.root = self.root_config.root
self._raw_metadata = metadata
self._metadata = _PackageMetadataWrapper(self, metadata)
if not self.built:
self._metadata["CHOST"] = self.root_config.settings.get("CHOST", "")
eapi_attrs = _get_eapi_attrs(self.eapi)
try:
db = self.cpv._db
except AttributeError:
if self.built:
# For independence from the source ebuild repository and
# profile implicit IUSE state, require the _db attribute
# for built packages.
raise
db = self.root_config.trees["porttree"].dbapi
self.cpv = _pkg_str(
self.cpv, metadata=self._metadata, settings=self.root_config.settings, db=db
)
if hasattr(self.cpv, "slot_invalid"):
self._invalid_metadata(
"SLOT.invalid", "SLOT: invalid value: '%s'" % self._metadata["SLOT"]
)
self.cpv_split = self.cpv.cpv_split
self.category, self.pf = portage.catsplit(self.cpv)
self.cp = self.cpv.cp
self.version = self.cpv.version
self.slot = self.cpv.slot
self.sub_slot = self.cpv.sub_slot
self.slot_atom = Atom("%s%s%s" % (self.cp, _slot_separator, self.slot))
# sync metadata with validated repo (may be UNKNOWN_REPO)
self._metadata["repository"] = self.cpv.repo
implicit_match = db._iuse_implicit_cnstr(self.cpv, self._metadata)
self.iuse = self._iuse(
self, self._metadata["IUSE"].split(), implicit_match, self.eapi
)
if (self.iuse.enabled or self.iuse.disabled) and not eapi_attrs.iuse_defaults:
if not self.installed:
self._invalid_metadata(
"EAPI.incompatible",
"IUSE contains defaults, but EAPI doesn't allow them",
)
if self.inherited is None:
self.inherited = frozenset()
if self.operation is None:
if self.onlydeps or self.installed:
self.operation = "nomerge"
else:
self.operation = "merge"
self._hash_key = Package._gen_hash_key(
cpv=self.cpv,
installed=self.installed,
onlydeps=self.onlydeps,
operation=self.operation,
repo_name=self.cpv.repo,
root_config=self.root_config,
type_name=self.type_name,
)
self._hash_value = hash(self._hash_key)
def _match_use(self, atom, cpv, metadata):
eapi_attrs = _get_eapi_attrs(metadata["EAPI"])
if eapi_attrs.iuse_effective:
iuse_implicit_match = self.settings._iuse_effective_match
else:
iuse_implicit_match = self.settings._iuse_implicit_match
iuse = frozenset(x.lstrip('+-') for x in metadata["IUSE"].split())
for x in atom.unevaluated_atom.use.required:
if x not in iuse and not iuse_implicit_match(x):
return False
if atom.use is None:
pass
elif not self._use_mutable:
# Use IUSE to validate USE settings for built packages,
# in case the package manager that built this package
# failed to do that for some reason (or in case of
# data corruption).
use = frozenset(x for x in metadata["USE"].split()
if x in iuse or iuse_implicit_match(x))
missing_enabled = atom.use.missing_enabled.difference(iuse)
missing_disabled = atom.use.missing_disabled.difference(iuse)
if atom.use.enabled:
if any(x in atom.use.enabled for x in missing_disabled):
return False
need_enabled = atom.use.enabled.difference(use)
if need_enabled:
if any(x not in missing_enabled for x in need_enabled):
return False
if atom.use.disabled:
if any(x in atom.use.disabled for x in missing_enabled):
return False
need_disabled = atom.use.disabled.intersection(use)
if need_disabled:
if any(x not in missing_disabled for x in need_disabled):
return False
elif not self.settings.local_config:
# Check masked and forced flags for repoman.
try:
cpv.slot
except AttributeError:
pkg = _pkg_str(cpv, metadata=metadata, settings=self.settings)
else:
pkg = cpv
usemask = self.settings._getUseMask(pkg)
if any(x in usemask for x in atom.use.enabled):
return False
useforce = self.settings._getUseForce(pkg)
if any(x in useforce and x not in usemask
for x in atom.use.disabled):
return False
# Check unsatisfied use-default deps
if atom.use.enabled:
missing_disabled = atom.use.missing_disabled.difference(iuse)
if any(x in atom.use.enabled for x in missing_disabled):
return False
if atom.use.disabled:
missing_enabled = atom.use.missing_enabled.difference(iuse)
if any(x in atom.use.disabled for x in missing_enabled):
return False
return True
def expand_new_virt(vardb, atom):
"""
Iterate over the recursively expanded RDEPEND atoms of
a new-style virtual. If atom is not a new-style virtual
or it does not match an installed package then it is
yielded without any expansion.
"""
if not isinstance(atom, Atom):
atom = Atom(atom)
if not atom.cp.startswith("virtual/"):
yield atom
return
traversed = set()
stack = [atom]
while stack:
atom = stack.pop()
if atom.blocker or \
not atom.cp.startswith("virtual/"):
yield atom
continue
matches = vardb.match(atom)
if not (matches and matches[-1].startswith("virtual/")):
yield atom
continue
virt_cpv = matches[-1]
if virt_cpv in traversed:
continue
traversed.add(virt_cpv)
eapi, iuse, rdepend, use = vardb.aux_get(
virt_cpv, ["EAPI", "IUSE", "RDEPEND", "USE"])
if not portage.eapi_is_supported(eapi):
yield atom
continue
eapi_attrs = _get_eapi_attrs(eapi)
# Validate IUSE and IUSE, for early detection of vardb corruption.
useflag_re = _get_useflag_re(eapi)
valid_iuse = []
for x in iuse.split():
if x[:1] in ("+", "-"):
x = x[1:]
if useflag_re.match(x) is not None:
valid_iuse.append(x)
valid_iuse = frozenset(valid_iuse)
if eapi_attrs.iuse_effective:
iuse_implicit_match = vardb.settings._iuse_effective_match
else:
iuse_implicit_match = vardb.settings._iuse_implicit_match
valid_use = []
for x in use.split():
if x in valid_iuse or iuse_implicit_match(x):
valid_use.append(x)
valid_use = frozenset(valid_use)
success, atoms = portage.dep_check(rdepend,
None,
vardb.settings,
myuse=valid_use,
myroot=vardb.settings['EROOT'],
trees={
vardb.settings['EROOT']: {
"porttree": vardb.vartree,
"vartree": vardb.vartree
}
})
if success:
stack.extend(atoms)
else:
yield atom
def _match_use(self, atom, pkg, metadata):
eapi_attrs = _get_eapi_attrs(metadata["EAPI"])
if eapi_attrs.iuse_effective:
iuse_implicit_match = self.settings._iuse_effective_match
else:
iuse_implicit_match = self.settings._iuse_implicit_match
usealiases = self.settings._use_manager.getUseAliases(pkg)
iuse = Package._iuse(None, metadata["IUSE"].split(),
iuse_implicit_match, usealiases, metadata["EAPI"])
for x in atom.unevaluated_atom.use.required:
if iuse.get_real_flag(x) is None:
return False
if atom.use is None:
pass
elif not self._use_mutable:
# Use IUSE to validate USE settings for built packages,
# in case the package manager that built this package
# failed to do that for some reason (or in case of
# data corruption). The enabled flags must be consistent
# with implicit IUSE, in order to avoid potential
# inconsistencies in USE dep matching (see bug #453400).
use = frozenset(x for x in metadata["USE"].split()
if iuse.get_real_flag(x) is not None)
missing_enabled = frozenset(x for x in atom.use.missing_enabled
if iuse.get_real_flag(x) is None)
missing_disabled = frozenset(x for x in atom.use.missing_disabled
if iuse.get_real_flag(x) is None)
enabled = frozenset(
(iuse.get_real_flag(x) or x) for x in atom.use.enabled)
disabled = frozenset(
(iuse.get_real_flag(x) or x) for x in atom.use.disabled)
if enabled:
if any(x in enabled for x in missing_disabled):
return False
need_enabled = enabled.difference(use)
if need_enabled:
if any(x not in missing_enabled for x in need_enabled):
return False
if disabled:
if any(x in disabled for x in missing_enabled):
return False
need_disabled = disabled.intersection(use)
if need_disabled:
if any(x not in missing_disabled for x in need_disabled):
return False
elif not self.settings.local_config:
# Check masked and forced flags for repoman.
usemask = self.settings._getUseMask(
pkg, stable=self.settings._parent_stable)
if any(x in usemask for x in atom.use.enabled):
return False
useforce = self.settings._getUseForce(
pkg, stable=self.settings._parent_stable)
if any(x in useforce and x not in usemask
for x in atom.use.disabled):
return False
# Check unsatisfied use-default deps
if atom.use.enabled:
missing_disabled = frozenset(x
for x in atom.use.missing_disabled
if iuse.get_real_flag(x) is None)
if any(x in atom.use.enabled for x in missing_disabled):
return False
if atom.use.disabled:
missing_enabled = frozenset(x for x in atom.use.missing_enabled
if iuse.get_real_flag(x) is None)
if any(x in atom.use.disabled for x in missing_enabled):
return False
return True
def _validate_deps(self):
"""
Validate deps. This does not trigger USE calculation since that
is expensive for ebuilds and therefore we want to avoid doing
it unnecessarily (like for masked packages).
"""
eapi = self.eapi
dep_eapi = eapi
dep_valid_flag = self.iuse.is_valid_flag
if self.installed:
# Ignore EAPI.incompatible and conditionals missing
# from IUSE for installed packages since these issues
# aren't relevant now (re-evaluate when new EAPIs are
# deployed).
dep_eapi = None
dep_valid_flag = None
validated_atoms = []
for k in self._dep_keys:
v = self._metadata.get(k)
if not v:
continue
try:
atoms = use_reduce(v, eapi=dep_eapi,
matchall=True, is_valid_flag=dep_valid_flag,
token_class=Atom, flat=True)
except InvalidDependString as e:
self._metadata_exception(k, e)
else:
validated_atoms.extend(atoms)
if not self.built:
for atom in atoms:
if not isinstance(atom, Atom):
continue
if atom.slot_operator_built:
e = InvalidDependString(
_("Improper context for slot-operator "
"\"built\" atom syntax: %s") %
(atom.unevaluated_atom,))
self._metadata_exception(k, e)
self._validated_atoms = tuple(set(atom for atom in
validated_atoms if isinstance(atom, Atom)))
for k in self._use_conditional_misc_keys:
v = self._metadata.get(k)
if not v:
continue
try:
use_reduce(v, eapi=dep_eapi, matchall=True,
is_valid_flag=dep_valid_flag)
except InvalidDependString as e:
self._metadata_exception(k, e)
k = 'REQUIRED_USE'
v = self._metadata.get(k)
if v and not self.built:
if not _get_eapi_attrs(eapi).required_use:
self._invalid_metadata('EAPI.incompatible',
"REQUIRED_USE set, but EAPI='%s' doesn't allow it" % eapi)
else:
try:
check_required_use(v, (),
self.iuse.is_valid_flag, eapi=eapi)
except InvalidDependString as e:
self._invalid_metadata(k + ".syntax", "%s: %s" % (k, e))
k = 'SRC_URI'
v = self._metadata.get(k)
if v:
try:
use_reduce(v, is_src_uri=True, eapi=eapi, matchall=True,
is_valid_flag=self.iuse.is_valid_flag)
except InvalidDependString as e:
if not self.installed:
self._metadata_exception(k, e)
if self.built:
k = 'PROVIDES'
try:
self._provides = frozenset(
parse_soname_deps(self._metadata[k]))
except InvalidData as e:
self._invalid_metadata(k + ".syntax", "%s: %s" % (k, e))
k = 'REQUIRES'
try:
self._requires = frozenset(
parse_soname_deps(self._metadata[k]))
except InvalidData as e:
self._invalid_metadata(k + ".syntax", "%s: %s" % (k, e))
def _match_use(self, atom, pkg, metadata, ignore_profile=False): eapi_attrs = _get_eapi_attrs(metadata["EAPI"]) if eapi_attrs.iuse_effective: iuse_implicit_match = self.settings._iuse_effective_match else: iuse_implicit_match = self.settings._iuse_implicit_match usealiases = self.settings._use_manager.getUseAliases(pkg) iuse = Package._iuse(None, metadata["IUSE"].split(), iuse_implicit_match, usealiases, metadata["EAPI"]) for x in atom.unevaluated_atom.use.required: if iuse.get_real_flag(x) is None: return False if atom.use is None: pass elif not self._use_mutable: # Use IUSE to validate USE settings for built packages, # in case the package manager that built this package # failed to do that for some reason (or in case of # data corruption). The enabled flags must be consistent # with implicit IUSE, in order to avoid potential # inconsistencies in USE dep matching (see bug #453400). use = frozenset(x for x in metadata["USE"].split() if iuse.get_real_flag(x) is not None) missing_enabled = frozenset(x for x in atom.use.missing_enabled if iuse.get_real_flag(x) is None) missing_disabled = frozenset(x for x in atom.use.missing_disabled if iuse.get_real_flag(x) is None) enabled = frozenset((iuse.get_real_flag(x) or x) for x in atom.use.enabled) disabled = frozenset((iuse.get_real_flag(x) or x) for x in atom.use.disabled) if enabled: if any(x in enabled for x in missing_disabled): return False need_enabled = enabled.difference(use) if need_enabled: if any(x not in missing_enabled for x in need_enabled): return False if disabled: if any(x in disabled for x in missing_enabled): return False need_disabled = disabled.intersection(use) if need_disabled: if any(x not in missing_disabled for x in need_disabled): return False elif not self.settings.local_config: if not ignore_profile: # Check masked and forced flags for repoman. usemask = self.settings._getUseMask(pkg, stable=self.settings._parent_stable) if any(x in usemask for x in atom.use.enabled): return False useforce = self.settings._getUseForce(pkg, stable=self.settings._parent_stable) if any(x in useforce and x not in usemask for x in atom.use.disabled): return False # Check unsatisfied use-default deps if atom.use.enabled: missing_disabled = frozenset(x for x in atom.use.missing_disabled if iuse.get_real_flag(x) is None) if any(x in atom.use.enabled for x in missing_disabled): return False if atom.use.disabled: missing_enabled = frozenset(x for x in atom.use.missing_enabled if iuse.get_real_flag(x) is None) if any(x in atom.use.disabled for x in missing_enabled): return False return True
def _validate_deps(self):
"""
Validate deps. This does not trigger USE calculation since that
is expensive for ebuilds and therefore we want to avoid doing
it unnecessarily (like for masked packages).
"""
eapi = self.eapi
dep_eapi = eapi
dep_valid_flag = self.iuse.is_valid_flag
if self.installed:
# Ignore EAPI.incompatible and conditionals missing
# from IUSE for installed packages since these issues
# aren't relevant now (re-evaluate when new EAPIs are
# deployed).
dep_eapi = None
dep_valid_flag = None
validated_atoms = []
for k in self._dep_keys:
v = self._metadata.get(k)
if not v:
continue
try:
atoms = use_reduce(v, eapi=dep_eapi,
matchall=True, is_valid_flag=dep_valid_flag,
token_class=Atom, flat=True)
except InvalidDependString as e:
self._metadata_exception(k, e)
else:
validated_atoms.extend(atoms)
if not self.built:
for atom in atoms:
if not isinstance(atom, Atom):
continue
if atom.slot_operator_built:
e = InvalidDependString(
_("Improper context for slot-operator "
"\"built\" atom syntax: %s") %
(atom.unevaluated_atom,))
self._metadata_exception(k, e)
self._validated_atoms = tuple(set(atom for atom in
validated_atoms if isinstance(atom, Atom)))
k = 'PROVIDE'
v = self._metadata.get(k)
if v:
try:
use_reduce(v, eapi=dep_eapi, matchall=True,
is_valid_flag=dep_valid_flag, token_class=Atom)
except InvalidDependString as e:
self._invalid_metadata("PROVIDE.syntax", "%s: %s" % (k, e))
for k in self._use_conditional_misc_keys:
v = self._metadata.get(k)
if not v:
continue
try:
use_reduce(v, eapi=dep_eapi, matchall=True,
is_valid_flag=dep_valid_flag)
except InvalidDependString as e:
self._metadata_exception(k, e)
k = 'REQUIRED_USE'
v = self._metadata.get(k)
if v and not self.built:
if not _get_eapi_attrs(eapi).required_use:
self._invalid_metadata('EAPI.incompatible',
"REQUIRED_USE set, but EAPI='%s' doesn't allow it" % eapi)
else:
try:
check_required_use(v, (),
self.iuse.is_valid_flag, eapi=eapi)
except InvalidDependString as e:
self._invalid_metadata(k + ".syntax", "%s: %s" % (k, e))
k = 'SRC_URI'
v = self._metadata.get(k)
if v:
try:
use_reduce(v, is_src_uri=True, eapi=eapi, matchall=True,
is_valid_flag=self.iuse.is_valid_flag)
except InvalidDependString as e:
if not self.installed:
self._metadata_exception(k, e)
if self.built:
k = 'PROVIDES'
try:
self._provides = frozenset(
parse_soname_deps(self._metadata[k]))
except InvalidData as e:
self._invalid_metadata(k + ".syntax", "%s: %s" % (k, e))
k = 'REQUIRES'
try:
self._requires = frozenset(
parse_soname_deps(self._metadata[k]))
except InvalidData as e:
self._invalid_metadata(k + ".syntax", "%s: %s" % (k, e))
def expand_new_virt(vardb, atom):
"""
Iterate over the recursively expanded RDEPEND atoms of
a new-style virtual. If atom is not a new-style virtual
or it does not match an installed package then it is
yielded without any expansion.
"""
if not isinstance(atom, Atom):
atom = Atom(atom)
if not atom.cp.startswith("virtual/"):
yield atom
return
traversed = set()
stack = [atom]
while stack:
atom = stack.pop()
if atom.blocker or \
not atom.cp.startswith("virtual/"):
yield atom
continue
matches = vardb.match(atom)
if not (matches and matches[-1].startswith("virtual/")):
yield atom
continue
virt_cpv = matches[-1]
if virt_cpv in traversed:
continue
traversed.add(virt_cpv)
eapi, iuse, rdepend, use = vardb.aux_get(virt_cpv,
["EAPI", "IUSE", "RDEPEND", "USE"])
if not portage.eapi_is_supported(eapi):
yield atom
continue
eapi_attrs = _get_eapi_attrs(eapi)
# Validate IUSE and IUSE, for early detection of vardb corruption.
useflag_re = _get_useflag_re(eapi)
valid_iuse = []
for x in iuse.split():
if x[:1] in ("+", "-"):
x = x[1:]
if useflag_re.match(x) is not None:
valid_iuse.append(x)
valid_iuse = frozenset(valid_iuse)
if eapi_attrs.iuse_effective:
iuse_implicit_match = vardb.settings._iuse_effective_match
else:
iuse_implicit_match = vardb.settings._iuse_implicit_match
valid_use = []
for x in use.split():
if x in valid_iuse or iuse_implicit_match(x):
valid_use.append(x)
valid_use = frozenset(valid_use)
success, atoms = portage.dep_check(rdepend,
None, vardb.settings, myuse=valid_use,
myroot=vardb.settings['EROOT'],
trees={vardb.settings['EROOT']:{"porttree":vardb.vartree,
"vartree":vardb.vartree}})
if success:
stack.extend(atoms)
else:
yield atom
def __init__(
self,
cpv,
metadata=None,
settings=None,
eapi=None,
repo=None,
slot=None,
build_time=None,
build_id=None,
file_size=None,
mtime=None,
db=None,
):
if not isinstance(cpv, str):
# Avoid TypeError from str.__init__ with PyPy.
cpv = _unicode_decode(cpv)
str.__init__(cpv)
if metadata is not None:
self.__dict__["_metadata"] = metadata
slot = metadata.get("SLOT", slot)
repo = metadata.get("repository", repo)
eapi = metadata.get("EAPI", eapi)
build_time = metadata.get("BUILD_TIME", build_time)
file_size = metadata.get("SIZE", file_size)
build_id = metadata.get("BUILD_ID", build_id)
mtime = metadata.get("_mtime_", mtime)
if settings is not None:
self.__dict__["_settings"] = settings
if db is not None:
self.__dict__["_db"] = db
if eapi is not None:
self.__dict__["eapi"] = eapi
self.__dict__["build_time"] = self._long(build_time, 0)
self.__dict__["file_size"] = self._long(file_size, None)
self.__dict__["build_id"] = self._long(build_id, None)
self.__dict__["mtime"] = self._long(mtime, None)
self.__dict__["cpv_split"] = catpkgsplit(cpv, eapi=eapi)
if self.cpv_split is None:
raise InvalidData(cpv)
self.__dict__["cp"] = self.cpv_split[0] + "/" + self.cpv_split[1]
if self.cpv_split[-1] == "r0" and cpv[-3:] != "-r0":
self.__dict__["version"] = "-".join(self.cpv_split[2:-1])
else:
self.__dict__["version"] = "-".join(self.cpv_split[2:])
# for match_from_list introspection
self.__dict__["cpv"] = self
if slot is not None:
eapi_attrs = _get_eapi_attrs(eapi)
slot_match = _get_slot_re(eapi_attrs).match(slot)
if slot_match is None:
# Avoid an InvalidAtom exception when creating SLOT atoms
self.__dict__["slot"] = "0"
self.__dict__["sub_slot"] = "0"
self.__dict__["slot_invalid"] = slot
else:
if eapi_attrs.slot_operator:
slot_split = slot.split("/")
self.__dict__["slot"] = slot_split[0]
if len(slot_split) > 1:
self.__dict__["sub_slot"] = slot_split[1]
else:
self.__dict__["sub_slot"] = slot_split[0]
else:
self.__dict__["slot"] = slot
self.__dict__["sub_slot"] = slot
if repo is not None:
repo = _gen_valid_repo(repo)
if not repo:
repo = _unknown_repo
self.__dict__["repo"] = repo
def _match_use(self, atom, cpv, metadata):
eapi_attrs = _get_eapi_attrs(metadata["EAPI"])
if eapi_attrs.iuse_effective:
iuse_implicit_match = self.settings._iuse_effective_match
else:
iuse_implicit_match = self.settings._iuse_implicit_match
iuse = frozenset(x.lstrip('+-') for x in metadata["IUSE"].split())
for x in atom.unevaluated_atom.use.required:
if x not in iuse and not iuse_implicit_match(x):
return False
if atom.use is None:
pass
elif not self._use_mutable:
# Use IUSE to validate USE settings for built packages,
# in case the package manager that built this package
# failed to do that for some reason (or in case of
# data corruption).
use = frozenset(x for x in metadata["USE"].split()
if x in iuse or iuse_implicit_match(x))
missing_enabled = atom.use.missing_enabled.difference(iuse)
missing_disabled = atom.use.missing_disabled.difference(iuse)
if atom.use.enabled:
if any(x in atom.use.enabled for x in missing_disabled):
return False
need_enabled = atom.use.enabled.difference(use)
if need_enabled:
if any(x not in missing_enabled for x in need_enabled):
return False
if atom.use.disabled:
if any(x in atom.use.disabled for x in missing_enabled):
return False
need_disabled = atom.use.disabled.intersection(use)
if need_disabled:
if any(x not in missing_disabled for x in need_disabled):
return False
elif not self.settings.local_config:
# Check masked and forced flags for repoman.
try:
cpv.slot
except AttributeError:
pkg = _pkg_str(cpv, metadata=metadata, settings=self.settings)
else:
pkg = cpv
usemask = self.settings._getUseMask(pkg)
if any(x in usemask for x in atom.use.enabled):
return False
useforce = self.settings._getUseForce(pkg)
if any(x in useforce and x not in usemask
for x in atom.use.disabled):
return False
# Check unsatisfied use-default deps
if atom.use.enabled:
missing_disabled = atom.use.missing_disabled.difference(iuse)
if any(x in atom.use.enabled for x in missing_disabled):
return False
if atom.use.disabled:
missing_enabled = atom.use.missing_enabled.difference(iuse)
if any(x in atom.use.disabled for x in missing_enabled):
return False
return True
def _display_use(self, pkg, pkg_info):
""" USE flag display
@param pkg: _emerge.Package.Package instance
@param pkg_info: PkgInfo instance
Modifies self.use_expand_hidden, self.use_expand, self.verboseadd,
self.forced_flags
"""
self.forced_flags = set()
self.forced_flags.update(pkg.use.force)
self.forced_flags.update(pkg.use.mask)
cur_use = [flag for flag in self.conf.pkg_use_enabled(pkg) \
if flag in pkg.iuse.all]
cur_iuse = sorted(pkg.iuse.all)
if pkg_info.previous_pkg is not None:
previous_pkg = pkg_info.previous_pkg
old_iuse = sorted(previous_pkg.iuse.all)
old_use = previous_pkg.use.enabled
is_new = False
else:
old_iuse = []
old_use = []
is_new = True
old_use = [flag for flag in old_use if flag in old_iuse]
self.use_expand = pkg.use.expand
self.use_expand_hidden = pkg.use.expand_hidden
# Prevent USE_EXPAND_HIDDEN flags from being hidden if they
# are the only thing that triggered reinstallation.
reinst_flags_map = {}
reinstall_for_flags = self.conf.reinstall_nodes.get(pkg)
reinst_expand_map = None
if reinstall_for_flags:
reinst_flags_map = self.map_to_use_expand(
list(reinstall_for_flags), remove_hidden=False)
for k in list(reinst_flags_map):
if not reinst_flags_map[k]:
del reinst_flags_map[k]
if not reinst_flags_map.get("USE"):
reinst_expand_map = reinst_flags_map.copy()
reinst_expand_map.pop("USE", None)
if reinst_expand_map and \
not set(reinst_expand_map).difference(
self.use_expand_hidden):
self.use_expand_hidden = \
set(self.use_expand_hidden).difference(
reinst_expand_map)
cur_iuse_map, iuse_forced = \
self.map_to_use_expand(cur_iuse, forced_flags=True)
cur_use_map = self.map_to_use_expand(cur_use)
old_iuse_map = self.map_to_use_expand(old_iuse)
old_use_map = self.map_to_use_expand(old_use)
use_expand = sorted(self.use_expand)
use_expand.insert(0, "USE")
feature_flags = _get_feature_flags(_get_eapi_attrs(pkg.eapi))
for key in use_expand:
if key in self.use_expand_hidden:
continue
self.verboseadd += _create_use_string(self.conf, key.upper(),
cur_iuse_map[key], iuse_forced[key],
cur_use_map[key], old_iuse_map[key],
old_use_map[key], is_new, feature_flags,
reinst_flags_map.get(key))
return
def _display_use(self, pkg, pkg_info):
""" USE flag display
@param pkg: _emerge.Package.Package instance
@param pkg_info: PkgInfo instance
Modifies self.use_expand_hidden, self.use_expand, self.verboseadd,
self.forced_flags
"""
self.forced_flags = set()
self.forced_flags.update(pkg.use.force)
self.forced_flags.update(pkg.use.mask)
cur_use = [flag for flag in self.conf.pkg_use_enabled(pkg) \
if flag in pkg.iuse.all]
cur_iuse = sorted(pkg.iuse.all)
if pkg_info.previous_pkg is not None:
previous_pkg = pkg_info.previous_pkg
old_iuse = sorted(previous_pkg.iuse.all)
old_use = previous_pkg.use.enabled
is_new = False
else:
old_iuse = []
old_use = []
is_new = True
old_use = [flag for flag in old_use if flag in old_iuse]
self.use_expand = pkg.use.expand
self.use_expand_hidden = pkg.use.expand_hidden
# Prevent USE_EXPAND_HIDDEN flags from being hidden if they
# are the only thing that triggered reinstallation.
reinst_flags_map = {}
reinstall_for_flags = self.conf.reinstall_nodes.get(pkg)
reinst_expand_map = None
if reinstall_for_flags:
reinst_flags_map = self.map_to_use_expand(
list(reinstall_for_flags), remove_hidden=False)
for k in list(reinst_flags_map):
if not reinst_flags_map[k]:
del reinst_flags_map[k]
if not reinst_flags_map.get("USE"):
reinst_expand_map = reinst_flags_map.copy()
reinst_expand_map.pop("USE", None)
if reinst_expand_map and \
not set(reinst_expand_map).difference(
self.use_expand_hidden):
self.use_expand_hidden = \
set(self.use_expand_hidden).difference(
reinst_expand_map)
cur_iuse_map, iuse_forced = \
self.map_to_use_expand(cur_iuse, forced_flags=True)
cur_use_map = self.map_to_use_expand(cur_use)
old_iuse_map = self.map_to_use_expand(old_iuse)
old_use_map = self.map_to_use_expand(old_use)
use_expand = sorted(self.use_expand)
use_expand.insert(0, "USE")
feature_flags = _get_feature_flags(_get_eapi_attrs(pkg.eapi))
for key in use_expand:
if key in self.use_expand_hidden:
continue
self.verboseadd += _create_use_string(
self.conf, key.upper(), cur_iuse_map[key], iuse_forced[key],
cur_use_map[key], old_iuse_map[key], old_use_map[key], is_new,
feature_flags, reinst_flags_map.get(key))
return
def parse_updates(mycontent):
"""Valid updates are returned as a list of split update commands."""
eapi_attrs = _get_eapi_attrs(None)
slot_re = _get_slot_re(eapi_attrs)
myupd = []
errors = []
mylines = mycontent.splitlines()
for myline in mylines:
mysplit = myline.split()
if len(mysplit) == 0:
continue
if mysplit[0] not in ("move", "slotmove"):
errors.append(_("ERROR: Update type not recognized '%s'") % myline)
continue
if mysplit[0] == "move":
if len(mysplit) != 3:
errors.append(_("ERROR: Update command invalid '%s'") % myline)
continue
valid = True
for i in (1, 2):
try:
atom = Atom(mysplit[i])
except InvalidAtom:
atom = None
else:
if atom.blocker or atom != atom.cp:
atom = None
if atom is not None:
mysplit[i] = atom
else:
errors.append(
_("ERROR: Malformed update entry '%s'") % myline)
valid = False
break
if not valid:
continue
if mysplit[0] == "slotmove":
if len(mysplit)!=4:
errors.append(_("ERROR: Update command invalid '%s'") % myline)
continue
pkg, origslot, newslot = mysplit[1], mysplit[2], mysplit[3]
try:
atom = Atom(pkg)
except InvalidAtom:
atom = None
else:
if atom.blocker:
atom = None
if atom is not None:
mysplit[1] = atom
else:
errors.append(_("ERROR: Malformed update entry '%s'") % myline)
continue
invalid_slot = False
for slot in (origslot, newslot):
m = slot_re.match(slot)
if m is None:
invalid_slot = True
break
if "/" in slot:
# EAPI 4-slot-abi style SLOT is currently not supported.
invalid_slot = True
break
if invalid_slot:
errors.append(_("ERROR: Malformed update entry '%s'") % myline)
continue
# The list of valid updates is filtered by continue statements above.
myupd.append(mysplit)
return myupd, errors
def __init__(self, **kwargs):
metadata = _PackageMetadataWrapperBase(kwargs.pop('metadata'))
Task.__init__(self, **kwargs)
# the SlotObject constructor assigns self.root_config from keyword args
# and is an instance of a '_emerge.RootConfig.RootConfig class
self.root = self.root_config.root
self._raw_metadata = metadata
self._metadata = _PackageMetadataWrapper(self, metadata)
if not self.built:
self._metadata['CHOST'] = self.root_config.settings.get('CHOST', '')
eapi_attrs = _get_eapi_attrs(self.eapi)
try:
db = self.cpv._db
except AttributeError:
if self.built:
# For independence from the source ebuild repository and
# profile implicit IUSE state, require the _db attribute
# for built packages.
raise
db = self.root_config.trees['porttree'].dbapi
self.cpv = _pkg_str(self.cpv, metadata=self._metadata,
settings=self.root_config.settings, db=db)
if hasattr(self.cpv, 'slot_invalid'):
self._invalid_metadata('SLOT.invalid',
"SLOT: invalid value: '%s'" % self._metadata["SLOT"])
self.cpv_split = self.cpv.cpv_split
self.category, self.pf = portage.catsplit(self.cpv)
self.cp = self.cpv.cp
self.version = self.cpv.version
self.slot = self.cpv.slot
self.sub_slot = self.cpv.sub_slot
self.slot_atom = Atom("%s%s%s" % (self.cp, _slot_separator, self.slot))
# sync metadata with validated repo (may be UNKNOWN_REPO)
self._metadata['repository'] = self.cpv.repo
if self.root_config.settings.local_config:
implicit_match = db._iuse_implicit_cnstr(self.cpv, self._metadata)
else:
implicit_match = db._repoman_iuse_implicit_cnstr(self.cpv, self._metadata)
usealiases = self.root_config.settings._use_manager.getUseAliases(self)
self.iuse = self._iuse(self, self._metadata["IUSE"].split(),
implicit_match, usealiases, self.eapi)
if (self.iuse.enabled or self.iuse.disabled) and \
not eapi_attrs.iuse_defaults:
if not self.installed:
self._invalid_metadata('EAPI.incompatible',
"IUSE contains defaults, but EAPI doesn't allow them")
if self.inherited is None:
self.inherited = frozenset()
if self.operation is None:
if self.onlydeps or self.installed:
self.operation = "nomerge"
else:
self.operation = "merge"
self._hash_key = Package._gen_hash_key(cpv=self.cpv,
installed=self.installed, onlydeps=self.onlydeps,
operation=self.operation, repo_name=self.cpv.repo,
root_config=self.root_config,
type_name=self.type_name)
self._hash_value = hash(self._hash_key)
def parse_updates(mycontent):
"""Valid updates are returned as a list of split update commands."""
eapi_attrs = _get_eapi_attrs(None)
slot_re = _get_slot_re(eapi_attrs)
myupd = []
errors = []
mylines = mycontent.splitlines()
for myline in mylines:
mysplit = myline.split()
if len(mysplit) == 0:
continue
if mysplit[0] not in ("move", "slotmove"):
errors.append(_("ERROR: Update type not recognized '%s'") % myline)
continue
if mysplit[0] == "move":
if len(mysplit) != 3:
errors.append(_("ERROR: Update command invalid '%s'") % myline)
continue
valid = True
for i in (1, 2):
try:
atom = Atom(mysplit[i])
except InvalidAtom:
atom = None
else:
if atom.blocker or atom != atom.cp:
atom = None
if atom is not None:
mysplit[i] = atom
else:
errors.append(
_("ERROR: Malformed update entry '%s'") % myline)
valid = False
break
if not valid:
continue
if mysplit[0] == "slotmove":
if len(mysplit)!=4:
errors.append(_("ERROR: Update command invalid '%s'") % myline)
continue
pkg, origslot, newslot = mysplit[1], mysplit[2], mysplit[3]
try:
atom = Atom(pkg)
except InvalidAtom:
atom = None
else:
if atom.blocker:
atom = None
if atom is not None:
mysplit[1] = atom
else:
errors.append(_("ERROR: Malformed update entry '%s'") % myline)
continue
invalid_slot = False
for slot in (origslot, newslot):
m = slot_re.match(slot)
if m is None:
invalid_slot = True
break
if "/" in slot:
# EAPI 4-slot-abi style SLOT is currently not supported.
invalid_slot = True
break
if invalid_slot:
errors.append(_("ERROR: Malformed update entry '%s'") % myline)
continue
# The list of valid updates is filtered by continue statements above.
myupd.append(mysplit)
return myupd, errors
