async def run(self): self.expected = getattr(self, "expected", None) or {"returncode": 0} if self.debug: fd_pipes = {} pr = None pw = None else: pr, pw = os.pipe() fd_pipes = {1: pw, 2: pw} pr = open(pr, "rb", 0) proc = AsyncFunction( scheduler=asyncio.get_event_loop(), target=self._subprocess, args=(self.args, self.cwd, self.env, self.expected, self.debug), fd_pipes=fd_pipes, ) proc.start() if pw is not None: os.close(pw) await proc.async_wait() if pr is None: stdio = None else: stdio = await _reader(pr) self.result = { "stdio": stdio, "result": proc.result, }
def test_getpid_double_fork(self): """ Verify that portage.getpid() cache is updated correctly after two forks. """ loop = asyncio._wrap_loop() proc = AsyncFunction(scheduler=loop, target=self._test_getpid_fork) proc.start() self.assertEqual(proc.wait(), 0)
def _testAsyncFunctionStdin(self, loop=None): test_string = '1\n2\n3\n' pr, pw = os.pipe() fd_pipes = {0: pr} reader = AsyncFunction(scheduler=loop, fd_pipes=fd_pipes, target=self._read_from_stdin, args=(pw, )) reader.start() os.close(pr) _set_nonblocking(pw) with open(pw, mode='wb', buffering=0) as pipe_write: yield _writer(pipe_write, test_string.encode('utf_8'), loop=loop) self.assertEqual((yield reader.async_wait()), os.EX_OK) self.assertEqual(reader.result, test_string)
async def _testAsyncFunctionStdin(self, loop): test_string = "1\n2\n3\n" pr, pw = os.pipe() fd_pipes = {0: pr} reader = AsyncFunction(scheduler=loop, fd_pipes=fd_pipes, target=self._read_from_stdin, args=(pw, )) reader.start() os.close(pr) _set_nonblocking(pw) with open(pw, mode="wb", buffering=0) as pipe_write: await _writer(pipe_write, test_string.encode("utf_8")) self.assertEqual((await reader.async_wait()), os.EX_OK) self.assertEqual(reader.result, test_string)
def sync_async(self, emerge_config=None, repo=None, master_hooks=True): self.emerge_config = emerge_config self.settings, self.trees, self.mtimedb = emerge_config self.xterm_titles = "notitles" not in self.settings.features self.portdb = self.trees[self.settings['EROOT']]['porttree'].dbapi return SyncRepo(sync_task=AsyncFunction(target=self.sync, kwargs=dict(emerge_config=emerge_config, repo=repo, master_hooks=master_hooks)), sync_callback=self._sync_callback)
def _test_getpid_fork(self): """ Verify that portage.getpid() cache is updated in a forked child process. """ loop = asyncio._wrap_loop() proc = AsyncFunction(scheduler=loop, target=portage.getpid) proc.start() proc.wait() self.assertEqual(proc.pid, proc.result)
def submit(self, fn, *args, **kwargs): """Submits a callable to be executed with the given arguments. Schedules the callable to be executed as fn(*args, **kwargs) and returns a Future instance representing the execution of the callable. Returns: A Future representing the given call. """ future = self._loop.create_future() proc = AsyncFunction( target=functools.partial(self._guarded_fn_call, fn, args, kwargs)) self._submit_queue.append((future, proc)) self._schedule() return future
def _copy_proot_exit(self, proc): if self._default_exit(proc) != os.EX_OK: self.wait() else: self._start_task( AsyncFunction( target=install_mask_dir, args=( os.path.join( self._proot, self.settings["EPREFIX"].lstrip(os.sep) ), self._pkg_install_mask, ), ), self._pkg_install_mask_exit, )
def async_main(fork_exitcode, loop=None): loop = asyncio._wrap_loop(loop) proc = AsyncFunction(scheduler=loop, target=fork_main) proc.start() proc.async_wait().add_done_callback( lambda future: fork_exitcode.set_result(future.result()))
hooks[filepath] = name else: writemsg_level(" %s %s hook: '%s' is not executable\n" % (warn("*"), _dir, _unicode_decode(name),), level=logging.WARN, noiselevel=2) self.hooks[_dir] = hooks def get_module_descriptions(self, mod): desc = self.module_controller.get_func_descriptions(mod) if desc: return desc return [] def async(self, emerge_config=None, repo=None): proc = AsyncFunction(target=self.sync, kwargs=dict(emerge_config=emerge_config, repo=repo)) proc.addExitListener(self._sync_callback) return proc def sync(self, emerge_config=None, repo=None): self.emerge_config = emerge_config self.callback = None self.repo = repo self.exitcode = 1 self.updatecache_flg = False if repo.sync_type in self.module_names: tasks = [self.module_controller.get_class(repo.sync_type)] else: msg = "\n%s: Sync module '%s' is not an installed/known type'\n" \ % (bad("ERROR"), repo.sync_type) return self.exitcode, msg
def async (self, emerge_config=None, repo=None): proc = AsyncFunction(target=self.sync, kwargs=dict(emerge_config=emerge_config, repo=repo)) proc.addExitListener(self._sync_callback) return proc