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 __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 __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
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 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)