def mk_tree(self, path, *args, **kwds):
eclasses = kwds.pop('eclass_cache', None)
if eclasses is None:
epath = pjoin(path, 'eclass')
ensure_dirs(epath)
eclasses = eclass_cache.cache(epath)
return repository._UnconfiguredTree(path, eclasses, *args, **kwds)
def mk_tree(self, path, *args, **kwds):
if path != self.dir:
self.dir_slave = path
self.dir_master = pjoin(os.path.dirname(path),
os.path.basename(path) + 'master')
ensure_dirs(self.dir_slave)
ensure_dirs(self.dir_master)
ensure_dirs(pjoin(self.dir_slave, 'profiles'))
ensure_dirs(pjoin(self.dir_master, 'profiles'))
eclasses = kwds.pop('eclass_cache', None)
if eclasses is None:
epath = pjoin(self.dir_master, 'eclass')
ensure_dirs(epath)
eclasses = eclass_cache.cache(epath)
self.master_repo = repository.UnconfiguredTree(self.dir_master,
eclass_cache=eclasses,
*args,
**kwds)
masters = (self.master_repo, )
return repository.UnconfiguredTree(self.dir_slave,
eclass_cache=eclasses,
masters=masters,
*args,
**kwds)
def _sort_eclasses(config, repo_config, eclasses):
if eclasses:
return eclasses
repo_path = repo_config.location
masters = repo_config.masters
eclasses = []
default = config.get_default('repo_config')
if default is None:
location = repo_path
else:
location = default.location
if not masters:
if masters is None:
# if it's None, that means it's not a standalone, and is PMS, or misconfigured.
# empty tuple means it's a standalone repository
if default is None:
raise Exception(
"repository %r named %r wants the default repository "
"(gentoo for example), but no repository is marked as the default. "
"Fix your configuration." %
(repo_path, repo_config.repo_id))
eclasses = [location]
else:
repo_map = {
r.repo_id: r.location
for r in config.objects['repo_config'].itervalues()
}
missing = set(repo_config.masters).difference(repo_map)
if missing:
missing = ', '.join(sorted(missing))
raise Exception(
"repo %r at path %r has masters %s; we cannot find "
"the following repos: %s" %
(repo_config.repo_id, repo_path, ', '.join(map(
repr, masters)), missing))
eclasses = [repo_map[x] for x in masters]
# add the repo's eclass directories if it's not specified.
# do it in this fashion so that the repo's masters can actually interpose
# this repo's eclasses in between others.
# admittedly an odd thing to do, but it has some benefits
if repo_path not in eclasses:
eclasses.append(repo_path)
eclasses = [
eclass_cache_module.cache(pjoin(x, 'eclass'), location=location)
for x in eclasses
]
if len(eclasses) == 1:
eclasses = eclasses[0]
else:
eclasses = list(reversed(eclasses))
eclasses = eclass_cache_module.StackedCaches(eclasses,
location=location,
eclassdir=location)
return eclasses
def setUp(self):
TempDirMixin.setUp(self)
self.loc1 = pjoin(self.dir, "stack1")
self.loc2 = pjoin(self.dir, "stack2")
os.mkdir(self.loc1)
open(pjoin(self.loc1, 'eclass1.eclass'), 'w').close()
os.utime(pjoin(self.loc1, 'eclass1.eclass'), (100, 100))
self.ec1 = eclass_cache.cache(self.loc1)
os.mkdir(self.loc2)
open(pjoin(self.loc2, 'eclass2.eclass'), 'w').close()
os.utime(pjoin(self.loc2, 'eclass2.eclass'), (100, 100))
self.ec2 = eclass_cache.cache(self.loc2)
self.ec = eclass_cache.StackedCaches([self.ec1, self.ec2])
self.ec_locs = {"eclass1": self.loc1, "eclass2": self.loc2}
# make a shadowed file to verify it's not seen
open(pjoin(self.loc2, 'eclass1.eclass'), 'w').close()
def setUp(self):
TempDirMixin.setUp(self)
for x, mtime in (("eclass1", 100), ("eclass2", 200)):
open(pjoin(self.dir, "%s.eclass" % x), "w").close()
os.utime(pjoin(self.dir, "%s.eclass" % x), (mtime, mtime))
# insert a crap file to ensure it doesn't grab it.
open(pjoin(self.dir, 'foon-eclass'), 'w').close()
self.ec = eclass_cache.cache(self.dir)
self.ec_locs = {x: self.dir for x in ("eclass1", "eclass2")}
def __init__(self, location, *args, **config):
self.ec = config.pop("eclasses", None)
if self.ec is None:
self.ec = eclass_cache.cache(pjoin(location, "eclass"), location)
config.pop('label', None)
self.mtime_in_entry = config.pop('mtime_in_entry', True)
location = pjoin(location, 'metadata', 'cache')
super().__init__(location, *args, **config)
self.hardcoded_auxdbkeys_order = tuple(
(idx, key) for idx, key in enumerate(self.auxdbkeys_order)
if key in self._known_keys)
self.hardcoded_auxdbkeys_processing = tuple(
(key in self._known_keys and key or None)
for key in self.auxdbkeys_order)
def _sort_eclasses(config, repo_config):
repo_path = repo_config.location
repo_id = repo_config.repo_id
masters = repo_config.masters
eclasses = []
default = config.get_default('repo_config')
if repo_config._missing_masters and default is not None:
# use default repo's eclasses for overlays with missing masters
location = default.location
else:
location = repo_path
if not masters:
eclasses = [location]
else:
repo_map = {
r.repo_id: r.location
for r in config.objects['repo_config'].values()
}
eclasses = [repo_map[x] for x in masters]
# add the repo's eclass directories if it's not specified.
# do it in this fashion so that the repo's masters can actually interpose
# this repo's eclasses in between others.
# admittedly an odd thing to do, but it has some benefits
if repo_path not in eclasses:
eclasses.append(repo_path)
eclasses = [
eclass_cache_mod.cache(pjoin(x, 'eclass'), location=location)
for x in eclasses
]
if len(eclasses) == 1:
eclasses = eclasses[0]
else:
eclasses = list(reversed(eclasses))
eclasses = eclass_cache_mod.StackedCaches(eclasses,
location=location,
eclassdir=location)
return eclasses
def __init__(self,
location,
eclass_cache=None,
masters=(),
cache=(),
default_mirrors=None,
allow_missing_manifests=False,
repo_config=None):
"""
:param location: on disk location of the tree
:param cache: sequence of :obj:`pkgcore.cache.template.database` instances
to use for storing metadata
:param masters: repo masters this repo inherits from
:param eclass_cache: If not None, :obj:`pkgcore.ebuild.eclass_cache`
instance representing the eclasses available,
if None, generates the eclass_cache itself
:param default_mirrors: Either None, or sequence of mirrors to try
fetching from first, then falling back to other uri
"""
super().__init__()
self.base = self.location = location
try:
if not stat.S_ISDIR(os.stat(self.base).st_mode):
raise errors.InitializationError(
f"base not a dir: {self.base}")
except OSError as e:
raise errors.InitializationError(
f"lstat failed: {self.base}") from e
if repo_config is None:
repo_config = repo_objs.RepoConfig(location)
self.config = repo_config
# profiles dir is required by PMS
if not os.path.isdir(self.config.profiles_base):
raise errors.InvalidRepo(
f'missing required profiles dir: {self.location!r}')
# verify we support the repo's EAPI
if not self.is_supported:
raise errors.UnsupportedRepo(self)
if eclass_cache is None:
eclass_cache = eclass_cache_mod.cache(pjoin(
self.location, 'eclass'),
location=self.location)
self.eclass_cache = eclass_cache
self.masters = masters
self.trees = tuple(masters) + (self, )
self.licenses = repo_objs.Licenses(self.location)
if masters:
self.licenses = repo_objs.OverlayedLicenses(*self.trees)
mirrors = {}
fp = pjoin(self.location, 'profiles', "thirdpartymirrors")
try:
for k, v in read_dict(fp, splitter=None).items():
v = v.split()
shuffle(v)
mirrors[k] = v
except FileNotFoundError:
pass
# use mirrors from masters if not defined in the repo
for master in masters:
for k, v in master.mirrors.items():
if k not in mirrors:
mirrors[k] = v
if isinstance(cache, (tuple, list)):
cache = tuple(cache)
else:
cache = (cache, )
self.mirrors = mirrors
self.default_mirrors = default_mirrors
self.cache = cache
self._allow_missing_chksums = allow_missing_manifests
self.package_class = self.package_factory(self, cache,
self.eclass_cache,
self.mirrors,
self.default_mirrors)
self._shared_pkg_cache = WeakValCache()
self._masked = RestrictionRepo(repo_id='masked')
def __init__(self,
location,
eclass_cache=None,
masters=(),
cache=(),
default_mirrors=None,
ignore_paludis_versioning=False,
allow_missing_manifests=False,
repo_config=None):
"""
:param location: on disk location of the tree
:param cache: sequence of :obj:`pkgcore.cache.template.database` instances
to use for storing metadata
:param masters: repo masters this repo inherits from
:param eclass_cache: If not None, :obj:`pkgcore.ebuild.eclass_cache`
instance representing the eclasses available,
if None, generates the eclass_cache itself
:param default_mirrors: Either None, or sequence of mirrors to try
fetching from first, then falling back to other uri
:param ignore_paludis_versioning: If False, fail when -scm is encountered. if True,
silently ignore -scm ebuilds.
"""
prototype.tree.__init__(self)
self.base = self.location = location
try:
if not stat.S_ISDIR(os.stat(self.base).st_mode):
raise errors.InitializationError("base not a dir: %s" %
self.base)
except OSError:
raise_from(
errors.InitializationError("lstat failed on base %s" %
(self.base, )))
if repo_config is None:
repo_config = repo_objs.RepoConfig(location)
self.config = repo_config
if eclass_cache is None:
eclass_cache = eclass_cache_module.cache(
pjoin(self.location, 'eclass'))
self.eclass_cache = eclass_cache
self.masters = masters
self.trees = tuple(masters) + (self, )
self.licenses = repo_objs.Licenses(self.location)
if masters:
self.licenses = repo_objs.OverlayedLicenses(*self.trees)
mirrors = {}
fp = pjoin(self.location, metadata_offset, "thirdpartymirrors")
try:
for k, v in read_dict(fp, splitter=None).iteritems():
v = v.split()
shuffle(v)
mirrors[k] = v
except EnvironmentError as ee:
if ee.errno != errno.ENOENT:
raise
# use mirrors from masters if not defined in the repo
for master in masters:
for k, v in master.mirrors.iteritems():
if k not in mirrors:
mirrors[k] = v
if isinstance(cache, (tuple, list)):
cache = tuple(cache)
else:
cache = (cache, )
self.mirrors = mirrors
self.default_mirrors = default_mirrors
self.cache = cache
self.ignore_paludis_versioning = ignore_paludis_versioning
self._allow_missing_chksums = allow_missing_manifests
self.package_class = self.package_factory(self, cache,
self.eclass_cache,
self.mirrors,
self.default_mirrors)
self._shared_pkg_cache = WeakValCache()
