def _start_unmerge(self, lock_task):
self._assert_current(lock_task)
if lock_task.cancelled:
self._default_final_exit(lock_task)
return
lock_task.future.result()
portage.prepare_build_dirs(
settings=self.settings, cleanup=True)
# Output only gets logged if it comes after prepare_build_dirs()
# which initializes PORTAGE_LOG_FILE.
retval, pkgmap = _unmerge_display(self.pkg.root_config,
self.opts, "unmerge", [self.pkg.cpv], clean_delay=0,
writemsg_level=self._writemsg_level)
if retval != os.EX_OK:
self._async_unlock_builddir(returncode=retval)
return
self._writemsg_level(">>> Unmerging %s...\n" % (self.pkg.cpv,),
noiselevel=-1)
self._emergelog("=== Unmerging... (%s)" % (self.pkg.cpv,))
cat, pf = portage.catsplit(self.pkg.cpv)
unmerge_task = MergeProcess(
mycat=cat, mypkg=pf, settings=self.settings,
treetype="vartree", vartree=self.pkg.root_config.trees["vartree"],
scheduler=self.scheduler, background=self.background,
mydbapi=self.pkg.root_config.trees["vartree"].dbapi,
prev_mtimes=self.ldpath_mtimes,
logfile=self.settings.get("PORTAGE_LOG_FILE"), unmerge=True)
self._start_task(unmerge_task, self._unmerge_exit)
def split_atom_pkg( pkg ):
"""Extract [category/package, atoms, version] from some ebuild identifier"""
#debug.dprint("PORTAGELIB: split_atom_pkg(); pkg = " +pkg)
atoms = []
version = ''
ver_suffix = ''
if pkg.endswith("*"):
pkg = pkg[:-1]
ver_suffix = '*'
while pkg[0] in ["<",">","=","!","*"]:
#debug.dprint("PORTAGELIB: split_atom_pkg(); pkg = " + str(pkg))
atoms.append(pkg[0])
pkg = pkg[1:]
cplist = portage.catpkgsplit(pkg) or portage.catsplit(pkg)
#debug.dprint("PORTAGELIB: split_atom_pkg(); cplist = " + str(cplist))
if not cplist or len(cplist) < 2:
debug.dprint("PORTAGELIB split_atom_pkg(): issues with '%s'" % pkg)
return ['', '', '']
cp = cplist[0] + "/" + cplist[1]
#debug.dprint("PORTAGELIB: split_atom_pkg(); cplist2 = " + str(cplist))
if cplist:
if len(cplist) >2:
version = cplist[2] + ver_suffix
if len(cplist) >3 and cplist[3] != 'r0':
version += '-' + cplist[3]
return [str(cp), ''.join(atoms), version] # hmm ... unicode keeps appearing :(
def show_invalid_depstring_notice(parent_node, depstring, error_msg):
msg1 = "\n\n!!! Invalid or corrupt dependency specification: " + \
"\n\n%s\n\n%s\n\n" % (error_msg, parent_node)
p_key = parent_node.cpv
p_status = parent_node.operation
msg = []
if p_status == "nomerge":
category, pf = portage.catsplit(p_key)
pkg_location = os.path.join(parent_node.root_config.settings['EROOT'], portage.VDB_PATH, category, pf)
msg.append("Portage is unable to process the dependencies of the ")
msg.append("'%s' package. " % p_key)
msg.append("In order to correct this problem, the package ")
msg.append("should be uninstalled, reinstalled, or upgraded. ")
msg.append("As a temporary workaround, the --nodeps option can ")
msg.append("be used to ignore all dependencies. For reference, ")
msg.append("the problematic dependencies can be found in the ")
msg.append("*DEPEND files located in '%s/'." % pkg_location)
else:
msg.append("This package can not be installed. ")
msg.append("Please notify the '%s' package maintainer " % p_key)
msg.append("about this problem.")
msg2 = "".join("%s\n" % line for line in textwrap.wrap("".join(msg), 72))
writemsg_level(msg1 + msg2, level=logging.ERROR, noiselevel=-1)
def split_atom_pkg(pkg):
"""Extract [category/package, atoms, version] from some ebuild identifier"""
#debug.dprint("PORTAGELIB: split_atom_pkg(); pkg = " + pkg)
atoms = []
cp = ''
version = ''
ver_suffix = ''
try: # ignores failures, but output the erroring pkg
_pkg = pkg
if pkg.endswith("*"):
_pkg = pkg[:-1]
ver_suffix = '*'
while _pkg[0] in ["<", ">", "=", "!", "*"]:
#debug.dprint("PORTAGELIB: split_atom_pkg(); pkg = " + str(_pkg))
atoms.append(_pkg[0])
_pkg = _pkg[1:]
cplist = portage.catpkgsplit(_pkg) or portage.catsplit(_pkg)
#debug.dprint("PORTAGELIB: split_atom_pkg(); cplist = " + str(cplist))
if not cplist or len(cplist) < 2:
debug.dprint("PORTAGELIB: split_atom_pkg(): issues with '%s'" %
_pkg)
return ['', '', '']
cp = cplist[0] + "/" + cplist[1]
#debug.dprint("PORTAGE_2_2.LIB: split_atom_pkg(); cplist2 = " + str(cplist))
if cplist:
if len(cplist) > 2:
version = cplist[2] + ver_suffix
if len(cplist) > 3 and cplist[3] != 'r0':
version += '-' + cplist[3]
except:
debug.dprint("PORTAGELIB: split_atom_pkg(); Error splitting pkg = " +
pkg)
return ['', '', '']
return [cp, ''.join(atoms), version] # hmm ... unicode keeps appearing :(
def _start(self):
vardb = self.pkg.root_config.trees["vartree"].dbapi
dbdir = vardb.getpath(self.pkg.cpv)
if not os.path.exists(dbdir):
# Apparently the package got uninstalled
# already, so we can safely return early.
self.returncode = os.EX_OK
self._async_wait()
return
self.settings.setcpv(self.pkg)
cat, pf = portage.catsplit(self.pkg.cpv)
myebuildpath = os.path.join(dbdir, pf + ".ebuild")
try:
portage.doebuild_environment(myebuildpath,
"prerm",
settings=self.settings,
db=vardb)
except UnsupportedAPIException:
# This is safe to ignore since this function is
# guaranteed to set PORTAGE_BUILDDIR even though
# it raises UnsupportedAPIException. The error
# will be logged when it prevents the pkg_prerm
# and pkg_postrm phases from executing.
pass
self._builddir_lock = EbuildBuildDir(scheduler=self.scheduler,
settings=self.settings)
self._start_task(
AsyncTaskFuture(future=self._builddir_lock.async_lock()),
self._start_unmerge,
)
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 show_invalid_depstring_notice(parent_node, error_msg):
msg1 = "\n\n!!! Invalid or corrupt dependency specification: " + \
"\n\n%s\n\n%s\n\n" % (error_msg, parent_node)
p_key = parent_node.cpv
p_status = parent_node.operation
msg = []
if p_status == "nomerge":
category, pf = portage.catsplit(p_key)
pkg_location = os.path.join(parent_node.root_config.settings['EROOT'],
portage.VDB_PATH, category, pf)
msg.append("Portage is unable to process the dependencies of the ")
msg.append("'%s' package. " % p_key)
msg.append("In order to correct this problem, the package ")
msg.append("should be uninstalled, reinstalled, or upgraded. ")
msg.append("As a temporary workaround, the --nodeps option can ")
msg.append("be used to ignore all dependencies. For reference, ")
msg.append("the problematic dependencies can be found in the ")
msg.append("*DEPEND files located in '%s/'." % pkg_location)
else:
msg.append("This package can not be installed. ")
msg.append("Please notify the '%s' package maintainer " % p_key)
msg.append("about this problem.")
msg2 = "".join("%s\n" % line for line in textwrap.wrap("".join(msg), 72))
writemsg_level(msg1 + msg2, level=logging.ERROR, noiselevel=-1)
def __init__(self, **kwargs):
Task.__init__(self, **kwargs)
self.root = self.root_config.root
self._raw_metadata = _PackageMetadataWrapperBase(self.metadata)
self.metadata = _PackageMetadataWrapper(self, self._raw_metadata)
if not self.built:
self.metadata['CHOST'] = self.root_config.settings.get('CHOST', '')
self.cp = portage.cpv_getkey(self.cpv)
slot = self.slot
if _slot_re.match(slot) is None:
self._invalid_metadata('SLOT.invalid',
"SLOT: invalid value: '%s'" % slot)
# Avoid an InvalidAtom exception when creating slot_atom.
# This package instance will be masked due to empty SLOT.
slot = '0'
if (self.iuse.enabled or self.iuse.disabled) and \
not eapi_has_iuse_defaults(self.metadata["EAPI"]):
if not self.installed:
self._invalid_metadata('EAPI.incompatible',
"IUSE contains defaults, but EAPI doesn't allow them")
self.slot_atom = portage.dep.Atom("%s:%s" % (self.cp, slot))
self.category, self.pf = portage.catsplit(self.cpv)
self.cpv_split = portage.catpkgsplit(self.cpv)
self.pv_split = self.cpv_split[1:]
self._validate_deps()
self.masks = self._masks()
self.visible = self._visible(self.masks)
def _start(self): vardb = self.pkg.root_config.trees["vartree"].dbapi dbdir = vardb.getpath(self.pkg.cpv) if not os.path.exists(dbdir): # Apparently the package got uninstalled # already, so we can safely return early. self.returncode = os.EX_OK self._async_wait() return self.settings.setcpv(self.pkg) cat, pf = portage.catsplit(self.pkg.cpv) myebuildpath = os.path.join(dbdir, pf + ".ebuild") try: portage.doebuild_environment(myebuildpath, "prerm", settings=self.settings, db=vardb) except UnsupportedAPIException: # This is safe to ignore since this function is # guaranteed to set PORTAGE_BUILDDIR even though # it raises UnsupportedAPIException. The error # will be logged when it prevents the pkg_prerm # and pkg_postrm phases from executing. pass self._builddir_lock = EbuildBuildDir( scheduler=self.scheduler, settings=self.settings) self._start_task( AsyncTaskFuture(future=self._builddir_lock.async_lock()), self._start_unmerge)
def scan(self, options, query=None):
env = os.environ
env['MY'] = "<category>/<name>-<version>:<slot> [<overlaynum>]\n"
cmd = ['eix', '--format', '<availableversions:MY>', '--pure-packages', '-x']
if query:
cmd.extend(['--exact', query])
output = subprocess.Popen(cmd, stdout=subprocess.PIPE, env=env).communicate()[0]
output = output.strip().strip('\n')
if len(output) == 0:
if not query:
return
if options['purge-packages']:
if not options['quiet']:
sys.stdout.write('- [p] %s\n' % (query))
if '/' in query:
cat, pkg = portage.catsplit(query)
Package.objects.filter(category=cat, name=pkg).delete()
else:
Package.objects.filter(name=query).delete()
else:
sys.stderr.write(self.style.ERROR("Unknown package '%s'\n" % query))
return
output = output.split('\n')
packages = {}
line_re = re.compile(r'^(?P<cpv>.*?):(?P<slot>.*?) \[(?P<overlay>.*?)\]$')
package = None
for line in output:
match = line_re.match(line)
if not match:
continue
cpv = match.group('cpv')
slot = match.group('slot')
overlay = match.group('overlay')
cat, pkg, ver, rev = portage.catpkgsplit(cpv)
packages['%s/%s' % (cat, pkg)] = True
if not package or not (cat == package.category and pkg == package.name):
package = self.store_package(options, cat, pkg)
self.store_version(options, package, cpv, slot, overlay)
if options['purge-packages'] and not query:
for package in Package.objects.all():
cp = "%s/%s" % (package.category, package.name)
if cp not in packages:
if not options['quiet']:
sys.stdout.write('- [p] %s\n' % (package))
package.delete()
def _start(self):
vardb = self.pkg.root_config.trees["vartree"].dbapi
dbdir = vardb.getpath(self.pkg.cpv)
if not os.path.exists(dbdir):
# Apparently the package got uninstalled
# already, so we can safely return early.
self.returncode = os.EX_OK
self._async_wait()
return
self.settings.setcpv(self.pkg)
cat, pf = portage.catsplit(self.pkg.cpv)
myebuildpath = os.path.join(dbdir, pf + ".ebuild")
try:
portage.doebuild_environment(myebuildpath, "prerm",
settings=self.settings, db=vardb)
except UnsupportedAPIException:
# This is safe to ignore since this function is
# guaranteed to set PORTAGE_BUILDDIR even though
# it raises UnsupportedAPIException. The error
# will be logged when it prevents the pkg_prerm
# and pkg_postrm phases from executing.
pass
self._builddir_lock = EbuildBuildDir(
scheduler=self.scheduler, settings=self.settings)
self._builddir_lock.lock()
portage.prepare_build_dirs(
settings=self.settings, cleanup=True)
# Output only gets logged if it comes after prepare_build_dirs()
# which initializes PORTAGE_LOG_FILE.
retval, pkgmap = _unmerge_display(self.pkg.root_config,
self.opts, "unmerge", [self.pkg.cpv], clean_delay=0,
writemsg_level=self._writemsg_level)
if retval != os.EX_OK:
self._builddir_lock.unlock()
self.returncode = retval
self._async_wait()
return
self._writemsg_level(">>> Unmerging %s...\n" % (self.pkg.cpv,),
noiselevel=-1)
self._emergelog("=== Unmerging... (%s)" % (self.pkg.cpv,))
unmerge_task = MergeProcess(
mycat=cat, mypkg=pf, settings=self.settings,
treetype="vartree", vartree=self.pkg.root_config.trees["vartree"],
scheduler=self.scheduler, background=self.background,
mydbapi=self.pkg.root_config.trees["vartree"].dbapi,
prev_mtimes=self.ldpath_mtimes,
logfile=self.settings.get("PORTAGE_LOG_FILE"), unmerge=True)
self._start_task(unmerge_task, self._unmerge_exit)
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 get_full_name(ebuild):
"""Extract category/package from some ebuild identifier"""
if ebuild.endswith("*"): ebuild = ebuild[:-1]
cplist = portage.catpkgsplit(ebuild) or portage.catsplit(ebuild)
if not cplist or len(cplist) < 2:
dprint("PKGCORE_LIB get_full_name(): issues with '%s'" % ebuild)
return ''
cp = cplist[0] + "/" + cplist[1]
while cp[0] in ["<",">","=","!","*"]: cp = cp[1:]
return str(cp) # hmm ... unicode keeps appearing :(
def scan_portage(packages=None,
category=None,
no_log=False,
upstream=False,
purge_packages=False,
purge_versions=False,
logger=None):
logger = logger or FakeLogger()
scan_handler = ScanPortage(logger=logger,
no_log=no_log,
purge_packages=purge_packages,
purge_versions=purge_versions)
logger.info('Scanning portage tree...')
if not packages:
qs = Package.objects.all()
if category:
qs = qs.filter(category=category)
prefetch_packages = qs
else:
results = []
for package in packages:
if isinstance(package, Package):
results.append(package)
else:
if '/' in package:
cat, pkg = portage.catsplit(package)
qs = Package.objects.filter(category=cat, name=pkg)
else:
qs = Package.objects.filter(name=package)
for package in qs:
results.append(package)
prefetch_packages = results
scan_handler.prefetch(prefetch_packages, category)
if not packages and category:
scan_handler.scan(category=category)
elif not packages:
scan_handler.scan()
else:
for pkg in packages:
if isinstance(pkg, Package):
scan_handler.scan('%s/%s' % (pkg.category, pkg.name))
else:
scan_handler.scan(pkg)
populate_categories(logger)
populate_overlays(logger)
logger.info('Done.')
return scan_handler.packages_updated()
def scan_portage(packages=None, category=None, no_log=False, upstream=False,
purge_packages=False, purge_versions=False, logger=None):
logger = logger or FakeLogger()
scan_handler = ScanPortage(
logger=logger,
no_log=no_log,
purge_packages=purge_packages,
purge_versions=purge_versions
)
logger.info('Scanning portage tree...')
if not packages:
qs = Package.objects.all()
if category:
qs = qs.filter(category=category)
prefetch_packages = qs
else:
results = []
for package in packages:
if isinstance(package, Package):
results.append(package)
else:
if '/' in package:
cat, pkg = portage.catsplit(package)
qs = Package.objects.filter(category=cat, name=pkg)
else:
qs = Package.objects.filter(name=package)
for package in qs:
results.append(package)
prefetch_packages = results
scan_handler.prefetch(prefetch_packages, category)
if not packages and category:
scan_handler.scan(category=category)
elif not packages:
scan_handler.scan()
else:
for pkg in packages:
if isinstance(pkg, Package):
scan_handler.scan('%s/%s' % (pkg.category, pkg.name))
else:
scan_handler.scan(pkg)
populate_categories(logger)
populate_overlays(logger)
logger.info('Done.')
return scan_handler.packages_updated()
def __init__(self, **kwargs):
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 = _PackageMetadataWrapperBase(self.metadata)
self.metadata = _PackageMetadataWrapper(self, self._raw_metadata)
if not self.built:
self.metadata['CHOST'] = self.root_config.settings.get('CHOST', '')
self.cp = portage.cpv_getkey(self.cpv)
slot = self.slot
if _slot_re.match(slot) is None:
self._invalid_metadata('SLOT.invalid',
"SLOT: invalid value: '%s'" % slot)
# Avoid an InvalidAtom exception when creating slot_atom.
# This package instance will be masked due to empty SLOT.
slot = '0'
if (self.iuse.enabled or self.iuse.disabled) and \
not eapi_has_iuse_defaults(self.metadata["EAPI"]):
if not self.installed:
self._invalid_metadata(
'EAPI.incompatible',
"IUSE contains defaults, but EAPI doesn't allow them")
self.slot_atom = portage.dep.Atom("%s%s%s" %
(self.cp, _slot_separator, slot))
self.category, self.pf = portage.catsplit(self.cpv)
self.cpv_split = portage.catpkgsplit(self.cpv)
self.pv_split = self.cpv_split[1:]
if self.inherited is None:
self.inherited = frozenset()
repo = _gen_valid_repo(self.metadata.get('repository', ''))
if not repo:
repo = self.UNKNOWN_REPO
self.metadata['repository'] = repo
self._validate_deps()
self.masks = self._masks()
self.visible = self._visible(self.masks)
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=repo,
root_config=self.root_config,
type_name=self.type_name)
self._hash_value = hash(self._hash_key)
def deserialize(cls, value):
atom = portage.dep.Atom(value)
operator = portage.dep.get_operator(atom)
cpv = portage.dep.dep_getcpv(atom)
category, rest = portage.catsplit(cpv)
if operator:
package, version, revision = portage.pkgsplit(rest)
else:
package = rest
version = ""
operator = ""
return Dependency(category, package, version, operator)
def deserialize(cls, value):
atom = portage.dep.Atom(value)
operator = portage.dep.get_operator(atom)
cpv = portage.dep.dep_getcpv(atom)
category, rest = portage.catsplit(cpv)
if operator:
package, version, revision = portage.pkgsplit(rest)
else:
package = rest
version = ""
operator = ""
return Dependency(category, package, version, operator)
def __init__(self, **kwargs):
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 = _PackageMetadataWrapperBase(self.metadata)
self.metadata = _PackageMetadataWrapper(self, self._raw_metadata)
if not self.built:
self.metadata['CHOST'] = self.root_config.settings.get('CHOST', '')
self.cp = portage.cpv_getkey(self.cpv)
slot = self.slot
if _slot_re.match(slot) is None:
self._invalid_metadata('SLOT.invalid',
"SLOT: invalid value: '%s'" % slot)
# Avoid an InvalidAtom exception when creating slot_atom.
# This package instance will be masked due to empty SLOT.
slot = '0'
if (self.iuse.enabled or self.iuse.disabled) and \
not eapi_has_iuse_defaults(self.metadata["EAPI"]):
if not self.installed:
self._invalid_metadata('EAPI.incompatible',
"IUSE contains defaults, but EAPI doesn't allow them")
self.slot_atom = portage.dep.Atom("%s%s%s" % (self.cp, _slot_separator, slot))
self.category, self.pf = portage.catsplit(self.cpv)
self.cpv_split = portage.catpkgsplit(self.cpv)
self.pv_split = self.cpv_split[1:]
if self.inherited is None:
self.inherited = frozenset()
repo = _gen_valid_repo(self.metadata.get('repository', ''))
if not repo:
repo = self.UNKNOWN_REPO
self.metadata['repository'] = repo
self._validate_deps()
self.masks = self._masks()
self.visible = self._visible(self.masks)
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=repo,
root_config=self.root_config,
type_name=self.type_name)
self._hash_value = hash(self._hash_key)
def split_atom_pkg( pkg ):
"""Extract [category/package, atoms, version] from some ebuild identifier"""
atoms = []
version = ''
if pkg.endswith("*"): pkg = pkg[:-1]
cplist = portage.catpkgsplit(pkg) or portage.catsplit(pkg)
if not cplist or len(cplist) < 2:
dprint("PKGCORE_LIB split_pkg(): issues with '%s'" % pkg)
return ['', '', '']
cp = cplist[0] + "/" + cplist[1]
while cp[0] in ["<",">","=","!","*"]:
atoms.append(cp[0])
cp = cp[1:]
if cplist:
version = cplist[2]
if cplist[3] != 'r0':
version += '-' + cplist[3]
return [str(cp), atoms.join(), version] # hmm ... unicode keeps appearing :(
def _start_unmerge(self, lock_task):
self._assert_current(lock_task)
if lock_task.cancelled:
self._default_final_exit(lock_task)
return
lock_task.future.result()
portage.prepare_build_dirs(settings=self.settings, cleanup=True)
# Output only gets logged if it comes after prepare_build_dirs()
# which initializes PORTAGE_LOG_FILE.
retval, _ = _unmerge_display(
self.pkg.root_config,
self.opts,
"unmerge",
[self.pkg.cpv],
clean_delay=0,
writemsg_level=self._writemsg_level,
)
if retval != os.EX_OK:
self._async_unlock_builddir(returncode=retval)
return
self._writemsg_level(">>> Unmerging %s...\n" % (self.pkg.cpv, ),
noiselevel=-1)
self._emergelog("=== Unmerging... (%s)" % (self.pkg.cpv, ))
cat, pf = portage.catsplit(self.pkg.cpv)
unmerge_task = MergeProcess(
mycat=cat,
mypkg=pf,
settings=self.settings,
treetype="vartree",
vartree=self.pkg.root_config.trees["vartree"],
scheduler=self.scheduler,
background=self.background,
mydbapi=self.pkg.root_config.trees["vartree"].dbapi,
prev_mtimes=self.ldpath_mtimes,
logfile=self.settings.get("PORTAGE_LOG_FILE"),
unmerge=True,
)
self._start_task(unmerge_task, self._unmerge_exit)
def get_package(self, query):
try:
return Package.objects.get(name=query)
except Package.DoesNotExist:
pass
try:
category, package = portage.catsplit(query)
return Package.objects.get(category=category, name=package)
except Package.DoesNotExist:
pass
try:
category, package, ver, rev = portage.catpkgsplit(query)
return Package.objects.get(category=category, name=package)
except Package.DoesNotExist:
pass
return None
def get_package(self, query):
try:
return Package.objects.get(name=query)
except Package.DoesNotExist:
pass
try:
category, package = portage.catsplit(query)
return Package.objects.get(category=category, name=package)
except Package.DoesNotExist:
pass
try:
category, package, ver, rev = portage.catpkgsplit(query)
return Package.objects.get(category=category, name=package)
except Package.DoesNotExist:
pass
return None
def __init__(self, **kwargs):
Task.__init__(self, **kwargs)
self.root = self.root_config.root
self.metadata = _PackageMetadataWrapper(self, self.metadata)
if not self.built:
self.metadata['CHOST'] = self.root_config.settings.get('CHOST', '')
self.cp = portage.cpv_getkey(self.cpv)
slot = self.slot
if _slot_re.match(slot) is None:
self._invalid_metadata('SLOT.invalid',
"SLOT: invalid value: '%s'" % slot)
# Avoid an InvalidAtom exception when creating slot_atom.
# This package instance will be masked due to empty SLOT.
slot = '0'
self.slot_atom = portage.dep.Atom("%s:%s" % (self.cp, slot))
self.category, self.pf = portage.catsplit(self.cpv)
self.cpv_split = portage.catpkgsplit(self.cpv)
self.pv_split = self.cpv_split[1:]
self.masks = self._masks()
self.visible = self._visible(self.masks)
def __init__(self, **kwargs):
Task.__init__(self, **kwargs)
self.root = self.root_config.root
self.metadata = _PackageMetadataWrapper(self, self.metadata)
if not self.built:
self.metadata['CHOST'] = self.root_config.settings.get('CHOST', '')
self.cp = portage.cpv_getkey(self.cpv)
slot = self.slot
if _slot_re.match(slot) is None:
self._invalid_metadata('SLOT.invalid',
"SLOT: invalid value: '%s'" % slot)
# Avoid an InvalidAtom exception when creating slot_atom.
# This package instance will be masked due to empty SLOT.
slot = '0'
self.slot_atom = portage.dep.Atom("%s:%s" % (self.cp, slot))
self.category, self.pf = portage.catsplit(self.cpv)
self.cpv_split = portage.catpkgsplit(self.cpv)
self.pv_split = self.cpv_split[1:]
self.masks = self._masks()
self.visible = self._visible(self.masks)
def get_p(pkg):
"pkg must contain at least the package name"
if not portage.isjustname(pkg):
return portage.catpkgsplit(pkg)[1]
return portage.catsplit(pkg)[-1]
def get_pv(cpv, ver=None):
if not ver:
return portage.catsplit(cpv)[-1]
else:
return get_p(cpv) + '-' + ver
def _start(self):
vardb = self.pkg.root_config.trees["vartree"].dbapi
dbdir = vardb.getpath(self.pkg.cpv)
if not os.path.exists(dbdir):
# Apparently the package got uninstalled
# already, so we can safely return early.
self.returncode = os.EX_OK
self._async_wait()
return
self.settings.setcpv(self.pkg)
cat, pf = portage.catsplit(self.pkg.cpv)
myebuildpath = os.path.join(dbdir, pf + ".ebuild")
try:
portage.doebuild_environment(myebuildpath,
"prerm",
settings=self.settings,
db=vardb)
except UnsupportedAPIException:
# This is safe to ignore since this function is
# guaranteed to set PORTAGE_BUILDDIR even though
# it raises UnsupportedAPIException. The error
# will be logged when it prevents the pkg_prerm
# and pkg_postrm phases from executing.
pass
self._builddir_lock = EbuildBuildDir(scheduler=self.scheduler,
settings=self.settings)
self._builddir_lock.lock()
portage.prepare_build_dirs(settings=self.settings, cleanup=True)
# Output only gets logged if it comes after prepare_build_dirs()
# which initializes PORTAGE_LOG_FILE.
retval, pkgmap = _unmerge_display(self.pkg.root_config,
self.opts,
"unmerge", [self.pkg.cpv],
clean_delay=0,
writemsg_level=self._writemsg_level)
if retval != os.EX_OK:
self._builddir_lock.unlock()
self.returncode = retval
self._async_wait()
return
self._writemsg_level(">>> Unmerging %s...\n" % (self.pkg.cpv, ),
noiselevel=-1)
self._emergelog("=== Unmerging... (%s)" % (self.pkg.cpv, ))
unmerge_task = MergeProcess(
mycat=cat,
mypkg=pf,
settings=self.settings,
treetype="vartree",
vartree=self.pkg.root_config.trees["vartree"],
scheduler=self.scheduler,
background=self.background,
mydbapi=self.pkg.root_config.trees["vartree"].dbapi,
prev_mtimes=self.ldpath_mtimes,
logfile=self.settings.get("PORTAGE_LOG_FILE"),
unmerge=True)
self._start_task(unmerge_task, self._unmerge_exit)
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 set_user_config(filename,
name='',
ebuild='',
comment='',
username='',
add=[],
remove=[],
delete=[]):
"""
Adds <name> or '=' + <ebuild> to <filename> with flags <add>.
If an existing entry is found, items in <remove> are removed
and <add> is added.
If <name> and <ebuild> are not given then lines starting with
something in remove are removed, and items in <add> are added
as new lines.
"""
dprint("SET_CONFIG: set_user_config(): filename = '%s'" % filename)
dprint("SET_CONFIG: set_user_config(): add=%s, remove=%s, delete=%s" %
(str(add), str(remove), str(delete)))
if not chk_permission(filename):
return False
dprint(" * SET_CONFIG: set_user_config(): filename = " + filename)
configlines = get_configlines(filename, username)
config = [line.split() for line in configlines]
if not name:
name = ebuild
done = False
# Check if there is already a line to append to
for line in config:
if not line: continue
#dprint("SET_CONFIG: checking line: " + str(line) )
if line[0] == name and line[0] not in remove:
done = True
dprint("SET_CONFIG: set_user_config(); found line for '%s'" % name)
for flag in remove:
line = remove_flag(flag, line)
for flag in add:
if flag.startswith('+'):
dprint(
"SET_CONFIG: set_user_config(); FIXME! removed leading "
+ "'+' from %s flag" % flag)
flag = flag[1:]
# check for and remove existing occurance(s) of flag
line = remove_flag(flag, line)
if flag not in line:
line.append(flag)
dprint("SET_CONFIG: added '%s' to line" % flag)
elif '+' + flag in line:
dprint("SET_CONFIG: removing existing '+' from '%s' flag" %
flag)
line = remove_flag('+' + flag, line)
line.append(flag)
dprint("SET_CONFIG: added '%s' flag" % flag)
if not line[1:]: # if we've removed everything and added nothing
config[config.index(line)] = []
elif line[0] in remove:
config[config.index(line)] = []
dprint("SET_CONFIG: removed line '%s'" % ' '.join(line))
done = True
if not done: # it did not find a matching line to modify
if "package.use" in filename or "package.keywords" in filename:
if add:
config.append([name] + add)
dprint("SET_CONFIG: added line '%s'" % ' '.join(config[-1]))
elif ebuild:
# Probably tried to modify by ebuild but was listed by package.
# Do a pass with the package name just in case
pkg = ebuild
while pkg[0] in ["<", ">", "=", "!",
"*"]: # remove any leading atoms
pkg = pkg[1:]
import portage
cplist = portage.catpkgsplit(pkg) or portage.catsplit(pkg)
dprint("SET_CONFIG: cplist = " + str(cplist))
if not cplist or len(cplist) < 2:
dprint("SET_CONFIG: issues with '%s'" % pkg)
return
cp = cplist[0] + "/" + cplist[1]
dprint("SET_CONFIG: couldn't find '%s', trying '%s' in stead" %
(ebuild, cp))
return set_user_config(filename, name=cp, remove=remove)
else: # package.mask/unmask: list of names to add
config.extend([[item] for item in add])
dprint("SET_CONFIG: added %d lines to %s" % (len(add), file))
done = True
# add one blank line to end (so we end with a \n)
config.append([''])
configlines = [' '.join(line) for line in config]
configlines = rm_dbl_nl(configlines)
configtext = '\n'.join(configlines)
configfile = open(filename, 'w')
configfile.write(configtext)
configfile.close()
return True
def get_p(pkg):
"pkg must contain at least the package name"
if not portage.isjustname(pkg):
return portage.catpkgsplit(pkg)[1]
return portage.catsplit(pkg)[-1]
p = portage.db[portage.root]["porttree"].dbapi
subdir = "output"
def do_package_use_line(pkg, imps):
if "python3_3" not in imps:
if "python2_7" in imps:
print("%s python_single_target_python2_7" % pkg)
else:
print("%s python_single_target_%s python_targets_%s" %
(pkg, imps[0], imps[0]))
for pkg in p.cp_all():
cp = portage.catsplit(pkg)
ebs = {}
for a in p.xmatch("match-all", pkg):
if len(a) == 0:
continue
aux = p.aux_get(a, ["INHERITED"])
eclasses = aux[0].split()
if "python-single-r1" not in eclasses:
continue
else:
px = portage.catsplit(a)
cmd = '( eval $(cat /usr/portage/%s/%s/%s.ebuild | grep ^PYTHON_COMPAT); echo "${PYTHON_COMPAT[@]}" )' % (
cp[0], cp[1], px[1])
outp = subprocess.getstatusoutput(cmd)
imps = outp[1].split()
ebs[a] = imps
import portage
import subprocess
import os
p = portage.db[portage.root]["porttree"].dbapi
subdir = "output"
def do_package_use_line(pkg, imps):
if "python3_3" not in imps:
if "python2_7" in imps:
print("%s python_single_target_python2_7" % pkg)
else:
print("%s python_single_target_%s python_targets_%s" % (pkg, imps[0], imps[0]))
for pkg in p.cp_all():
cp = portage.catsplit(pkg)
ebs = {}
for a in p.xmatch("match-all", pkg):
if len(a) == 0:
continue
aux = p.aux_get(a, ["INHERITED"])
eclasses=aux[0].split()
if "python-single-r1" not in eclasses:
continue
else:
px = portage.catsplit(a)
cmd = '( eval $(cat /usr/portage/%s/%s/%s.ebuild | grep ^PYTHON_COMPAT); echo "${PYTHON_COMPAT[@]}" )' % ( cp[0], cp[1], px[1] )
outp = subprocess.getstatusoutput(cmd)
imps = outp[1].split()
ebs[a] = imps
if len(ebs.keys()) == 0:
def get_contents(cpv):
cpv = portage.catsplit(cpv)
return set(portage.dblink(cpv[0], cpv[1], root, settings).getcontents().keys())
def get_contents(cpv):
cpv = portage.catsplit(cpv)
return set(
portage.dblink(cpv[0], cpv[1], root, settings).getcontents().keys())
# Generate a slot-sorted hashtable for cpvs
for cpv in not_pmasked:
slot = portdb.aux_get(cpv, ['SLOT'])[0]
if not slot_cpvs.has_key(slot):
slot_cpvs[slot] = []
slot_cpvs[slot].append(cpv)
# Consider each slot separately for obsolete-detection
for (slot, cpvs) in slot_cpvs.iteritems():
all_kws = set()
for cpv in cpvs:
kws = set(get_kws(cpv, arches=ALL_ARCHES))
if cmp_kws(kws, all_kws):
# Keywords list is unique or better, so add it to the list
all_kws.update(kws)
else:
# Same or worse keywords (unstable and stable) => can be punted
obsolete_cpvs.append(cpv)
return obsolete_cpvs
if __name__ == "__main__":
if len(sys.argv) < 2:
usage()
sys.exit(1)
if sys.argv[1] == '.':
sys.argv[1] = '/'.join((os.path.basename(os.path.dirname(os.getcwd())),
os.path.basename(os.getcwd())))
for i in get_obsolete(sys.argv[1]):
print portage.catsplit(i)[-1] + '.ebuild',
def generate_config(kcheck_config: str, outputfile: str = 'kcheck.conf') -> int:
"""
Entry point for generating required kernel configuration items from portage installed packages.
:param kcheck_config: path to kcheck config file for checking existing options
:param outputfile: path to write new keys into (default: 'kcheck.conf' in cwd)
:return: integer to be returned by commandline util (0 for success, etc)
"""
assert isinstance(kcheck_config, str)
log.debug('Module loaded')
master_config = configparser.ConfigParser(allow_no_value=True)
if _add_to_config:
log.debug('Opening config file')
if os.path.isfile(kcheck_config):
master_config.read(kcheck_config)
log.debug('Config loaded')
else:
log.debug('No config file to open')
# config object in which to add new keys
config = configparser.ConfigParser(allow_no_value=True, dict_type=OrderedDict)
# much of this section of code based on `kernel-config-check.py` by mrueg
log.debug('Finding installed packages with kernel checks')
verbose_print('Finding ebuilds...')
ebuild_paths = []
vartree = portage.db[portage.root]['vartree']
all_cpv = vartree.dbapi.cpv_all()
for cpv in all_cpv:
inherit = vartree.dbapi.aux_get(cpv, ['INHERITED'])[0]
if 'linux-info' in inherit:
pv = portage.catsplit(cpv)[1]
ebuild_paths.append(vartree.dbapi.getpath(cpv)+'/'+pv+'.ebuild')
log.info('Got %d ebuilds inheriting kernel utilties' % len(ebuild_paths))
symbols = []
symbol_count = 0
errors = 0
# check listed ebuilds for known kernel config check helpers
verbose_print('Checking %d ebuilds' % len(ebuild_paths))
for ebuild in ebuild_paths:
log.debug('Checking ebuild %s' % ebuild)
# little helper object to save code repetition
option = {
'linux_chkconfig_present': 'YM',
'linux_chkconfig_module': 'M',
'linux_chkconfig_builtin': 'Y'
}
esymbols = 0
eerrors = 0
for line in open(ebuild).readlines():
line = line.strip()
match = re_sym.match(line)
if not match:
continue
try:
checker = match.group(1)
mode = option[checker]
symbol = match.group(2)
except AttributeError:
log.error('Failed getting symbol from line: %s' % line)
eerrors += 1
continue
# check if symbol already found, warn if so
if symbol in symbols:
log.warning('Additional instance of symbol %s found with value %s' % (symbol, mode))
verbose_print('Found additional instance of %s - only the first will be used' % bold(symbol))
continue
log.debug('Got symbol %s using %s (%s)' % (symbol, checker, mode))
# check if we already have this symbol in the master config
try:
notused = master_config['ternary'][symbol]
# no exception, so it already exists
log.warning('Symbol %s found in master config - skipping' % symbol)
verbose_print('Symbol %s already in config' % bold(symbol))
del notused
continue
except KeyError:
# nothing to see here
pass
except configparser.NoSectionError:
# These are not the exceptions you're looking for. Move along
pass
esymbols += 1
if _add_to_config:
# make sure the section exists
if 'ternary' not in config.sections():
config.add_section('ternary')
source = os.path.basename(ebuild)
config.set('ternary', '; from %s' % source)
config.set('ternary', symbol, mode)
verbose_print(' Got symbol %s using %s (%s)' % (bold(symbol), checker, yellow(mode)))
log.info('Got %d symbols and %d errors from ebuild' % (esymbols, eerrors))
symbol_count += esymbols
errors += eerrors
verbose_print('Got %s symbols and %s errors from %s ebuilds' % (bold(symbol_count), yellow(errors), green(len(ebuild_paths))))
# write out (if necessary)
if _add_to_config:
log.info('Writing values to config file')
with open(outputfile, 'w') as fh:
config.write(fh)
log.debug('Config file written')
print('%s discovered required symbol(s) written to %s.' % (bold(symbol_count), green(outputfile)))
# return with how many failed reads we go (the only really significant error count here)
return errors
not_pmasked.reverse()
# Generate a slot-sorted hashtable for cpvs
for cpv in not_pmasked:
slot = portdb.aux_get(cpv, ['SLOT'])[0]
if not slot_cpvs.has_key(slot):
slot_cpvs[slot] = []
slot_cpvs[slot].append(cpv)
# Consider each slot separately for obsolete-detection
for (slot, cpvs) in slot_cpvs.iteritems():
all_kws = set()
for cpv in cpvs:
kws = set(get_kws(cpv, arches=ALL_ARCHES))
if cmp_kws(kws, all_kws):
# Keywords list is unique or better, so add it to the list
all_kws.update(kws)
else:
# Same or worse keywords (unstable and stable) => can be punted
obsolete_cpvs.append(cpv)
return obsolete_cpvs
if __name__ == "__main__":
if len(sys.argv) < 2:
usage()
sys.exit(1)
if sys.argv[1] == '.':
sys.argv[1] = '/'.join((os.path.basename(os.path.dirname(os.getcwd())), os.path.basename(os.getcwd())))
for i in get_obsolete(sys.argv[1]):
print portage.catsplit(i)[-1]+'.ebuild',
def process(mysettings, key, logentries, fulltext):
if mysettings.get("PORTAGE_LOGDIR"):
logdir = normalize_path(mysettings["PORTAGE_LOGDIR"])
else:
logdir = os.path.join(os.sep, mysettings["EPREFIX"].lstrip(os.sep),
"var", "log", "portage")
if not os.path.isdir(logdir):
# Only initialize group/mode if the directory doesn't
# exist, so that we don't override permissions if they
# were previously set by the administrator.
# NOTE: These permissions should be compatible with our
# default logrotate config as discussed in bug 374287.
uid = -1
if portage.data.secpass >= 2:
uid = portage_uid
ensure_dirs(logdir, uid=uid, gid=portage_gid, mode=0o2770)
cat, pf = portage.catsplit(key)
elogfilename = pf + ":" + _unicode_decode(
time.strftime("%Y%m%d-%H%M%S", time.gmtime(time.time())),
encoding=_encodings['content'], errors='replace') + ".log"
if "split-elog" in mysettings.features:
log_subdir = os.path.join(logdir, "elog", cat)
elogfilename = os.path.join(log_subdir, elogfilename)
else:
log_subdir = os.path.join(logdir, "elog")
elogfilename = os.path.join(log_subdir, cat + ':' + elogfilename)
_ensure_log_subdirs(logdir, log_subdir)
try:
with io.open(_unicode_encode(elogfilename,
encoding=_encodings['fs'], errors='strict'), mode='w',
encoding=_encodings['content'],
errors='backslashreplace') as elogfile:
elogfile.write(_unicode_decode(fulltext))
except IOError as e:
func_call = "open('%s', 'w')" % elogfilename
if e.errno == errno.EACCES:
raise portage.exception.PermissionDenied(func_call)
elif e.errno == errno.EPERM:
raise portage.exception.OperationNotPermitted(func_call)
elif e.errno == errno.EROFS:
raise portage.exception.ReadOnlyFileSystem(func_call)
else:
raise
# Copy group permission bits from parent directory.
elogdir_st = os.stat(log_subdir)
elogdir_gid = elogdir_st.st_gid
elogdir_grp_mode = 0o060 & elogdir_st.st_mode
# Copy the uid from the parent directory if we have privileges
# to do so, for compatibility with our default logrotate
# config (see bug 378451). With the "su portage portage"
# directive and logrotate-3.8.0, logrotate's chown call during
# the compression phase will only succeed if the log file's uid
# is portage_uid.
logfile_uid = -1
if portage.data.secpass >= 2:
logfile_uid = elogdir_st.st_uid
apply_permissions(elogfilename, uid=logfile_uid, gid=elogdir_gid,
mode=elogdir_grp_mode, mask=0)
return elogfilename
def get_pv(cpv, ver=None):
if not ver:
return portage.catsplit(cpv)[-1]
else:
return get_p(cpv) + '-' + ver
def process(mysettings, key, logentries, fulltext):
if mysettings.get("PORT_LOGDIR"):
logdir = normalize_path(mysettings["PORT_LOGDIR"])
else:
logdir = os.path.join(os.sep, mysettings["EPREFIX"].lstrip(os.sep),
"var", "log", "portage")
if not os.path.isdir(logdir):
# Only initialize group/mode if the directory doesn't
# exist, so that we don't override permissions if they
# were previously set by the administrator.
# NOTE: These permissions should be compatible with our
# default logrotate config as discussed in bug 374287.
uid = -1
if portage.data.secpass >= 2:
uid = portage_uid
ensure_dirs(logdir, uid=uid, gid=portage_gid, mode=0o2770)
cat, pf = portage.catsplit(key)
elogfilename = pf + ":" + _unicode_decode(time.strftime(
"%Y%m%d-%H%M%S", time.gmtime(time.time())),
encoding=_encodings['content'],
errors='replace') + ".log"
if "split-elog" in mysettings.features:
log_subdir = os.path.join(logdir, "elog", cat)
elogfilename = os.path.join(log_subdir, elogfilename)
else:
log_subdir = os.path.join(logdir, "elog")
elogfilename = os.path.join(log_subdir, cat + ':' + elogfilename)
_ensure_log_subdirs(logdir, log_subdir)
try:
with io.open(_unicode_encode(elogfilename,
encoding=_encodings['fs'],
errors='strict'),
mode='w',
encoding=_encodings['content'],
errors='backslashreplace') as elogfile:
elogfile.write(_unicode_decode(fulltext))
except IOError as e:
func_call = "open('%s', 'w')" % elogfilename
if e.errno == errno.EACCES:
raise portage.exception.PermissionDenied(func_call)
elif e.errno == errno.EPERM:
raise portage.exception.OperationNotPermitted(func_call)
elif e.errno == errno.EROFS:
raise portage.exception.ReadOnlyFileSystem(func_call)
else:
raise
# Copy group permission bits from parent directory.
elogdir_st = os.stat(log_subdir)
elogdir_gid = elogdir_st.st_gid
elogdir_grp_mode = 0o060 & elogdir_st.st_mode
# Copy the uid from the parent directory if we have privileges
# to do so, for compatibility with our default logrotate
# config (see bug 378451). With the "su portage portage"
# directive and logrotate-3.8.0, logrotate's chown call during
# the compression phase will only succeed if the log file's uid
# is portage_uid.
logfile_uid = -1
if portage.data.secpass >= 2:
logfile_uid = elogdir_st.st_uid
apply_permissions(elogfilename,
uid=logfile_uid,
gid=elogdir_gid,
mode=elogdir_grp_mode,
mask=0)
return elogfilename
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)
#!/usr/bin/env python
# Checking installed packages using linux-info.eclass
# for necessary kernel options
import portage
vartree = portage.db[portage.root]['vartree']
all_cpvs = vartree.dbapi.cpv_all()
settings = portage.config()
for cpv in all_cpvs:
inherit = vartree.dbapi.aux_get(cpv, ['INHERITED'])[0]
if 'linux-info' in inherit:
pv = portage.catsplit(cpv)[1]
cpvpath = vartree.dbapi.getpath(cpv) + '/' + pv + '.ebuild'
print('Checking: ' + cpv)
portage.doebuild(cpvpath,
'clean',
settings=settings,
tree='vartree',
vartree=vartree)
portage.doebuild(cpvpath,
'setup',
settings=settings,
tree='vartree',
vartree=vartree)
