def testChildWatcher(self):
true_binary = find_binary("true")
self.assertNotEqual(true_binary, None)
initial_policy = asyncio.get_event_loop_policy()
if not isinstance(initial_policy, DefaultEventLoopPolicy):
asyncio.set_event_loop_policy(DefaultEventLoopPolicy())
try:
try:
asyncio.set_child_watcher(None)
except NotImplementedError:
pass
else:
self.assertTrue(False)
args_tuple = ('hello', 'world')
loop = asyncio.get_event_loop()
future = loop.create_future()
def callback(pid, returncode, *args):
future.set_result((pid, returncode, args))
with asyncio.get_child_watcher() as watcher:
pids = spawn([true_binary], returnpid=True)
watcher.add_child_handler(pids[0], callback, *args_tuple)
self.assertEqual(
loop.run_until_complete(future),
(pids[0], os.EX_OK, args_tuple))
finally:
asyncio.set_event_loop_policy(initial_policy)
def _do_test(self, read_end, write_end):
initial_policy = asyncio.get_event_loop_policy()
if not isinstance(initial_policy, DefaultEventLoopPolicy):
asyncio.set_event_loop_policy(DefaultEventLoopPolicy())
loop = asyncio.get_event_loop()
read_end = os.fdopen(read_end, 'rb', 0)
write_end = os.fdopen(write_end, 'wb', 0)
try:
def reader_callback():
if not reader_callback.called.done():
reader_callback.called.set_result(None)
reader_callback.called = loop.create_future()
loop.add_reader(read_end.fileno(), reader_callback)
# Allow the loop to check for IO events, and assert
# that our future is still not done.
loop.run_until_complete(asyncio.sleep(0, loop=loop))
self.assertFalse(reader_callback.called.done())
# Demonstrate that the callback is called afer the
# other end of the pipe has been closed.
write_end.close()
loop.run_until_complete(reader_callback.called)
finally:
loop.remove_reader(read_end.fileno())
write_end.close()
read_end.close()
asyncio.set_event_loop_policy(initial_policy)
def _run_test(self, test):
initial_policy = asyncio.get_event_loop_policy()
if not isinstance(initial_policy, DefaultEventLoopPolicy):
asyncio.set_event_loop_policy(DefaultEventLoopPolicy())
try:
test(asyncio.get_event_loop())
finally:
asyncio.set_event_loop_policy(initial_policy)
def _do_test(self, read_end, write_end):
initial_policy = asyncio.get_event_loop_policy()
if not isinstance(initial_policy, DefaultEventLoopPolicy):
asyncio.set_event_loop_policy(DefaultEventLoopPolicy())
loop = asyncio._wrap_loop()
read_end = os.fdopen(read_end, 'rb', 0)
write_end = os.fdopen(write_end, 'wb', 0)
try:
def writer_callback():
if not writer_callback.called.done():
writer_callback.called.set_result(None)
writer_callback.called = loop.create_future()
_set_nonblocking(write_end.fileno())
loop.add_writer(write_end.fileno(), writer_callback)
# With pypy we've seen intermittent spurious writer callbacks
# here, so retry until the correct state is achieved.
tries = 10
while tries:
tries -= 1
# Fill up the pipe, so that no writer callbacks should be
# received until the state has changed.
while True:
try:
os.write(write_end.fileno(), 512 * b'0')
except EnvironmentError as e:
if e.errno != errno.EAGAIN:
raise
break
# Allow the loop to check for IO events, and assert
# that our future is still not done.
loop.run_until_complete(asyncio.sleep(0, loop=loop))
if writer_callback.called.done():
writer_callback.called = loop.create_future()
else:
break
self.assertFalse(writer_callback.called.done())
# Demonstrate that the callback is called afer the
# other end of the pipe has been closed.
read_end.close()
loop.run_until_complete(writer_callback.called)
finally:
loop.remove_writer(write_end.fileno())
write_end.close()
read_end.close()
asyncio.set_event_loop_policy(initial_policy)
if loop not in (None, global_event_loop()):
loop.close()
self.assertFalse(global_event_loop().is_closed())
def testPolicyWrapperRecursion(self): initial_policy = asyncio.get_event_loop_policy() if not isinstance(initial_policy, DefaultEventLoopPolicy): asyncio.set_event_loop_policy(DefaultEventLoopPolicy()) try: with self.assertRaises(NotImplementedError): asyncio.get_event_loop() with self.assertRaises(NotImplementedError): asyncio.get_child_watcher() finally: asyncio.set_event_loop_policy(initial_policy)
def _run_test(self, test):
initial_policy = asyncio.get_event_loop_policy()
if not isinstance(initial_policy, DefaultEventLoopPolicy):
asyncio.set_event_loop_policy(DefaultEventLoopPolicy())
loop = asyncio._wrap_loop()
try:
test(loop)
finally:
asyncio.set_event_loop_policy(initial_policy)
if loop not in (None, global_event_loop()):
loop.close()
self.assertFalse(global_event_loop().is_closed())
def testEventLoopInForkTestCase(self): initial_policy = asyncio.get_event_loop_policy() if not isinstance(initial_policy, DefaultEventLoopPolicy): asyncio.set_event_loop_policy(DefaultEventLoopPolicy()) try: loop = asyncio.get_event_loop() fork_exitcode = loop.create_future() # Make async_main fork while the loop is running, which would # trigger https://bugs.python.org/issue22087 with asyncio's # default event loop policy. loop.call_soon(async_main, fork_exitcode) assert loop.run_until_complete(fork_exitcode) == os.EX_OK finally: asyncio.set_event_loop_policy(initial_policy)
def test_add_done_callback(self):
initial_policy = asyncio.get_event_loop_policy()
if not isinstance(initial_policy, DefaultEventLoopPolicy):
asyncio.set_event_loop_policy(DefaultEventLoopPolicy())
try:
loop = asyncio.get_event_loop()
f1 = loop.create_future()
f2 = loop.create_future()
f1.add_done_callback(f2.set_result)
loop.call_soon(lambda: f1.set_result(None))
loop.run_until_complete(f1)
self.assertEqual(f1.done(), True)
# This proves that done callbacks of f1 are executed before
# loop.run_until_complete(f1) returns, which is how asyncio's
# default event loop behaves.
self.assertEqual(f2.done(), True)
finally:
asyncio.set_event_loop_policy(initial_policy)
def testChildWatcher(self):
true_binary = find_binary("true")
self.assertNotEqual(true_binary, None)
initial_policy = asyncio.get_event_loop_policy()
if not isinstance(initial_policy, DefaultEventLoopPolicy):
asyncio.set_event_loop_policy(DefaultEventLoopPolicy())
loop = None
try:
try:
asyncio.set_child_watcher(None)
except NotImplementedError:
pass
else:
self.assertTrue(False)
args_tuple = ("hello", "world")
loop = asyncio._wrap_loop()
future = loop.create_future()
def callback(pid, returncode, *args):
future.set_result((pid, returncode, args))
async def watch_pid():
with asyncio.get_child_watcher() as watcher:
pids = spawn([true_binary], returnpid=True)
watcher.add_child_handler(pids[0], callback, *args_tuple)
self.assertEqual((await future),
(pids[0], os.EX_OK, args_tuple))
loop.run_until_complete(watch_pid())
finally:
asyncio.set_event_loop_policy(initial_policy)
if loop not in (None, global_event_loop()):
loop.close()
self.assertFalse(global_event_loop().is_closed())