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)))