def check_repoman(self, cpv, repo):
# We run repoman run_checks on the ebuild
ebuild_version_tree = portage.versions.cpv_getversion(cpv)
element = portage.versions.cpv_getkey(cpv).split('/')
categories = element[0]
package = element[1]
pkgdir = self._myportdb.getRepositoryPath(repo) + "/" + categories + "/" + package
full_path = pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild"
root = '/'
trees = {
root : {'porttree' : portage.portagetree(root, settings=self._mysettings)}
}
root_config = RootConfig(self._mysettings, trees[root], None)
allvars = set(x for x in portage.auxdbkeys if not x.startswith("UNUSED_"))
allvars.update(Package.metadata_keys)
allvars = sorted(allvars)
myaux = dict(zip(allvars, self._myportdb.aux_get(cpv, allvars, myrepo=repo)))
pkg = Package(cpv=cpv, metadata=myaux, root_config=root_config, type_name='ebuild')
fails = []
try:
# All ebuilds should have utf_8 encoding.
f = codecs.open(_unicode_encode(full_path,
encoding = _encodings['fs'], errors = 'strict'),
mode = 'r', encoding = _encodings['repo.content'])
try:
for check_name, e in run_checks(f, pkg):
fails.append(check_name + ": " + e)
finally:
f.close()
except UnicodeDecodeError:
# A file.UTF8 failure will have already been recorded above.
pass
# fails will have a list with repoman errors
return fails
def gentoo_version(self):
if not self.error:
portage = portagetree()
versions = portage.dep_match(self.atom)
if len(versions) == 0:
raise Exception('package not found %r' % self.atom)
last_atom = versions[-1]
cp, pv, rev = pkgsplit(last_atom)
return pv
def main():
""" Main function """
api = portage.portdbapi()
api._aux_cache_keys.clear()
api._aux_cache_keys.update(["EAPI", "KEYWORDS", "SLOT"])
root = '/'
trees = {
root : {'porttree' : portage.portagetree(root)}
}
portdb = trees[root]['porttree'].dbapi
#portdb._aux_cache_keys.clear()
#portdb._aux_cache_keys.update(["EAPI", "KEYWORDS", "SLOT"])
#pprint(api.porttrees)
for atom in sys.argv:
arches = {}
keywords = {}
best_revision = {}
need_keyword = {}
revisions = api.cp_list(atom, mytree=api.porttrees[0])
rev_keywords = {}
max_arch_list = []
# Select best revision
revisions.sort(package_sort)
# Build maximum possible arches list
for revision in revisions:
# print revision
aux_kw, slot = api.aux_get(revision, ['KEYWORDS', 'SLOT'])
aux_kw = [kw for kw in aux_kw.replace('~', '').split() if kw and not kw.startswith('-') and kw not in ARCH_DEV and kw not in ARCH_EXP]
# Build best set of keywords per SLOT
for kw in aux_kw:
if slot in keywords:
if kw not in keywords[slot]:
keywords[slot].append(kw)
else:
keywords[slot] = [kw]
if not keywords or not slot in keywords:
revisions.remove(revision)
else:
if revision.endswith("9999"):
revisions.remove(revision)
continue
best_revision[slot] = revision
keywords[slot] = ARCH_GNOME
need_keyword[slot] = [kw for kw in keywords[slot] if kw not in aux_kw]
# Show missing arches
for slot in keywords:
if need_keyword[slot]:
# keycheck_incrementals = tuple(x for x in portage.const.INCREMENTALS if x != 'ACCEPT_KEYWORDS')
# for package.use.mask support inside dep_check
# dep_settings = portage.config(
# config_incrementals = keycheck_incrementals,
# local_config = False)
# dep_settings.setcpv(revision)
# dep_settings["ACCEPT_KEYWORDS"] = " ".join(keywords[slot] + need_keyword[slot])
#
# for dep_type in ('DEPEND', 'RDEPEND', 'PDEPEND'):
# aux_dep = api.aux_get(revision, [dep_type])[0]
# print portage.dep_check(aux_dep, portdb, dep_settings, use='all', trees=trees, mode='minimum-visible')
#
kw_print = ""
for kw in ARCH_GNOME:
kw_print += " "
if kw in need_keyword[slot]:
kw_print += kw
else:
kw_print += " " * len(kw)
print "%-60s:" % best_revision[slot], kw_print
import portage
import os
import re
import portage.xml.metadata
from xml.etree.ElementTree import ParseError
from urllib.parse import urlparse
from collections import namedtuple
# local_config=False tells this to ignore all changes in /etc/portage
SETTINGS = portage.config(local_config=False)
PORTTREE = portage.portagetree(settings=SETTINGS).dbapi
class VersionMaskedException(Exception):
pass
# As far as I'm aware these are not formally defined anywhere, so we're making up the sets as we go
def arch_list():
name = "Default"
DEFAULT = ["alpha", "amd64", "arm", "hppa", "ia64", "ppc", "ppc64", "sparc", "x86"]
if name == "FreeBSD":
return frozenset([arch for arch in self.valid_arches() if arch.endswith('-fbsd')])
if name == "Prefix":
# Warning: This will fail if we ever include more archs with hyphens than fbsd
return frozenset([arch for arch in self.valid_arches() if "-" in arch and not arch.endswith('-fbsd')])
import os
import sys
import portage
if len(sys.argv) != 2 or not portage.isvalidatom(sys.argv[1]):
sys.stderr.write("usage: %s <atom>\n" % os.path.basename(sys.argv[0]))
sys.exit(1)
input_atom = portage.dep.Atom(sys.argv[1])
settings = portage.config(config_profile_path="",
local_config=False)
settings["ACCEPT_KEYWORDS"] = "**"
settings.backup_changes("ACCEPT_KEYWORDS")
settings.lock()
porttree = portage.portagetree(settings=settings)
portdb = porttree.dbapi
trees = {"/" : {"porttree":porttree}}
dep_keys = ("DEPEND", "RDEPEND", "PDEPEND")
for cp in portdb.cp_all():
for cpv in portdb.cp_list(cp):
metadata = dict(zip(dep_keys,
portdb.aux_get(cpv, dep_keys)))
dep_str = " ".join(metadata[k] for k in dep_keys)
success, atoms = portage.dep_check(dep_str,
None, settings, use="all",
trees=trees, myroot=settings["ROOT"])
if not success:
sys.stderr.write("%s %s\n" % (cpv, atoms))
