def __init__(self):
self._publish = Gate().grants('gentoo', 'repositories')
self._fill_overlays()
tree_config = config()
tree_config['PORTDIR_OVERLAY'] = ' '.join(self._get_active_paths())
tree_config['PORTDIR'] = main_tree_dir()
self._dbapi = portdbapi(main_tree_dir(), tree_config)
def __init__(self):
self._publish = Gate().grants('gentoo', 'repositories')
self._fill_overlays()
tree_config = config()
tree_config['PORTDIR_OVERLAY'] = ' '.join(self._get_active_paths())
tree_config['PORTDIR'] = main_tree_dir()
self._dbapi = portdbapi(main_tree_dir(), tree_config)
def get_atom(package):
"""Return the atom for a specified package name."""
try:
atom = cpv_expand.cpv_expand(package, mydb=porttree.portdbapi())
except AmbiguousPackageName as e:
print('Found several matches for "%s": %s' % (package, e))
return None
return atom if not atom.startswith('null/') else None
def getAllMeta(metadata, ebuild_repo, super_repo=None):
print("EBUILD REPO", ebuild_repo.root, "SUPER_REPO", super_repo.root)
metadict = { "LICENSE" : 0, "INHERITED" : 1 }
metapos = metadict[metadata]
# ebuild_repo is where we get the set of all packages for our loop:
eb_name = ebuild_repo.reponame if ebuild_repo.reponame else repoName(ebuild_repo)
env = os.environ.copy()
# super_repo contains all ebuilds in ebuild_repo AND eclasses
if super_repo:
super_name = super_repo.reponame if super_repo.reponame else repoName(super_repo)
env['PORTAGE_REPOSITORIES'] = '''
[DEFAULT]
main-repo = gentoo
[gentoo]
location = %s
[%s]
location = %s
eclass-overrides = gentoo
aliases = -gentoo
masters = gentoo
''' % ( super_repo.root, eb_name, ebuild_repo.root)
else:
env['PORTAGE_REPOSITORIES'] = '''
[DEFAULT]
main-repo = %s
[%s]
location = %s
''' % ( eb_name, eb_name, eb_name, ebuild_repo.root )
print(env['PORTAGE_REPOSITORIES'])
p = portdbapi(mysettings=portage.config(env=env,config_profile_path=''))
p.frozen = False
myeclasses = set()
for cp in p.cp_all(trees=[ebuild_repo.root]):
for cpv in p.cp_list(cp, mytree=ebuild_repo.root):
try:
aux = p.aux_get(cpv, ["LICENSE","INHERITED"], mytree=ebuild_repo.root)
except PortageKeyError:
print("Portage key error for %s" % repr(cpv))
raise
if metadata == "INHERITED":
for eclass in aux[metapos].split():
key = eclass + ".eclass"
if key not in myeclasses:
myeclasses.add(key)
elif metadata == "LICENSE":
for lic in aux[metapos].split():
if lic not in myeclasses:
myeclasses.add(lic)
return myeclasses
def get_repo_info(self):
"""
Get portage repos informations and return formatted
"""
logger = logging.getLogger(f'::{self.__logger_name}::get_repo_info::')
# Generic infos
infos = {
'names': [],
'formatted': 'unknow',
'count': '(?)',
'msg': 'repo',
'failed': [],
'success': []
}
names = portdbapi().getRepositories()
if names:
names = sorted(names)
count = len(names)
msg = 'repositories'
# get only first 6 elements if names > 6
if count > 6:
formatted = ', '.join(names[:6]) + ' (+' + str(count - 6) + ')'
elif count == 1:
msg = 'repository'
formatted = ''.join(names)
else:
formatted = ', '.join(names)
logger.debug(f"Informations extracted for {count} {msg}: "
f"{','.join(names)}")
infos['names'] = names
infos['formatted'] = formatted
infos['count'] = count
infos['msg'] = msg
return infos
logger.error("Failed to extract repositories informations"
" from portdbapi().getRepositories()")
return infos
def available_portage_update(self, detected=False, init=False):
"""
Check if an update to portage is available.
"""
# TODO: be more verbose for debug !
name = 'available_portage_update'
logger = logging.getLogger(f'{self.__logger_name}{name}::')
logger.debug(f"Running with detected={detected}, init={init}")
self.available = False
self.latest = False
self.current = False
# First, any way get installed and latest
current = vardbapi().match('portage')[0]
latest = portdbapi().xmatch('bestmatch-visible', 'portage')
# Then just compare
# From site-packages/portage/versions.py
# @param mypkg: either a pv or cpv
# @return:
# 1. None if input is invalid.
# 2. (pn, ver, rev) if input is pv
# 3. (cp, ver, rev) if input is a cpv
result = pkgcmp(pkgsplit(latest), pkgsplit(current))
# From site-packages/portage/versions.py
# Parameters:
# pkg1 (list (example: ['test', '1.0', 'r1'])) -
# package to compare with
# pkg2 (list (example: ['test', '1.0', 'r1'])) -
# package to compare againts
# Returns: None or integer
# None if package names are not the same
# 1 if pkg1 is greater than pkg2
# -1 if pkg1 is less than pkg2
# 0 if pkg1 equals pkg2
if result == None or result == -1:
msg = 'no result (package names are not the same ?!)'
if result == -1:
msg = ('the latest version available is lower than the'
' one installed...')
logger.error("FAILED to compare versions when obtaining update "
"informations for the portage package.")
logger.error(f"Result is: {msg}")
logger.error(f"Current portage version: {current}, latest:"
f" {latest}.")
# Return is ignored for the moment...
# TODO ??
return
# Split current version
# as we don't know yet if latest > current
split = pkgsplit(current)
self.current = split[1]
if not split[2] == 'r0':
self.current = '-'.join(split[-2:])
# Check if an update to portage is available
if result:
# Now, split latest because > current
split = pkgsplit(latest)
self.latest = split[1]
if not split[2] == 'r0':
self.latest = '-'.join(split[-2:])
logger.debug(f"Found an update to portage (from {self.current}"
f" to {self.latest}).")
# Print only one time when program start
if init:
logger.info("Found an update to portage (from "
f"{self.current} to {self.latest}).")
self.available = True
else:
logger.debug("No update to portage package is available"
f" (current version: {self.current})")
self.available = False
# For detected we have to compare current extracted
# version and last current know version (so from
# self.portage['current']. Both versions are already
# split
if detected:
# From site-packages/portage/versions.py
# Compare two versions
# Example usage:
# >>> from portage.versions import vercmp
# >>> vercmp('1.0-r1','1.2-r3')
# negative number
# >>> vercmp('1.3','1.2-r3')
# positive number
# >>> vercmp('1.0_p3','1.0_p3')
# 0
# @param pkg1: version to compare with
# (see ver_regexp in portage.versions.py)
# @type pkg1: string (example: "2.1.2-r3")
# @param pkg2: version to compare againts
# (see ver_regexp in portage.versions.py)
# @type pkg2: string (example: "2.1.2_rc5")
# @rtype: None or float
# @return:
# 1. positive if ver1 is greater than ver2
# 2. negative if ver1 is less than ver2
# 3. 0 if ver1 equals ver2
# 4. None if ver1 or ver2 are invalid
# (see ver_regexp in portage.versions.py)
compare = vercmp(self.portage['current'], self.current)
msg = False
add_msg = ''
if compare < 0:
# If not available and it have been updated
# than it have been updated to latest one
if not self.available:
add_msg = 'latest '
msg = (f"The portage package has been updated (from "
f"{self.portage['current']} to "
f"{add_msg}{self.current}).")
elif compare > 0:
# Same here but reversed: if it was not
# available (self.portage['available'])
# and now it is (self.available) than
# it have been downgraded from latest.
if not self.portage['available'] and self.available:
add_msg = 'latest '
msg = (f"The portage package has been downgraded (from "
f"{add_msg}{self.portage['current']} to "
f"{self.current}).")
elif compare == 0:
# This have been aborted
msg = ("The portage package process has been aborted.")
# Just skipp if msg = False
# so that mean compare == None
if msg:
logger.info(msg)
tosave = []
# Update only if change
for key in 'current', 'latest', 'available':
if not self.portage[key] == getattr(self, key):
# This print if there a new version of portage available
# even if there is already an older version available
# TEST: if checking only for key latest than it could
# be == to current so check also result.
if key == 'latest' and result:
logger.info("Found an update to portage (from "
f"{self.current} to {self.latest}).")
self.portage[key] = getattr(self, key)
tosave.append([f'portage {key}', self.portage[key]])
if tosave:
self.stateinfo.save(*tosave)
import os
import sys
import portage
from portage.dbapi.porttree import portdbapi
portdir = os.path.realpath(sys.argv[1])
env = {}
env["PORTAGE_REPOSITORIES"] = """
[gentoo_prefix]
location = %s
""" % portdir
settings = portage.config(env=env)
portdb = portdbapi(mysettings=settings)
portdb.porttrees = [portdir]
for i in range(2, len(sys.argv)):
for ebuild in portdb.cp_list(sys.argv[i]):
for distfile in portdb.getFetchMap(ebuild):
print(distfile)
#!/usr/bin/python
from portage.dbapi.porttree import portdbapi
import subprocess
TREE = "/usr/portage/"
dbapi = portdbapi()
pkgs = dbapi.cp_all(categories=None, trees=[TREE])
for pkg in pkgs:
res = subprocess.call("egrep -q \"SLOT=\\\"?[0-9]*\/\" %s/%s/*.ebuild" % (TREE, pkg), shell=True)
if res == 0:
print("%s" % pkg)
def __init__(self):
self.dbapi = portdbapi()
self.subslottedCp = []
with open("subslotted-packages.txt", "r") as f:
for line in f:
self.subslottedCp.append(line[:-1])
#!/usr/bin/python
from portage.dbapi.porttree import portdbapi
import subprocess
TREE = "/usr/portage/"
dbapi = portdbapi()
pkgs = dbapi.cp_all(categories=None, trees=[TREE])
for pkg in pkgs:
res = subprocess.call("egrep -q \"SLOT=\\\"?[0-9]*\/\" %s/%s/*.ebuild" %
(TREE, pkg),
shell=True)
if res == 0:
print("%s" % pkg)
def __init__(self):
self.dbapi = portdbapi()
self.subslottedCp = []
with open("subslotted-packages.txt", "r") as f:
for line in f:
self.subslottedCp.append(line[:-1])
