def spawn_get_output(mycommand,
spawn_type=None,
raw_exit_code=False,
collect_fds=(1, ),
fd_pipes=None,
split_lines=True,
**keywords):
"""Call spawn, collecting the output to fd's specified in collect_fds list.
:param spawn_type: the passed in function to call- typically :func:`spawn_bash`,
:func:`spawn`, :func:`spawn_sandbox`, or :func:`spawn_fakeroot`.
Defaults to :func:`spawn`.
"""
if spawn_type is None:
spawn_type = spawn
pr, pw = None, None
if fd_pipes is None:
fd_pipes = {0: 0}
else:
fd_pipes = ProtectedDict(fd_pipes)
try:
pr, pw = os.pipe()
for x in collect_fds:
fd_pipes[x] = pw
keywords["returnpid"] = True
mypid = spawn_type(mycommand, fd_pipes=fd_pipes, **keywords)
os.close(pw)
pw = None
if not isinstance(mypid, (list, tuple)):
raise ExecutionFailure()
fd = os.fdopen(pr, "r")
try:
if not split_lines:
mydata = fd.read()
else:
mydata = fd.readlines()
finally:
fd.close()
pw = None
retval = os.waitpid(mypid[0], 0)[1]
cleanup_pids(mypid)
if raw_exit_code:
return [retval, mydata]
return [process_exit_code(retval), mydata]
finally:
if pr is not None:
try:
os.close(pr)
except OSError:
pass
if pw is not None:
try:
os.close(pw)
except OSError:
pass
def read_bash_dict(bash_source, vars_dict=None, sourcing_command=None):
"""Read bash source, yielding a dict of vars.
:param bash_source: either a file to read from
or a string holding the filename to open
:param vars_dict: initial 'env' for the sourcing.
Is protected from modification.
:type vars_dict: dict or None
:param sourcing_command: controls whether a source command exists.
If one does and is encountered, then this func is called.
:type sourcing_command: callable
:raise BashParseError: thrown if invalid syntax is encountered.
:return: dict representing the resultant env if bash executed the source.
"""
# quite possibly I'm missing something here, but the original
# portage_util getconfig/varexpand seemed like it only went
# halfway. The shlex posix mode *should* cover everything.
if vars_dict is not None:
d, protected = ProtectedDict(vars_dict), True
else:
d, protected = {}, False
close = False
infile = None
if isinstance(bash_source, basestring):
f = open(bash_source, "r")
close = True
infile = bash_source
else:
f = bash_source
s = bash_parser(f, sourcing_command=sourcing_command, env=d, infile=infile)
try:
tok = ""
try:
while tok is not None:
key = s.get_token()
if key is None:
break
elif key.isspace():
# we specifically have to check this, since we're
# screwing with the whitespace filters below to
# detect empty assigns
continue
eq = s.get_token()
if eq != '=':
raise BashParseError(
bash_source, s.lineno,
"got token %r, was expecting '='" % eq)
val = s.get_token()
if val is None:
val = ''
# look ahead to see if we just got an empty assign.
next_tok = s.get_token()
if next_tok == '=':
# ... we did.
# leftmost insertions, thus reversed ordering
s.push_token(next_tok)
s.push_token(val)
val = ''
else:
s.push_token(next_tok)
d[key] = val
except ValueError as e:
raise_from(BashParseError(bash_source, s.lineno, str(e)))
finally:
if close and f is not None:
f.close()
if protected:
d = d.new
return d
def spawn_fakeroot(mycommand,
save_file,
env=None,
name=None,
returnpid=False,
**keywords):
"""spawn a process via fakeroot
refer to the fakeroot manpage for specifics of using fakeroot
"""
if env is None:
env = {}
else:
env = ProtectedDict(env)
if name is None:
name = "fakeroot %s" % mycommand
args = [
FAKED_PATH, "--unknown-is-real", "--foreground", "--save-file",
save_file
]
rd_fd, wr_fd = os.pipe()
daemon_fd_pipes = {1: wr_fd, 2: wr_fd}
if os.path.exists(save_file):
args.append("--load")
daemon_fd_pipes[0] = os.open(save_file, os.O_RDONLY)
else:
daemon_fd_pipes[0] = os.open("/dev/null", os.O_RDONLY)
pids = None
pids = spawn(args, fd_pipes=daemon_fd_pipes, returnpid=True)
try:
try:
rd_f = os.fdopen(rd_fd)
line = rd_f.readline()
rd_f.close()
rd_fd = None
except:
cleanup_pids(pids)
raise
finally:
for x in (rd_fd, wr_fd, daemon_fd_pipes[0]):
if x is not None:
try:
os.close(x)
except OSError:
pass
line = line.strip()
try:
fakekey, fakepid = map(int, line.split(":"))
except ValueError:
raise ExecutionFailure("output from faked was unparsable- %s" % line)
# by now we have our very own daemonized faked. yay.
env["FAKEROOTKEY"] = str(fakekey)
paths = [LIBFAKEROOT_PATH] + env.get("LD_PRELOAD", "").split(":")
env["LD_PRELOAD"] = ":".join(x for x in paths if x)
try:
ret = spawn(mycommand,
name=name,
env=env,
returnpid=returnpid,
**keywords)
if returnpid:
return ret + [fakepid] + pids
return ret
finally:
if not returnpid:
cleanup_pids([fakepid] + pids)
def __init__(self,
profile,
repositories,
vdb,
name=None,
root='/',
prefix='/',
incrementals=const.incrementals,
triggers=(),
**settings):
# voodoo, unfortunately (so it goes)
# break this up into chunks once it's stabilized (most of code
# here has already, but still more to add)
self._triggers = triggers
# prevent critical variables from being changed in make.conf
for k in profile.profile_only_variables.intersection(settings.keys()):
del settings[k]
if 'CHOST' in settings and 'CBUILD' not in settings:
settings['CBUILD'] = settings['CHOST']
# if unset, MAKEOPTS defaults to CPU thread count
if 'MAKEOPTS' not in settings:
settings['MAKEOPTS'] = '-j%i' % get_proc_count()
# map out sectionname -> config manager immediately.
repositories_collapsed = [r.collapse() for r in repositories]
repositories = [r.instantiate() for r in repositories_collapsed]
self.fetcher = settings.pop("fetcher")
self.default_licenses_manager = OverlayedLicenses(*repositories)
vdb_collapsed = [r.collapse() for r in vdb]
vdb = [r.instantiate() for r in vdb_collapsed]
self.repos_raw = {
collapsed.name: repo
for (collapsed, repo) in izip(repositories_collapsed, repositories)
}
self.repos_raw.update(
(collapsed.name, repo)
for (collapsed, repo) in izip(vdb_collapsed, vdb))
self.repos_raw.pop(None, None)
if profile.provides_repo is not None:
self.repos_raw['package.provided'] = profile.provides_repo
vdb.append(profile.provides_repo)
self.profile = profile
pkg_maskers, pkg_unmaskers, pkg_keywords, pkg_licenses = [], [], [], []
pkg_use, self.bashrcs = [], []
self.ebuild_hook_dir = settings.pop("ebuild_hook_dir", None)
for key, val, action in (
("package.mask", pkg_maskers, parse_match),
("package.unmask", pkg_unmaskers, parse_match),
("package.keywords", pkg_keywords, package_keywords_splitter),
("package.accept_keywords", pkg_keywords,
package_keywords_splitter),
("package.license", pkg_licenses, package_keywords_splitter),
("package.use", pkg_use, package_keywords_splitter),
("package.env", self.bashrcs, package_env_splitter),
):
for fp in settings.pop(key, ()):
try:
if key == "package.env":
base = self.ebuild_hook_dir
if base is None:
base = os.path.dirname(fp)
action = partial(action, base)
for fs_obj in iter_scan(fp, follow_symlinks=True):
if not fs_obj.is_reg or '/.' in fs_obj.location:
continue
val.extend(
action(x) for x in iter_read_bash(fs_obj.location))
except EnvironmentError as e:
if e.errno == errno.ENOENT:
raise MissingFile(fp, key)
raise_from(Failure("failed reading '%s': %s" % (fp, e)))
except ValueError as e:
raise_from(Failure("failed reading '%s': %s" % (fp, e)))
self.name = name
settings.setdefault("PKGCORE_DOMAIN", name)
for x in incrementals:
if isinstance(settings.get(x), basestring):
settings[x] = tuple(settings[x].split())
# roughly... all incremental stacks should be interpreted left -> right
# as such we start with the profile settings, and append ours onto it.
for k, v in profile.default_env.iteritems():
if k not in settings:
settings[k] = v
continue
if k in incrementals:
settings[k] = v + tuple(settings[k])
# next we finalize incrementals.
for incremental in incrementals:
# Skip USE/ACCEPT_LICENSE for the time being; hack; we need the
# negations currently so that pkg iuse induced enablings can be
# disabled by negations. For example, think of the profile doing
# USE=-cdr for brasero w/ IUSE=+cdr. Similarly, ACCEPT_LICENSE is
# skipped because negations are required for license filtering.
if incremental not in settings or incremental in (
"USE", "ACCEPT_LICENSE"):
continue
s = set()
incremental_expansion(s, settings[incremental],
'While expanding %s ' % (incremental, ))
settings[incremental] = tuple(s)
# use is collapsed; now stack use_expand.
use = settings['USE'] = set(
optimize_incrementals(settings.get("USE", ())))
self._extend_use_for_features(use, settings.get("FEATURES", ()))
for u in profile.use_expand:
v = settings.get(u)
if v is None:
continue
u2 = u.lower() + "_"
use.update(u2 + x for x in v.split())
if 'ACCEPT_KEYWORDS' not in settings:
raise Failure("No ACCEPT_KEYWORDS setting detected from profile, "
"or user config")
s = set()
default_keywords = []
incremental_expansion(s, settings['ACCEPT_KEYWORDS'],
'while expanding ACCEPT_KEYWORDS')
default_keywords.extend(s)
settings['ACCEPT_KEYWORDS'] = set(default_keywords)
self.use = use
if "ARCH" not in settings:
raise Failure(
"No ARCH setting detected from profile, or user config")
self.arch = self.stable_arch = settings["ARCH"]
self.unstable_arch = "~%s" % self.arch
# ~amd64 -> [amd64, ~amd64]
for x in default_keywords[:]:
if x.startswith("~"):
default_keywords.append(x.lstrip("~"))
default_keywords = unstable_unique(default_keywords + [self.arch])
accept_keywords = pkg_keywords + list(profile.accept_keywords)
vfilters = [
self.make_keywords_filter(self.arch,
default_keywords,
accept_keywords,
profile.keywords,
incremental="package.keywords"
in incrementals)
]
del default_keywords, accept_keywords
# we can finally close that fricking
# "DISALLOW NON FOSS LICENSES" bug via this >:)
master_license = []
master_license.extend(settings.get('ACCEPT_LICENSE', ()))
if master_license or pkg_licenses:
vfilters.append(
self.make_license_filter(master_license, pkg_licenses))
del master_license
# if it's made it this far...
self.root = settings["ROOT"] = root
self.prefix = prefix
self.settings = ProtectedDict(settings)
for data in self.settings.get('bashrc', ()):
source = local_source(data)
# this is currently local-only so a path check is ok
# TODO make this more general
if not os.path.exists(source.path):
raise Failure('user-specified bashrc %r does not exist' %
(data, ))
self.bashrcs.append((packages.AlwaysTrue, source))
# stack use stuff first, then profile.
self.enabled_use = ChunkedDataDict()
self.enabled_use.add_bare_global(*split_negations(self.use))
self.enabled_use.merge(profile.pkg_use)
self.enabled_use.update_from_stream(
chunked_data(k, *split_negations(v)) for k, v in pkg_use)
for attr in ('', 'stable_'):
c = ChunkedDataDict()
c.merge(getattr(profile, attr + 'forced_use'))
c.add_bare_global((), (self.arch, ))
setattr(self, attr + 'forced_use', c)
c = ChunkedDataDict()
c.merge(getattr(profile, attr + 'masked_use'))
setattr(self, attr + 'disabled_use', c)
self.repos = []
self.vdb = []
self.repos_configured = {}
self.repos_configured_filtered = {}
rev_names = {repo: name for name, repo in self.repos_raw.iteritems()}
profile_masks = profile._incremental_masks()
profile_unmasks = profile._incremental_unmasks()
repo_masks = {
r.repo_id: r._visibility_limiters()
for r in repositories
}
for l, repos, filtered in ((self.repos, repositories, True),
(self.vdb, vdb, False)):
for repo in repos:
if not repo.configured:
pargs = [repo]
try:
for x in repo.configurables:
if x == "domain":
pargs.append(self)
elif x == "settings":
pargs.append(settings)
elif x == "profile":
pargs.append(profile)
else:
pargs.append(getattr(self, x))
except AttributeError as ae:
raise_from(
Failure("failed configuring repo '%s': "
"configurable missing: %s" % (repo, ae)))
wrapped_repo = repo.configure(*pargs)
else:
wrapped_repo = repo
key = rev_names.get(repo)
self.repos_configured[key] = wrapped_repo
if filtered:
config = getattr(repo, 'config', None)
masters = getattr(config, 'masters', ())
if masters is None:
# tough cookies. If a user has an overlay, no masters
# defined, we're not applying the portdir masks.
# we do this both since that's annoying, and since
# frankly there isn't any good course of action.
masters = ()
global_masks = [
repo_masks.get(master, [(), ()]) for master in masters
]
global_masks.append(repo_masks[repo.repo_id])
global_masks.extend(profile_masks)
masks = set()
for neg, pos in global_masks:
masks.difference_update(neg)
masks.update(pos)
masks.update(pkg_maskers)
unmasks = set(chain(pkg_unmaskers, *profile_unmasks))
filtered = self.generate_filter(
make_mask_filter(masks), make_unmask_filter(unmasks),
*vfilters)
if filtered:
wrapped_repo = visibility.filterTree(
wrapped_repo, filtered, True)
self.repos_configured_filtered[key] = wrapped_repo
l.append(wrapped_repo)
if profile.virtuals:
l = [
x for x in (getattr(v, 'old_style_virtuals', None)
for v in self.vdb) if x is not None
]
profile_repo = profile.make_virtuals_repo(
multiplex.tree(*repositories), *l)
self.repos_raw["profile virtuals"] = profile_repo
self.repos_configured_filtered["profile virtuals"] = profile_repo
self.repos_configured["profile virtuals"] = profile_repo
self.repos = [profile_repo] + self.repos
self.use_expand_re = re.compile(
"^(?:[+-])?(%s)_(.*)$" %
"|".join(x.lower()
for x in sorted(profile.use_expand, reverse=True)))
