# Default distfiles mirrors
GENTOO_MIRRORS="http://distfiles.gentoo.org http://distro.ibiblio.org/pub/linux/distributions/gentoo"
+ACCEPT_LICENSE="* -@EULA"
+ACCEPT_PROPERTIES="*"
+
# Repository Paths
PORTDIR="@PORTAGE_EPREFIX@/usr/portage"
DISTDIR="@PORTAGE_EPREFIX@/usr/portage/distfiles"
required_sets[s] = InternalPackageSet(
initial_atoms=getSetAtoms(s))
-
+
# When removing packages, use a temporary version of world
# which excludes packages that are intended to be eligible for
# removal.
def cmp_reference_count(node1, node2):
return node_refcounts[node1] - node_refcounts[node2]
graph.order.sort(key=cmp_sort_key(cmp_reference_count))
-
+
ignore_priority_range = [None]
ignore_priority_range.extend(
range(UnmergeDepPriority.MIN, UnmergeDepPriority.MAX + 1))
portage.writemsg(yellow("WARNING:") + " adding required option " + \
"%s not included in PORTAGE_RSYNC_OPTS\n" % opt)
rsync_opts.append(opt)
-
+
for exclude in ("distfiles", "local", "packages"):
opt = "--exclude=/%s" % exclude
if opt not in rsync_opts:
" adding required option %s not included in " % opt + \
"PORTAGE_RSYNC_OPTS (can be overridden with --exclude='!')\n")
rsync_opts.append(opt)
-
+
if syncuri.rstrip("/").endswith(".gentoo.org/gentoo-portage"):
def rsync_opt_startswith(opt_prefix):
for x in rsync_opts:
print()
print(red(" * ")+"To update portage, run 'emerge portage' now.")
print()
-
+
display_news_notification(root_config, myopts)
return os.EX_OK
UNREAD_PATH = os.path.join(target_root, NEWS_LIB_PATH, "news")
newsReaderDisplay = False
update = "--pretend" not in myopts
+ if "news" not in settings.features:
+ return
if not settings.treeVirtuals:
# Populate these using our existing vartree, to avoid
print()
print(colorize("WARN", " * IMPORTANT:"), end=' ')
print("%s news items need reading for repository '%s'." % (unreadItems, repo))
-
-
+
+
if newsReaderDisplay:
print(colorize("WARN", " *"), end=' ')
print("Use " + colorize("GOOD", "eselect news") + " to read news items.")
"""
Examines news items in repodir + '/' + NEWS_PATH and attempts to find unread items
Returns the number of unread (yet relevent) items.
-
+
@param portdb: a portage tree database
@type portdb: pordbapi
@param vardb: an installed package database
@rtype: Integer
@returns:
1. The number of unread but relevant news items.
-
+
"""
from portage.news import NewsManager
manager = NewsManager(portdb, vardb, NEWS_PATH, UNREAD_PATH)
_environ_filter = frozenset(_environ_filter)
+ _undef_lic_groups = set()
+ _default_globals = (
+ ('ACCEPT_LICENSE', '* -@EULA'),
+ ('ACCEPT_PROPERTIES', '*'),
+ )
+
def __init__(self, clone=None, mycpv=None, config_profile_path=None,
config_incrementals=None, config_root=None, target_root=None,
local_config=True, env=None):
if self.mygcfg is None:
self.mygcfg = {}
+ for k, v in self._default_globals:
+ self.mygcfg.setdefault(k, v)
+
self.configlist.append(self.mygcfg)
self.configdict["globals"]=self.configlist[-1]
else:
rValue.extend(self._expandLicenseToken(l, traversed_groups))
else:
- writemsg(_("Undefined license group '%s'\n") % group_name,
- noiselevel=-1)
+ if self._license_groups and \
+ group_name not in self._undef_lic_groups:
+ self._undef_lic_groups.add(group_name)
+ writemsg(_("Undefined license group '%s'\n") % group_name,
+ noiselevel=-1)
rValue.append("@"+group_name)
if negate:
rValue = ["-" + token for token in rValue]
@rtype: List
@return: A list of licenses that have not been accepted.
"""
- if not self._accept_license:
- return []
accept_license = self._accept_license
cpdict = self._plicensedict.get(dep_getkey(cpv), None)
if cpdict:
@rtype: List
@return: A list of properties that have not been accepted.
"""
- if not self._accept_properties:
- return []
accept_properties = self._accept_properties
cpdict = self._ppropertiesdict.get(dep_getkey(cpv), None)
if cpdict:
# env_d will be None if profile.env doesn't exist.
self.configdict["env.d"].update(env_d)
+ def _prune_incremental(self, split):
+ """
+ Prune off any parts of an incremental variable that are
+ made irrelevant by the latest occuring * or -*. This
+ could be more aggressive but that might be confusing
+ and the point is just to reduce noise a bit.
+ """
+ for i, x in enumerate(reversed(split)):
+ if x == '*':
+ split = split[-i-1:]
+ break
+ elif x == '-*':
+ if i == 0:
+ split = []
+ else:
+ split = split[-i:]
+ break
+ return split
+
def regenerate(self,useonly=0,use_cache=1):
"""
Regenerate settings
mysplit = []
for curdb in mydbs:
mysplit.extend(curdb.get('ACCEPT_LICENSE', '').split())
+ mysplit = self._prune_incremental(mysplit)
accept_license_str = ' '.join(mysplit)
- if accept_license_str:
- self.configlist[-1]['ACCEPT_LICENSE'] = accept_license_str
+ self.configlist[-1]['ACCEPT_LICENSE'] = accept_license_str
if accept_license_str != self._accept_license_str:
self._accept_license_str = accept_license_str
self._accept_license = tuple(self.expandLicenseTokens(mysplit))
else:
# repoman will accept any license
- self._accept_license = ()
+ self._accept_license = ('*',)
# ACCEPT_PROPERTIES works like ACCEPT_LICENSE, without groups
if self.local_config:
mysplit = []
for curdb in mydbs:
mysplit.extend(curdb.get('ACCEPT_PROPERTIES', '').split())
- if mysplit:
- self.configlist[-1]['ACCEPT_PROPERTIES'] = ' '.join(mysplit)
+ mysplit = self._prune_incremental(mysplit)
+ self.configlist[-1]['ACCEPT_PROPERTIES'] = ' '.join(mysplit)
if tuple(mysplit) != self._accept_properties:
self._accept_properties = tuple(mysplit)
else:
# repoman will accept any property
- self._accept_properties = ()
+ self._accept_properties = ('*',)
for mykey in myincrementals:
mypv = os.path.basename(ebuild_path)[:-7]
mycpv = cat+"/"+mypv
- mysplit=pkgsplit(mypv,silent=0)
+ mysplit = versions._pkgsplit(mypv)
if mysplit is None:
raise portage.exception.IncorrectParameter(
_("Invalid ebuild path: '%s'") % myebuild)
% (mycpv,), DeprecationWarning)
myslash = mycpv.split("/", 1)
- mysplit=pkgsplit(myslash[-1])
+ mysplit = versions._pkgsplit(myslash[-1])
if mysplit is None:
return None
mylen=len(myslash)
virtual is a valid choice and defaults to the first element when there
are no installed/available candidates."""
myslash=mycpv.split("/")
- mysplit=pkgsplit(myslash[-1])
+ mysplit = versions._pkgsplit(myslash[-1])
if settings is None:
settings = globals()["settings"]
virts = settings.getvirtuals("/")
mode='r', encoding=_encodings['content'], errors='replace').readlines()
writemsg(colorize("BAD", _("\n!!! Your current profile is "
"deprecated and not supported anymore.")) + "\n", noiselevel=-1)
+ writemsg(colorize("BAD", _("!!! Use eselect profile to update your "
+ "profile.")) + "\n", noiselevel=-1)
if not dcontent:
writemsg(colorize("BAD", _("!!! Please refer to the "
"Gentoo Upgrading Guide.")) + "\n", noiselevel=-1)
'portage.dep:dep_getkey,match_from_list,paren_reduce,use_reduce',
'portage.env.loaders:KeyValuePairFileLoader',
'portage.util:ensure_dirs,writemsg,writemsg_level',
- 'portage.versions:best,catpkgsplit,pkgsplit,ver_regexp',
+ 'portage.versions:best,catpkgsplit,_pkgsplit@pkgsplit,ver_regexp',
)
from portage.cache.cache_errors import CacheError
'portage.util:apply_secpass_permissions,ConfigProtect,ensure_dirs,' + \
'writemsg,writemsg_level,write_atomic,atomic_ofstream,writedict,' + \
'grabfile,grabdict,normalize_path,new_protect_filename,getlibpaths',
- 'portage.versions:best,catpkgsplit,catsplit,pkgcmp,pkgsplit',
+ 'portage.versions:best,catpkgsplit,catsplit,pkgcmp,_pkgsplit@pkgsplit',
)
from portage.const import CACHE_PATH, CONFIG_MEMORY_FILE, \
raise
del e
else:
- showMessage(_("<<< !needed %s %s\n") % (obj_type, obj),
+ showMessage(_("<<< !needed %s %s\n") % (obj_type, obj),
noiselevel=-1)
# Remove empty parent directories if possible.
_pv_re = re.compile('^' + _pv + '$', re.VERBOSE)
-def pkgsplit(mypkg,silent=1):
-
+def _pkgsplit(mypkg):
+ """
+ @param mypkg: pv
+ @return:
+ 1. None if input is invalid.
+ 2. (pn, ver, rev) if input is pv
+ """
m = _pv_re.match(mypkg)
if m is None:
return None
return (m.group('pn'), m.group('ver'), rev)
+_missing_cat = 'null'
catcache={}
def catpkgsplit(mydata,silent=1):
"""
mysplit = mydata.split('/', 1)
p_split=None
if len(mysplit)==1:
- cat = "null"
- p_split=pkgsplit(mydata,silent=silent)
+ cat = _missing_cat
+ p_split = _pkgsplit(mydata)
elif len(mysplit)==2:
cat = mysplit[0]
- p_split=pkgsplit(mysplit[1],silent=silent)
+ p_split = _pkgsplit(mysplit[1])
if not p_split:
catcache[mydata]=None
return None
catcache[mydata]=retval
return retval
+def pkgsplit(mypkg, silent=1):
+ """
+ @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
+ """
+ catpsplit = catpkgsplit(mypkg)
+ if catpsplit is None:
+ return None
+ cat, pn, ver, rev = catpsplit
+ if cat is _missing_cat and '/' not in mypkg:
+ return (pn, ver, rev)
+ else:
+ return (cat + '/' + pn, ver, rev)
+
def catsplit(mydep):
return mydep.split("/", 1)
def end(self):
pass
+class PhaseCheck(LineCheck):
+ """ basic class for function detection """
+
+ ignore_line = re.compile(r'(^\s*#)')
+ func_end_re = re.compile(r'^\}$')
+ in_phase = ''
+
+ def __init__(self):
+ self.phases = ('pkg_pretend', 'pkg_setup', 'src_unpack', 'src_prepare', 'src_configure', 'src_compile',
+ 'src_test', 'src_install', 'pkg_preinst', 'pkg_postinst', 'pkg_prerm', 'pkg_postrm', 'pkg_config')
+ phase_re = '('
+ for phase in self.phases:
+ phase_re += phase + '|'
+ phase_re = phase_re[:-1] + ')'
+ self.phases_re = re.compile(phase_re)
+
+ def check(self, num, line):
+ m = self.phases_re.match(line)
+ if m is not None:
+ self.in_phase = m.group(1)
+ if self.in_phase != '' and \
+ self.func_end_re.match(line) is not None:
+ self.in_phase = ''
+
+ return self.phase_check(num, line)
+
+ def phase_check(self, num, line):
+ """ override this function for your checks """
+ pass
+
class EbuildHeader(LineCheck):
"""Ensure ebuilds have proper headers
Copyright header errors
if self._iuse_def is None:
yield 'IUSE is not defined'
-class EMakeParallelDisabled(LineCheck):
+class EMakeParallelDisabled(PhaseCheck):
"""Check for emake -j1 calls which disable parallelization."""
repoman_check_name = 'upstream.workaround'
re = re.compile(r'^\s*emake\s+.*-j\s*1\b')
error = errors.EMAKE_PARALLEL_DISABLED
+ def phase_check(self, num, line):
+ if self.in_phase == 'src_compile' or self.in_phase == 'src_install':
+ if self.re.match(line):
+ return self.error
+
class EMakeParallelDisabledViaMAKEOPTS(LineCheck):
"""Check for MAKEOPTS=-j1 that disables parallelization."""
repoman_check_name = 'upstream.workaround'
return 'WANT_AUTO' + m.group(1) + \
' redundantly set to default value "latest" on line: %d'
-class PhaseCheck(LineCheck):
- """ basic class for function detection """
-
- ignore_line = re.compile(r'(^\s*#)')
- func_end_re = re.compile(r'^\}$')
- in_phase = ''
-
- def __init__(self):
- self.phases = ('pkg_setup', 'pkg_preinst', 'pkg_postinst', 'pkg_prerm', 'pkg_postrm', 'pkg_pretend',
- 'src_unpack', 'src_prepare', 'src_compile', 'src_test', 'src_install')
- phase_re = '('
- for phase in self.phases:
- phase_re += phase + '|'
- phase_re = phase_re[:-1] + ')'
- self.phases_re = re.compile(phase_re)
-
- def check(self, num, line):
- m = self.phases_re.match(line)
- if m is not None:
- self.in_phase = m.group(1)
- if self.in_phase != '' and \
- self.func_end_re.match(line) is not None:
- self.in_phase = ''
-
- return self.phase_check(num, line)
-
- def phase_check(self, num, line):
- """ override this function for your checks """
- pass
-
class SrcCompileEconf(PhaseCheck):
repoman_check_name = 'ebuild.minorsyn'
configure_re = re.compile(r'\s(econf|./configure)')
projects / portage.git / commitdiff