2013-10-17 17:40:50 -03:00
|
|
|
"""Tests for events.py."""
|
|
|
|
|
2016-10-05 20:32:49 -03:00
|
|
|
import collections.abc
|
2017-03-02 21:07:11 -04:00
|
|
|
import concurrent.futures
|
2013-10-17 17:40:50 -03:00
|
|
|
import functools
|
|
|
|
import io
|
|
|
|
import os
|
2014-02-19 13:10:32 -04:00
|
|
|
import platform
|
2014-06-12 13:39:26 -03:00
|
|
|
import re
|
2013-10-17 17:40:50 -03:00
|
|
|
import signal
|
|
|
|
import socket
|
|
|
|
try:
|
|
|
|
import ssl
|
|
|
|
except ImportError:
|
|
|
|
ssl = None
|
|
|
|
import subprocess
|
|
|
|
import sys
|
2018-02-25 13:10:58 -04:00
|
|
|
import tempfile
|
2013-10-17 17:40:50 -03:00
|
|
|
import threading
|
|
|
|
import time
|
|
|
|
import errno
|
|
|
|
import unittest
|
2014-02-26 05:25:02 -04:00
|
|
|
from unittest import mock
|
2014-04-27 14:44:22 -03:00
|
|
|
import weakref
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2016-08-31 13:40:18 -03:00
|
|
|
if sys.platform != 'win32':
|
|
|
|
import tty
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
import asyncio
|
2018-01-27 15:22:47 -04:00
|
|
|
from asyncio import base_events
|
2018-01-27 16:52:52 -04:00
|
|
|
from asyncio import constants
|
2016-10-05 20:32:49 -03:00
|
|
|
from asyncio import coroutines
|
2017-12-13 15:49:42 -04:00
|
|
|
from asyncio import events
|
2014-08-25 18:20:52 -03:00
|
|
|
from asyncio import proactor_events
|
2014-01-25 17:22:18 -04:00
|
|
|
from asyncio import selector_events
|
2017-12-11 11:04:40 -04:00
|
|
|
from test.test_asyncio import utils as test_utils
|
2017-12-30 01:35:36 -04:00
|
|
|
from test import support
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
|
2018-09-13 21:03:35 -03:00
|
|
|
def broken_unix_getsockname():
|
2014-02-19 13:10:32 -04:00
|
|
|
"""Return True if the platform is Mac OS 10.4 or older."""
|
2018-09-13 21:03:35 -03:00
|
|
|
if sys.platform.startswith("aix"):
|
|
|
|
return True
|
|
|
|
elif sys.platform != 'darwin':
|
2014-02-19 13:10:32 -04:00
|
|
|
return False
|
|
|
|
version = platform.mac_ver()[0]
|
|
|
|
version = tuple(map(int, version.split('.')))
|
|
|
|
return version < (10, 5)
|
|
|
|
|
|
|
|
|
2017-03-02 21:07:11 -04:00
|
|
|
def _test_get_event_loop_new_process__sub_proc():
|
|
|
|
async def doit():
|
|
|
|
return 'hello'
|
|
|
|
|
|
|
|
loop = asyncio.new_event_loop()
|
|
|
|
asyncio.set_event_loop(loop)
|
|
|
|
return loop.run_until_complete(doit())
|
|
|
|
|
|
|
|
|
2017-12-23 13:44:29 -04:00
|
|
|
class CoroLike:
|
|
|
|
def send(self, v):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def throw(self, *exc):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def close(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
def __await__(self):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
class MyBaseProto(asyncio.Protocol):
|
2014-03-05 20:00:36 -04:00
|
|
|
connected = None
|
2013-10-17 17:40:50 -03:00
|
|
|
done = None
|
|
|
|
|
|
|
|
def __init__(self, loop=None):
|
2013-12-05 19:23:13 -04:00
|
|
|
self.transport = None
|
2013-10-17 17:40:50 -03:00
|
|
|
self.state = 'INITIAL'
|
|
|
|
self.nbytes = 0
|
|
|
|
if loop is not None:
|
2014-03-05 20:00:36 -04:00
|
|
|
self.connected = asyncio.Future(loop=loop)
|
2014-01-25 10:32:06 -04:00
|
|
|
self.done = asyncio.Future(loop=loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def connection_made(self, transport):
|
|
|
|
self.transport = transport
|
|
|
|
assert self.state == 'INITIAL', self.state
|
|
|
|
self.state = 'CONNECTED'
|
2014-03-05 20:00:36 -04:00
|
|
|
if self.connected:
|
|
|
|
self.connected.set_result(None)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def data_received(self, data):
|
|
|
|
assert self.state == 'CONNECTED', self.state
|
|
|
|
self.nbytes += len(data)
|
|
|
|
|
|
|
|
def eof_received(self):
|
|
|
|
assert self.state == 'CONNECTED', self.state
|
|
|
|
self.state = 'EOF'
|
|
|
|
|
|
|
|
def connection_lost(self, exc):
|
|
|
|
assert self.state in ('CONNECTED', 'EOF'), self.state
|
|
|
|
self.state = 'CLOSED'
|
|
|
|
if self.done:
|
|
|
|
self.done.set_result(None)
|
|
|
|
|
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
class MyProto(MyBaseProto):
|
|
|
|
def connection_made(self, transport):
|
|
|
|
super().connection_made(transport)
|
|
|
|
transport.write(b'GET / HTTP/1.0\r\nHost: example.com\r\n\r\n')
|
|
|
|
|
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
class MyDatagramProto(asyncio.DatagramProtocol):
|
2013-10-17 17:40:50 -03:00
|
|
|
done = None
|
|
|
|
|
|
|
|
def __init__(self, loop=None):
|
|
|
|
self.state = 'INITIAL'
|
|
|
|
self.nbytes = 0
|
|
|
|
if loop is not None:
|
2014-01-25 10:32:06 -04:00
|
|
|
self.done = asyncio.Future(loop=loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def connection_made(self, transport):
|
|
|
|
self.transport = transport
|
|
|
|
assert self.state == 'INITIAL', self.state
|
|
|
|
self.state = 'INITIALIZED'
|
|
|
|
|
|
|
|
def datagram_received(self, data, addr):
|
|
|
|
assert self.state == 'INITIALIZED', self.state
|
|
|
|
self.nbytes += len(data)
|
|
|
|
|
2013-11-15 20:51:48 -04:00
|
|
|
def error_received(self, exc):
|
2013-10-17 17:40:50 -03:00
|
|
|
assert self.state == 'INITIALIZED', self.state
|
|
|
|
|
|
|
|
def connection_lost(self, exc):
|
|
|
|
assert self.state == 'INITIALIZED', self.state
|
|
|
|
self.state = 'CLOSED'
|
|
|
|
if self.done:
|
|
|
|
self.done.set_result(None)
|
|
|
|
|
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
class MyReadPipeProto(asyncio.Protocol):
|
2013-10-17 17:40:50 -03:00
|
|
|
done = None
|
|
|
|
|
|
|
|
def __init__(self, loop=None):
|
|
|
|
self.state = ['INITIAL']
|
|
|
|
self.nbytes = 0
|
|
|
|
self.transport = None
|
|
|
|
if loop is not None:
|
2014-01-25 10:32:06 -04:00
|
|
|
self.done = asyncio.Future(loop=loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def connection_made(self, transport):
|
|
|
|
self.transport = transport
|
|
|
|
assert self.state == ['INITIAL'], self.state
|
|
|
|
self.state.append('CONNECTED')
|
|
|
|
|
|
|
|
def data_received(self, data):
|
|
|
|
assert self.state == ['INITIAL', 'CONNECTED'], self.state
|
|
|
|
self.nbytes += len(data)
|
|
|
|
|
|
|
|
def eof_received(self):
|
|
|
|
assert self.state == ['INITIAL', 'CONNECTED'], self.state
|
|
|
|
self.state.append('EOF')
|
|
|
|
|
|
|
|
def connection_lost(self, exc):
|
2014-01-10 17:30:04 -04:00
|
|
|
if 'EOF' not in self.state:
|
|
|
|
self.state.append('EOF') # It is okay if EOF is missed.
|
2013-10-17 17:40:50 -03:00
|
|
|
assert self.state == ['INITIAL', 'CONNECTED', 'EOF'], self.state
|
|
|
|
self.state.append('CLOSED')
|
|
|
|
if self.done:
|
|
|
|
self.done.set_result(None)
|
|
|
|
|
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
class MyWritePipeProto(asyncio.BaseProtocol):
|
2013-10-17 17:40:50 -03:00
|
|
|
done = None
|
|
|
|
|
|
|
|
def __init__(self, loop=None):
|
|
|
|
self.state = 'INITIAL'
|
|
|
|
self.transport = None
|
|
|
|
if loop is not None:
|
2014-01-25 10:32:06 -04:00
|
|
|
self.done = asyncio.Future(loop=loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def connection_made(self, transport):
|
|
|
|
self.transport = transport
|
|
|
|
assert self.state == 'INITIAL', self.state
|
|
|
|
self.state = 'CONNECTED'
|
|
|
|
|
|
|
|
def connection_lost(self, exc):
|
|
|
|
assert self.state == 'CONNECTED', self.state
|
|
|
|
self.state = 'CLOSED'
|
|
|
|
if self.done:
|
|
|
|
self.done.set_result(None)
|
|
|
|
|
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
class MySubprocessProtocol(asyncio.SubprocessProtocol):
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def __init__(self, loop):
|
|
|
|
self.state = 'INITIAL'
|
|
|
|
self.transport = None
|
2014-01-25 10:32:06 -04:00
|
|
|
self.connected = asyncio.Future(loop=loop)
|
|
|
|
self.completed = asyncio.Future(loop=loop)
|
|
|
|
self.disconnects = {fd: asyncio.Future(loop=loop) for fd in range(3)}
|
2013-10-17 17:40:50 -03:00
|
|
|
self.data = {1: b'', 2: b''}
|
|
|
|
self.returncode = None
|
2014-01-25 10:32:06 -04:00
|
|
|
self.got_data = {1: asyncio.Event(loop=loop),
|
|
|
|
2: asyncio.Event(loop=loop)}
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def connection_made(self, transport):
|
|
|
|
self.transport = transport
|
|
|
|
assert self.state == 'INITIAL', self.state
|
|
|
|
self.state = 'CONNECTED'
|
|
|
|
self.connected.set_result(None)
|
|
|
|
|
|
|
|
def connection_lost(self, exc):
|
|
|
|
assert self.state == 'CONNECTED', self.state
|
|
|
|
self.state = 'CLOSED'
|
|
|
|
self.completed.set_result(None)
|
|
|
|
|
|
|
|
def pipe_data_received(self, fd, data):
|
|
|
|
assert self.state == 'CONNECTED', self.state
|
|
|
|
self.data[fd] += data
|
|
|
|
self.got_data[fd].set()
|
|
|
|
|
|
|
|
def pipe_connection_lost(self, fd, exc):
|
|
|
|
assert self.state == 'CONNECTED', self.state
|
|
|
|
if exc:
|
|
|
|
self.disconnects[fd].set_exception(exc)
|
|
|
|
else:
|
|
|
|
self.disconnects[fd].set_result(exc)
|
|
|
|
|
|
|
|
def process_exited(self):
|
|
|
|
assert self.state == 'CONNECTED', self.state
|
|
|
|
self.returncode = self.transport.get_returncode()
|
|
|
|
|
|
|
|
|
|
|
|
class EventLoopTestsMixin:
|
|
|
|
|
|
|
|
def setUp(self):
|
|
|
|
super().setUp()
|
|
|
|
self.loop = self.create_event_loop()
|
2014-06-17 20:36:32 -03:00
|
|
|
self.set_event_loop(self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def tearDown(self):
|
|
|
|
# just in case if we have transport close callbacks
|
2014-12-04 18:07:47 -04:00
|
|
|
if not self.loop.is_closed():
|
|
|
|
test_utils.run_briefly(self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2017-09-01 19:25:39 -03:00
|
|
|
self.doCleanups()
|
|
|
|
support.gc_collect()
|
2013-10-17 17:40:50 -03:00
|
|
|
super().tearDown()
|
|
|
|
|
|
|
|
def test_run_until_complete_nesting(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
@asyncio.coroutine
|
2013-10-17 17:40:50 -03:00
|
|
|
def coro1():
|
|
|
|
yield
|
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
@asyncio.coroutine
|
2013-10-17 17:40:50 -03:00
|
|
|
def coro2():
|
|
|
|
self.assertTrue(self.loop.is_running())
|
|
|
|
self.loop.run_until_complete(coro1())
|
|
|
|
|
|
|
|
self.assertRaises(
|
|
|
|
RuntimeError, self.loop.run_until_complete, coro2())
|
|
|
|
|
|
|
|
# Note: because of the default Windows timing granularity of
|
|
|
|
# 15.6 msec, we use fairly long sleep times here (~100 msec).
|
|
|
|
|
|
|
|
def test_run_until_complete(self):
|
|
|
|
t0 = self.loop.time()
|
2014-01-25 10:32:06 -04:00
|
|
|
self.loop.run_until_complete(asyncio.sleep(0.1, loop=self.loop))
|
2013-10-17 17:40:50 -03:00
|
|
|
t1 = self.loop.time()
|
2013-10-18 19:15:56 -03:00
|
|
|
self.assertTrue(0.08 <= t1-t0 <= 0.8, t1-t0)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_run_until_complete_stopped(self):
|
2017-12-08 18:23:48 -04:00
|
|
|
|
|
|
|
async def cb():
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.stop()
|
2017-12-08 18:23:48 -04:00
|
|
|
await asyncio.sleep(0.1, loop=self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
task = cb()
|
|
|
|
self.assertRaises(RuntimeError,
|
|
|
|
self.loop.run_until_complete, task)
|
|
|
|
|
|
|
|
def test_call_later(self):
|
|
|
|
results = []
|
|
|
|
|
|
|
|
def callback(arg):
|
|
|
|
results.append(arg)
|
|
|
|
self.loop.stop()
|
|
|
|
|
|
|
|
self.loop.call_later(0.1, callback, 'hello world')
|
|
|
|
t0 = time.monotonic()
|
|
|
|
self.loop.run_forever()
|
|
|
|
t1 = time.monotonic()
|
|
|
|
self.assertEqual(results, ['hello world'])
|
2013-10-18 19:15:56 -03:00
|
|
|
self.assertTrue(0.08 <= t1-t0 <= 0.8, t1-t0)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_call_soon(self):
|
|
|
|
results = []
|
|
|
|
|
|
|
|
def callback(arg1, arg2):
|
|
|
|
results.append((arg1, arg2))
|
|
|
|
self.loop.stop()
|
|
|
|
|
|
|
|
self.loop.call_soon(callback, 'hello', 'world')
|
|
|
|
self.loop.run_forever()
|
|
|
|
self.assertEqual(results, [('hello', 'world')])
|
|
|
|
|
|
|
|
def test_call_soon_threadsafe(self):
|
|
|
|
results = []
|
|
|
|
lock = threading.Lock()
|
|
|
|
|
|
|
|
def callback(arg):
|
|
|
|
results.append(arg)
|
|
|
|
if len(results) >= 2:
|
|
|
|
self.loop.stop()
|
|
|
|
|
|
|
|
def run_in_thread():
|
|
|
|
self.loop.call_soon_threadsafe(callback, 'hello')
|
|
|
|
lock.release()
|
|
|
|
|
|
|
|
lock.acquire()
|
|
|
|
t = threading.Thread(target=run_in_thread)
|
|
|
|
t.start()
|
|
|
|
|
|
|
|
with lock:
|
|
|
|
self.loop.call_soon(callback, 'world')
|
|
|
|
self.loop.run_forever()
|
|
|
|
t.join()
|
|
|
|
self.assertEqual(results, ['hello', 'world'])
|
|
|
|
|
|
|
|
def test_call_soon_threadsafe_same_thread(self):
|
|
|
|
results = []
|
|
|
|
|
|
|
|
def callback(arg):
|
|
|
|
results.append(arg)
|
|
|
|
if len(results) >= 2:
|
|
|
|
self.loop.stop()
|
|
|
|
|
|
|
|
self.loop.call_soon_threadsafe(callback, 'hello')
|
|
|
|
self.loop.call_soon(callback, 'world')
|
|
|
|
self.loop.run_forever()
|
|
|
|
self.assertEqual(results, ['hello', 'world'])
|
|
|
|
|
|
|
|
def test_run_in_executor(self):
|
|
|
|
def run(arg):
|
|
|
|
return (arg, threading.get_ident())
|
|
|
|
f2 = self.loop.run_in_executor(None, run, 'yo')
|
|
|
|
res, thread_id = self.loop.run_until_complete(f2)
|
|
|
|
self.assertEqual(res, 'yo')
|
|
|
|
self.assertNotEqual(thread_id, threading.get_ident())
|
|
|
|
|
2018-05-28 19:50:02 -03:00
|
|
|
def test_run_in_executor_cancel(self):
|
|
|
|
called = False
|
|
|
|
|
|
|
|
def patched_call_soon(*args):
|
|
|
|
nonlocal called
|
|
|
|
called = True
|
|
|
|
|
|
|
|
def run():
|
|
|
|
time.sleep(0.05)
|
|
|
|
|
|
|
|
f2 = self.loop.run_in_executor(None, run)
|
|
|
|
f2.cancel()
|
|
|
|
self.loop.close()
|
|
|
|
self.loop.call_soon = patched_call_soon
|
|
|
|
self.loop.call_soon_threadsafe = patched_call_soon
|
|
|
|
time.sleep(0.4)
|
|
|
|
self.assertFalse(called)
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_reader_callback(self):
|
2017-11-28 16:33:20 -04:00
|
|
|
r, w = socket.socketpair()
|
2014-03-05 20:00:36 -04:00
|
|
|
r.setblocking(False)
|
|
|
|
bytes_read = bytearray()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def reader():
|
|
|
|
try:
|
|
|
|
data = r.recv(1024)
|
|
|
|
except BlockingIOError:
|
|
|
|
# Spurious readiness notifications are possible
|
|
|
|
# at least on Linux -- see man select.
|
|
|
|
return
|
|
|
|
if data:
|
2014-03-05 20:00:36 -04:00
|
|
|
bytes_read.extend(data)
|
2013-10-17 17:40:50 -03:00
|
|
|
else:
|
|
|
|
self.assertTrue(self.loop.remove_reader(r.fileno()))
|
|
|
|
r.close()
|
|
|
|
|
|
|
|
self.loop.add_reader(r.fileno(), reader)
|
|
|
|
self.loop.call_soon(w.send, b'abc')
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: len(bytes_read) >= 3)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.call_soon(w.send, b'def')
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: len(bytes_read) >= 6)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.call_soon(w.close)
|
|
|
|
self.loop.call_soon(self.loop.stop)
|
|
|
|
self.loop.run_forever()
|
2014-03-05 20:00:36 -04:00
|
|
|
self.assertEqual(bytes_read, b'abcdef')
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_writer_callback(self):
|
2017-11-28 16:33:20 -04:00
|
|
|
r, w = socket.socketpair()
|
2013-10-17 17:40:50 -03:00
|
|
|
w.setblocking(False)
|
|
|
|
|
2014-03-05 20:00:36 -04:00
|
|
|
def writer(data):
|
|
|
|
w.send(data)
|
|
|
|
self.loop.stop()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-03-05 20:00:36 -04:00
|
|
|
data = b'x' * 1024
|
|
|
|
self.loop.add_writer(w.fileno(), writer, data)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_forever()
|
2014-03-05 20:00:36 -04:00
|
|
|
|
|
|
|
self.assertTrue(self.loop.remove_writer(w.fileno()))
|
|
|
|
self.assertFalse(self.loop.remove_writer(w.fileno()))
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
w.close()
|
2014-03-05 20:00:36 -04:00
|
|
|
read = r.recv(len(data) * 2)
|
2013-10-17 17:40:50 -03:00
|
|
|
r.close()
|
2014-03-05 20:00:36 -04:00
|
|
|
self.assertEqual(read, data)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
def _basetest_sock_client_ops(self, httpd, sock):
|
2014-08-25 18:20:52 -03:00
|
|
|
if not isinstance(self.loop, proactor_events.BaseProactorEventLoop):
|
|
|
|
# in debug mode, socket operations must fail
|
|
|
|
# if the socket is not in blocking mode
|
|
|
|
self.loop.set_debug(True)
|
|
|
|
sock.setblocking(True)
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_connect(sock, httpd.address))
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_sendall(sock, b'GET / HTTP/1.0\r\n\r\n'))
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_recv(sock, 1024))
|
2017-10-19 16:46:40 -03:00
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_recv_into(sock, bytearray()))
|
2014-08-25 18:20:52 -03:00
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_accept(sock))
|
2014-07-29 18:08:17 -03:00
|
|
|
|
|
|
|
# test in non-blocking mode
|
2014-02-18 13:15:06 -04:00
|
|
|
sock.setblocking(False)
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_connect(sock, httpd.address))
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_sendall(sock, b'GET / HTTP/1.0\r\n\r\n'))
|
|
|
|
data = self.loop.run_until_complete(
|
|
|
|
self.loop.sock_recv(sock, 1024))
|
|
|
|
# consume data
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_recv(sock, 1024))
|
|
|
|
sock.close()
|
|
|
|
self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
|
|
|
|
|
2017-10-19 16:46:40 -03:00
|
|
|
def _basetest_sock_recv_into(self, httpd, sock):
|
|
|
|
# same as _basetest_sock_client_ops, but using sock_recv_into
|
|
|
|
sock.setblocking(False)
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_connect(sock, httpd.address))
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_sendall(sock, b'GET / HTTP/1.0\r\n\r\n'))
|
|
|
|
data = bytearray(1024)
|
|
|
|
with memoryview(data) as buf:
|
|
|
|
nbytes = self.loop.run_until_complete(
|
|
|
|
self.loop.sock_recv_into(sock, buf[:1024]))
|
|
|
|
# consume data
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_recv_into(sock, buf[nbytes:]))
|
|
|
|
sock.close()
|
|
|
|
self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_sock_client_ops(self):
|
|
|
|
with test_utils.run_test_server() as httpd:
|
|
|
|
sock = socket.socket()
|
2014-02-18 13:15:06 -04:00
|
|
|
self._basetest_sock_client_ops(httpd, sock)
|
2017-10-19 16:46:40 -03:00
|
|
|
sock = socket.socket()
|
|
|
|
self._basetest_sock_recv_into(httpd, sock)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2017-11-24 12:35:55 -04:00
|
|
|
@support.skip_unless_bind_unix_socket
|
2014-02-18 13:15:06 -04:00
|
|
|
def test_unix_sock_client_ops(self):
|
|
|
|
with test_utils.run_test_unix_server() as httpd:
|
|
|
|
sock = socket.socket(socket.AF_UNIX)
|
|
|
|
self._basetest_sock_client_ops(httpd, sock)
|
2017-10-19 16:46:40 -03:00
|
|
|
sock = socket.socket(socket.AF_UNIX)
|
|
|
|
self._basetest_sock_recv_into(httpd, sock)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_sock_client_fail(self):
|
|
|
|
# Make sure that we will get an unused port
|
|
|
|
address = None
|
|
|
|
try:
|
|
|
|
s = socket.socket()
|
|
|
|
s.bind(('127.0.0.1', 0))
|
|
|
|
address = s.getsockname()
|
|
|
|
finally:
|
|
|
|
s.close()
|
|
|
|
|
|
|
|
sock = socket.socket()
|
|
|
|
sock.setblocking(False)
|
|
|
|
with self.assertRaises(ConnectionRefusedError):
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_connect(sock, address))
|
|
|
|
sock.close()
|
|
|
|
|
|
|
|
def test_sock_accept(self):
|
|
|
|
listener = socket.socket()
|
|
|
|
listener.setblocking(False)
|
|
|
|
listener.bind(('127.0.0.1', 0))
|
|
|
|
listener.listen(1)
|
|
|
|
client = socket.socket()
|
|
|
|
client.connect(listener.getsockname())
|
|
|
|
|
|
|
|
f = self.loop.sock_accept(listener)
|
|
|
|
conn, addr = self.loop.run_until_complete(f)
|
|
|
|
self.assertEqual(conn.gettimeout(), 0)
|
|
|
|
self.assertEqual(addr, client.getsockname())
|
|
|
|
self.assertEqual(client.getpeername(), listener.getsockname())
|
|
|
|
client.close()
|
|
|
|
conn.close()
|
|
|
|
listener.close()
|
|
|
|
|
|
|
|
@unittest.skipUnless(hasattr(signal, 'SIGKILL'), 'No SIGKILL')
|
|
|
|
def test_add_signal_handler(self):
|
|
|
|
caught = 0
|
|
|
|
|
|
|
|
def my_handler():
|
|
|
|
nonlocal caught
|
|
|
|
caught += 1
|
|
|
|
|
|
|
|
# Check error behavior first.
|
|
|
|
self.assertRaises(
|
|
|
|
TypeError, self.loop.add_signal_handler, 'boom', my_handler)
|
|
|
|
self.assertRaises(
|
|
|
|
TypeError, self.loop.remove_signal_handler, 'boom')
|
|
|
|
self.assertRaises(
|
|
|
|
ValueError, self.loop.add_signal_handler, signal.NSIG+1,
|
|
|
|
my_handler)
|
|
|
|
self.assertRaises(
|
|
|
|
ValueError, self.loop.remove_signal_handler, signal.NSIG+1)
|
|
|
|
self.assertRaises(
|
|
|
|
ValueError, self.loop.add_signal_handler, 0, my_handler)
|
|
|
|
self.assertRaises(
|
|
|
|
ValueError, self.loop.remove_signal_handler, 0)
|
|
|
|
self.assertRaises(
|
|
|
|
ValueError, self.loop.add_signal_handler, -1, my_handler)
|
|
|
|
self.assertRaises(
|
|
|
|
ValueError, self.loop.remove_signal_handler, -1)
|
|
|
|
self.assertRaises(
|
|
|
|
RuntimeError, self.loop.add_signal_handler, signal.SIGKILL,
|
|
|
|
my_handler)
|
|
|
|
# Removing SIGKILL doesn't raise, since we don't call signal().
|
|
|
|
self.assertFalse(self.loop.remove_signal_handler(signal.SIGKILL))
|
|
|
|
# Now set a handler and handle it.
|
|
|
|
self.loop.add_signal_handler(signal.SIGINT, my_handler)
|
2014-03-05 20:00:36 -04:00
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
os.kill(os.getpid(), signal.SIGINT)
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: caught)
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
# Removing it should restore the default handler.
|
|
|
|
self.assertTrue(self.loop.remove_signal_handler(signal.SIGINT))
|
|
|
|
self.assertEqual(signal.getsignal(signal.SIGINT),
|
|
|
|
signal.default_int_handler)
|
|
|
|
# Removing again returns False.
|
|
|
|
self.assertFalse(self.loop.remove_signal_handler(signal.SIGINT))
|
|
|
|
|
|
|
|
@unittest.skipUnless(hasattr(signal, 'SIGALRM'), 'No SIGALRM')
|
|
|
|
def test_signal_handling_while_selecting(self):
|
|
|
|
# Test with a signal actually arriving during a select() call.
|
|
|
|
caught = 0
|
|
|
|
|
|
|
|
def my_handler():
|
|
|
|
nonlocal caught
|
|
|
|
caught += 1
|
|
|
|
self.loop.stop()
|
|
|
|
|
|
|
|
self.loop.add_signal_handler(signal.SIGALRM, my_handler)
|
|
|
|
|
|
|
|
signal.setitimer(signal.ITIMER_REAL, 0.01, 0) # Send SIGALRM once.
|
2018-12-28 22:01:00 -04:00
|
|
|
self.loop.call_later(60, self.loop.stop)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_forever()
|
|
|
|
self.assertEqual(caught, 1)
|
|
|
|
|
|
|
|
@unittest.skipUnless(hasattr(signal, 'SIGALRM'), 'No SIGALRM')
|
|
|
|
def test_signal_handling_args(self):
|
|
|
|
some_args = (42,)
|
|
|
|
caught = 0
|
|
|
|
|
|
|
|
def my_handler(*args):
|
|
|
|
nonlocal caught
|
|
|
|
caught += 1
|
|
|
|
self.assertEqual(args, some_args)
|
2018-12-28 22:01:00 -04:00
|
|
|
self.loop.stop()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
self.loop.add_signal_handler(signal.SIGALRM, my_handler, *some_args)
|
|
|
|
|
2013-10-18 19:15:56 -03:00
|
|
|
signal.setitimer(signal.ITIMER_REAL, 0.1, 0) # Send SIGALRM once.
|
2018-12-28 22:01:00 -04:00
|
|
|
self.loop.call_later(60, self.loop.stop)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_forever()
|
|
|
|
self.assertEqual(caught, 1)
|
|
|
|
|
2014-02-19 13:32:03 -04:00
|
|
|
def _basetest_create_connection(self, connection_fut, check_sockname=True):
|
2014-02-18 13:15:06 -04:00
|
|
|
tr, pr = self.loop.run_until_complete(connection_fut)
|
|
|
|
self.assertIsInstance(tr, asyncio.Transport)
|
|
|
|
self.assertIsInstance(pr, asyncio.Protocol)
|
2014-07-08 18:57:31 -03:00
|
|
|
self.assertIs(pr.transport, tr)
|
2014-02-19 13:10:32 -04:00
|
|
|
if check_sockname:
|
|
|
|
self.assertIsNotNone(tr.get_extra_info('sockname'))
|
2014-02-18 13:15:06 -04:00
|
|
|
self.loop.run_until_complete(pr.done)
|
|
|
|
self.assertGreater(pr.nbytes, 0)
|
|
|
|
tr.close()
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_create_connection(self):
|
|
|
|
with test_utils.run_test_server() as httpd:
|
2014-02-18 13:15:06 -04:00
|
|
|
conn_fut = self.loop.create_connection(
|
2013-10-17 17:40:50 -03:00
|
|
|
lambda: MyProto(loop=self.loop), *httpd.address)
|
2014-02-18 13:15:06 -04:00
|
|
|
self._basetest_create_connection(conn_fut)
|
|
|
|
|
2017-11-24 12:35:55 -04:00
|
|
|
@support.skip_unless_bind_unix_socket
|
2014-02-18 13:15:06 -04:00
|
|
|
def test_create_unix_connection(self):
|
2014-02-19 13:10:32 -04:00
|
|
|
# Issue #20682: On Mac OS X Tiger, getsockname() returns a
|
|
|
|
# zero-length address for UNIX socket.
|
2018-09-13 21:03:35 -03:00
|
|
|
check_sockname = not broken_unix_getsockname()
|
2014-02-19 13:10:32 -04:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
with test_utils.run_test_unix_server() as httpd:
|
|
|
|
conn_fut = self.loop.create_unix_connection(
|
|
|
|
lambda: MyProto(loop=self.loop), httpd.address)
|
2014-02-19 13:10:32 -04:00
|
|
|
self._basetest_create_connection(conn_fut, check_sockname)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_create_connection_sock(self):
|
|
|
|
with test_utils.run_test_server() as httpd:
|
|
|
|
sock = None
|
|
|
|
infos = self.loop.run_until_complete(
|
|
|
|
self.loop.getaddrinfo(
|
|
|
|
*httpd.address, type=socket.SOCK_STREAM))
|
|
|
|
for family, type, proto, cname, address in infos:
|
|
|
|
try:
|
|
|
|
sock = socket.socket(family=family, type=type, proto=proto)
|
|
|
|
sock.setblocking(False)
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sock_connect(sock, address))
|
|
|
|
except:
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
break
|
|
|
|
else:
|
|
|
|
assert False, 'Can not create socket.'
|
|
|
|
|
|
|
|
f = self.loop.create_connection(
|
|
|
|
lambda: MyProto(loop=self.loop), sock=sock)
|
|
|
|
tr, pr = self.loop.run_until_complete(f)
|
2014-01-25 10:32:06 -04:00
|
|
|
self.assertIsInstance(tr, asyncio.Transport)
|
|
|
|
self.assertIsInstance(pr, asyncio.Protocol)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(pr.done)
|
|
|
|
self.assertGreater(pr.nbytes, 0)
|
|
|
|
tr.close()
|
|
|
|
|
2015-09-21 13:06:17 -03:00
|
|
|
def check_ssl_extra_info(self, client, check_sockname=True,
|
|
|
|
peername=None, peercert={}):
|
|
|
|
if check_sockname:
|
|
|
|
self.assertIsNotNone(client.get_extra_info('sockname'))
|
|
|
|
if peername:
|
|
|
|
self.assertEqual(peername,
|
|
|
|
client.get_extra_info('peername'))
|
|
|
|
else:
|
|
|
|
self.assertIsNotNone(client.get_extra_info('peername'))
|
|
|
|
self.assertEqual(peercert,
|
|
|
|
client.get_extra_info('peercert'))
|
|
|
|
|
|
|
|
# test SSL cipher
|
|
|
|
cipher = client.get_extra_info('cipher')
|
|
|
|
self.assertIsInstance(cipher, tuple)
|
|
|
|
self.assertEqual(len(cipher), 3, cipher)
|
|
|
|
self.assertIsInstance(cipher[0], str)
|
|
|
|
self.assertIsInstance(cipher[1], str)
|
|
|
|
self.assertIsInstance(cipher[2], int)
|
|
|
|
|
|
|
|
# test SSL object
|
|
|
|
sslobj = client.get_extra_info('ssl_object')
|
|
|
|
self.assertIsNotNone(sslobj)
|
|
|
|
self.assertEqual(sslobj.compression(),
|
|
|
|
client.get_extra_info('compression'))
|
|
|
|
self.assertEqual(sslobj.cipher(),
|
|
|
|
client.get_extra_info('cipher'))
|
|
|
|
self.assertEqual(sslobj.getpeercert(),
|
|
|
|
client.get_extra_info('peercert'))
|
2015-09-21 17:20:19 -03:00
|
|
|
self.assertEqual(sslobj.compression(),
|
|
|
|
client.get_extra_info('compression'))
|
2015-09-21 13:06:17 -03:00
|
|
|
|
2014-02-19 13:10:32 -04:00
|
|
|
def _basetest_create_ssl_connection(self, connection_fut,
|
2015-09-21 13:06:17 -03:00
|
|
|
check_sockname=True,
|
|
|
|
peername=None):
|
2014-02-18 13:15:06 -04:00
|
|
|
tr, pr = self.loop.run_until_complete(connection_fut)
|
|
|
|
self.assertIsInstance(tr, asyncio.Transport)
|
|
|
|
self.assertIsInstance(pr, asyncio.Protocol)
|
|
|
|
self.assertTrue('ssl' in tr.__class__.__name__.lower())
|
2015-09-21 13:06:17 -03:00
|
|
|
self.check_ssl_extra_info(tr, check_sockname, peername)
|
2014-02-18 13:15:06 -04:00
|
|
|
self.loop.run_until_complete(pr.done)
|
|
|
|
self.assertGreater(pr.nbytes, 0)
|
|
|
|
tr.close()
|
|
|
|
|
2014-10-15 11:58:21 -03:00
|
|
|
def _test_create_ssl_connection(self, httpd, create_connection,
|
2015-09-21 13:06:17 -03:00
|
|
|
check_sockname=True, peername=None):
|
2014-10-15 11:58:21 -03:00
|
|
|
conn_fut = create_connection(ssl=test_utils.dummy_ssl_context())
|
2015-09-21 13:06:17 -03:00
|
|
|
self._basetest_create_ssl_connection(conn_fut, check_sockname,
|
|
|
|
peername)
|
2014-10-15 11:58:21 -03:00
|
|
|
|
2014-11-20 09:16:31 -04:00
|
|
|
# ssl.Purpose was introduced in Python 3.4
|
|
|
|
if hasattr(ssl, 'Purpose'):
|
|
|
|
def _dummy_ssl_create_context(purpose=ssl.Purpose.SERVER_AUTH, *,
|
|
|
|
cafile=None, capath=None,
|
|
|
|
cadata=None):
|
|
|
|
"""
|
|
|
|
A ssl.create_default_context() replacement that doesn't enable
|
|
|
|
cert validation.
|
|
|
|
"""
|
|
|
|
self.assertEqual(purpose, ssl.Purpose.SERVER_AUTH)
|
|
|
|
return test_utils.dummy_ssl_context()
|
|
|
|
|
|
|
|
# With ssl=True, ssl.create_default_context() should be called
|
|
|
|
with mock.patch('ssl.create_default_context',
|
|
|
|
side_effect=_dummy_ssl_create_context) as m:
|
|
|
|
conn_fut = create_connection(ssl=True)
|
2015-09-21 13:06:17 -03:00
|
|
|
self._basetest_create_ssl_connection(conn_fut, check_sockname,
|
|
|
|
peername)
|
2014-11-20 09:16:31 -04:00
|
|
|
self.assertEqual(m.call_count, 1)
|
2014-10-15 11:58:21 -03:00
|
|
|
|
|
|
|
# With the real ssl.create_default_context(), certificate
|
|
|
|
# validation will fail
|
|
|
|
with self.assertRaises(ssl.SSLError) as cm:
|
|
|
|
conn_fut = create_connection(ssl=True)
|
2014-11-20 09:19:23 -04:00
|
|
|
# Ignore the "SSL handshake failed" log in debug mode
|
|
|
|
with test_utils.disable_logger():
|
2015-09-21 13:06:17 -03:00
|
|
|
self._basetest_create_ssl_connection(conn_fut, check_sockname,
|
|
|
|
peername)
|
2014-10-15 11:58:21 -03:00
|
|
|
|
|
|
|
self.assertEqual(cm.exception.reason, 'CERTIFICATE_VERIFY_FAILED')
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
@unittest.skipIf(ssl is None, 'No ssl module')
|
|
|
|
def test_create_ssl_connection(self):
|
|
|
|
with test_utils.run_test_server(use_ssl=True) as httpd:
|
2014-10-15 11:58:21 -03:00
|
|
|
create_connection = functools.partial(
|
|
|
|
self.loop.create_connection,
|
2014-02-18 13:15:06 -04:00
|
|
|
lambda: MyProto(loop=self.loop),
|
2014-10-15 11:58:21 -03:00
|
|
|
*httpd.address)
|
2015-09-21 13:06:17 -03:00
|
|
|
self._test_create_ssl_connection(httpd, create_connection,
|
|
|
|
peername=httpd.address)
|
2014-02-18 13:15:06 -04:00
|
|
|
|
2017-11-24 12:35:55 -04:00
|
|
|
@support.skip_unless_bind_unix_socket
|
2014-02-18 13:15:06 -04:00
|
|
|
@unittest.skipIf(ssl is None, 'No ssl module')
|
|
|
|
def test_create_ssl_unix_connection(self):
|
2014-02-19 13:10:32 -04:00
|
|
|
# Issue #20682: On Mac OS X Tiger, getsockname() returns a
|
|
|
|
# zero-length address for UNIX socket.
|
2018-09-13 21:03:35 -03:00
|
|
|
check_sockname = not broken_unix_getsockname()
|
2014-02-19 13:10:32 -04:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
with test_utils.run_test_unix_server(use_ssl=True) as httpd:
|
2014-10-15 11:58:21 -03:00
|
|
|
create_connection = functools.partial(
|
|
|
|
self.loop.create_unix_connection,
|
|
|
|
lambda: MyProto(loop=self.loop), httpd.address,
|
2014-02-18 13:15:06 -04:00
|
|
|
server_hostname='127.0.0.1')
|
|
|
|
|
2014-10-15 11:58:21 -03:00
|
|
|
self._test_create_ssl_connection(httpd, create_connection,
|
2015-09-21 13:06:17 -03:00
|
|
|
check_sockname,
|
|
|
|
peername=httpd.address)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_create_connection_local_addr(self):
|
|
|
|
with test_utils.run_test_server() as httpd:
|
2013-12-05 19:23:13 -04:00
|
|
|
port = support.find_unused_port()
|
2013-10-17 17:40:50 -03:00
|
|
|
f = self.loop.create_connection(
|
|
|
|
lambda: MyProto(loop=self.loop),
|
|
|
|
*httpd.address, local_addr=(httpd.address[0], port))
|
|
|
|
tr, pr = self.loop.run_until_complete(f)
|
|
|
|
expected = pr.transport.get_extra_info('sockname')[1]
|
|
|
|
self.assertEqual(port, expected)
|
|
|
|
tr.close()
|
|
|
|
|
|
|
|
def test_create_connection_local_addr_in_use(self):
|
|
|
|
with test_utils.run_test_server() as httpd:
|
|
|
|
f = self.loop.create_connection(
|
|
|
|
lambda: MyProto(loop=self.loop),
|
|
|
|
*httpd.address, local_addr=httpd.address)
|
|
|
|
with self.assertRaises(OSError) as cm:
|
|
|
|
self.loop.run_until_complete(f)
|
|
|
|
self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
|
|
|
|
self.assertIn(str(httpd.address), cm.exception.strerror)
|
|
|
|
|
2016-07-12 19:23:10 -03:00
|
|
|
def test_connect_accepted_socket(self, server_ssl=None, client_ssl=None):
|
|
|
|
loop = self.loop
|
|
|
|
|
|
|
|
class MyProto(MyBaseProto):
|
|
|
|
|
|
|
|
def connection_lost(self, exc):
|
|
|
|
super().connection_lost(exc)
|
|
|
|
loop.call_soon(loop.stop)
|
|
|
|
|
|
|
|
def data_received(self, data):
|
|
|
|
super().data_received(data)
|
|
|
|
self.transport.write(expected_response)
|
|
|
|
|
|
|
|
lsock = socket.socket()
|
|
|
|
lsock.bind(('127.0.0.1', 0))
|
|
|
|
lsock.listen(1)
|
|
|
|
addr = lsock.getsockname()
|
|
|
|
|
|
|
|
message = b'test data'
|
2016-08-31 13:08:41 -03:00
|
|
|
response = None
|
2016-07-12 19:23:10 -03:00
|
|
|
expected_response = b'roger'
|
|
|
|
|
|
|
|
def client():
|
2016-08-31 13:08:41 -03:00
|
|
|
nonlocal response
|
2016-07-12 19:23:10 -03:00
|
|
|
try:
|
|
|
|
csock = socket.socket()
|
|
|
|
if client_ssl is not None:
|
|
|
|
csock = client_ssl.wrap_socket(csock)
|
|
|
|
csock.connect(addr)
|
|
|
|
csock.sendall(message)
|
|
|
|
response = csock.recv(99)
|
|
|
|
csock.close()
|
|
|
|
except Exception as exc:
|
|
|
|
print(
|
|
|
|
"Failure in client thread in test_connect_accepted_socket",
|
|
|
|
exc)
|
|
|
|
|
|
|
|
thread = threading.Thread(target=client, daemon=True)
|
|
|
|
thread.start()
|
|
|
|
|
|
|
|
conn, _ = lsock.accept()
|
|
|
|
proto = MyProto(loop=loop)
|
|
|
|
proto.loop = loop
|
2016-11-09 16:47:00 -04:00
|
|
|
loop.run_until_complete(
|
2016-07-12 19:23:10 -03:00
|
|
|
loop.connect_accepted_socket(
|
2016-11-09 16:47:00 -04:00
|
|
|
(lambda: proto), conn, ssl=server_ssl))
|
2016-07-12 19:23:10 -03:00
|
|
|
loop.run_forever()
|
2016-09-09 18:26:31 -03:00
|
|
|
proto.transport.close()
|
2016-07-12 19:23:10 -03:00
|
|
|
lsock.close()
|
|
|
|
|
2017-09-14 18:40:56 -03:00
|
|
|
support.join_thread(thread, timeout=1)
|
2016-07-12 19:23:10 -03:00
|
|
|
self.assertFalse(thread.is_alive())
|
|
|
|
self.assertEqual(proto.state, 'CLOSED')
|
|
|
|
self.assertEqual(proto.nbytes, len(message))
|
|
|
|
self.assertEqual(response, expected_response)
|
|
|
|
|
|
|
|
@unittest.skipIf(ssl is None, 'No ssl module')
|
|
|
|
def test_ssl_connect_accepted_socket(self):
|
|
|
|
if (sys.platform == 'win32' and
|
|
|
|
sys.version_info < (3, 5) and
|
|
|
|
isinstance(self.loop, proactor_events.BaseProactorEventLoop)
|
|
|
|
):
|
|
|
|
raise unittest.SkipTest(
|
|
|
|
'SSL not supported with proactor event loops before Python 3.5'
|
|
|
|
)
|
|
|
|
|
2017-12-30 01:35:36 -04:00
|
|
|
server_context = test_utils.simple_server_sslcontext()
|
|
|
|
client_context = test_utils.simple_client_sslcontext()
|
2016-07-12 19:23:10 -03:00
|
|
|
|
|
|
|
self.test_connect_accepted_socket(server_context, client_context)
|
|
|
|
|
2017-12-20 14:24:43 -04:00
|
|
|
def test_connect_accepted_socket_ssl_timeout_for_plain_socket(self):
|
|
|
|
sock = socket.socket()
|
|
|
|
self.addCleanup(sock.close)
|
|
|
|
coro = self.loop.connect_accepted_socket(
|
|
|
|
MyProto, sock, ssl_handshake_timeout=1)
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
ValueError,
|
|
|
|
'ssl_handshake_timeout is only meaningful with ssl'):
|
|
|
|
self.loop.run_until_complete(coro)
|
|
|
|
|
2015-09-21 13:33:43 -03:00
|
|
|
@mock.patch('asyncio.base_events.socket')
|
|
|
|
def create_server_multiple_hosts(self, family, hosts, mock_sock):
|
|
|
|
@asyncio.coroutine
|
|
|
|
def getaddrinfo(host, port, *args, **kw):
|
|
|
|
if family == socket.AF_INET:
|
2016-03-02 12:17:01 -04:00
|
|
|
return [(family, socket.SOCK_STREAM, 6, '', (host, port))]
|
2015-09-21 13:33:43 -03:00
|
|
|
else:
|
2016-03-02 12:17:01 -04:00
|
|
|
return [(family, socket.SOCK_STREAM, 6, '', (host, port, 0, 0))]
|
2015-09-21 13:33:43 -03:00
|
|
|
|
|
|
|
def getaddrinfo_task(*args, **kwds):
|
|
|
|
return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop)
|
|
|
|
|
2016-03-02 12:17:01 -04:00
|
|
|
unique_hosts = set(hosts)
|
|
|
|
|
2015-09-21 13:33:43 -03:00
|
|
|
if family == socket.AF_INET:
|
2016-03-02 12:17:01 -04:00
|
|
|
mock_sock.socket().getsockbyname.side_effect = [
|
|
|
|
(host, 80) for host in unique_hosts]
|
2015-09-21 13:33:43 -03:00
|
|
|
else:
|
2016-03-02 12:17:01 -04:00
|
|
|
mock_sock.socket().getsockbyname.side_effect = [
|
|
|
|
(host, 80, 0, 0) for host in unique_hosts]
|
2015-09-21 13:33:43 -03:00
|
|
|
self.loop.getaddrinfo = getaddrinfo_task
|
|
|
|
self.loop._start_serving = mock.Mock()
|
2015-09-21 17:28:44 -03:00
|
|
|
self.loop._stop_serving = mock.Mock()
|
2015-09-21 13:33:43 -03:00
|
|
|
f = self.loop.create_server(lambda: MyProto(self.loop), hosts, 80)
|
|
|
|
server = self.loop.run_until_complete(f)
|
|
|
|
self.addCleanup(server.close)
|
2016-03-02 12:17:01 -04:00
|
|
|
server_hosts = {sock.getsockbyname()[0] for sock in server.sockets}
|
|
|
|
self.assertEqual(server_hosts, unique_hosts)
|
2015-09-21 13:33:43 -03:00
|
|
|
|
|
|
|
def test_create_server_multiple_hosts_ipv4(self):
|
|
|
|
self.create_server_multiple_hosts(socket.AF_INET,
|
2016-03-02 12:17:01 -04:00
|
|
|
['1.2.3.4', '5.6.7.8', '1.2.3.4'])
|
2015-09-21 13:33:43 -03:00
|
|
|
|
|
|
|
def test_create_server_multiple_hosts_ipv6(self):
|
2016-03-02 12:17:01 -04:00
|
|
|
self.create_server_multiple_hosts(socket.AF_INET6,
|
|
|
|
['::1', '::2', '::1'])
|
2015-09-21 13:33:43 -03:00
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_create_server(self):
|
2014-03-05 20:00:36 -04:00
|
|
|
proto = MyProto(self.loop)
|
2014-02-18 13:15:06 -04:00
|
|
|
f = self.loop.create_server(lambda: proto, '0.0.0.0', 0)
|
2013-10-17 17:40:50 -03:00
|
|
|
server = self.loop.run_until_complete(f)
|
|
|
|
self.assertEqual(len(server.sockets), 1)
|
|
|
|
sock = server.sockets[0]
|
|
|
|
host, port = sock.getsockname()
|
|
|
|
self.assertEqual(host, '0.0.0.0')
|
|
|
|
client = socket.socket()
|
|
|
|
client.connect(('127.0.0.1', port))
|
2013-10-19 20:51:25 -03:00
|
|
|
client.sendall(b'xxx')
|
2014-03-05 20:00:36 -04:00
|
|
|
|
|
|
|
self.loop.run_until_complete(proto.connected)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
2014-03-05 20:00:36 -04:00
|
|
|
|
|
|
|
test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual(3, proto.nbytes)
|
|
|
|
|
|
|
|
# extra info is available
|
|
|
|
self.assertIsNotNone(proto.transport.get_extra_info('sockname'))
|
|
|
|
self.assertEqual('127.0.0.1',
|
|
|
|
proto.transport.get_extra_info('peername')[0])
|
|
|
|
|
|
|
|
# close connection
|
|
|
|
proto.transport.close()
|
2014-03-05 20:00:36 -04:00
|
|
|
self.loop.run_until_complete(proto.done)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
self.assertEqual('CLOSED', proto.state)
|
|
|
|
|
|
|
|
# the client socket must be closed after to avoid ECONNRESET upon
|
|
|
|
# recv()/send() on the serving socket
|
|
|
|
client.close()
|
|
|
|
|
|
|
|
# close server
|
|
|
|
server.close()
|
|
|
|
|
2015-10-05 13:15:28 -03:00
|
|
|
@unittest.skipUnless(hasattr(socket, 'SO_REUSEPORT'), 'No SO_REUSEPORT')
|
|
|
|
def test_create_server_reuse_port(self):
|
|
|
|
proto = MyProto(self.loop)
|
|
|
|
f = self.loop.create_server(
|
|
|
|
lambda: proto, '0.0.0.0', 0)
|
|
|
|
server = self.loop.run_until_complete(f)
|
|
|
|
self.assertEqual(len(server.sockets), 1)
|
|
|
|
sock = server.sockets[0]
|
|
|
|
self.assertFalse(
|
|
|
|
sock.getsockopt(
|
|
|
|
socket.SOL_SOCKET, socket.SO_REUSEPORT))
|
|
|
|
server.close()
|
|
|
|
|
|
|
|
test_utils.run_briefly(self.loop)
|
|
|
|
|
|
|
|
proto = MyProto(self.loop)
|
|
|
|
f = self.loop.create_server(
|
|
|
|
lambda: proto, '0.0.0.0', 0, reuse_port=True)
|
|
|
|
server = self.loop.run_until_complete(f)
|
|
|
|
self.assertEqual(len(server.sockets), 1)
|
|
|
|
sock = server.sockets[0]
|
|
|
|
self.assertTrue(
|
|
|
|
sock.getsockopt(
|
|
|
|
socket.SOL_SOCKET, socket.SO_REUSEPORT))
|
|
|
|
server.close()
|
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
def _make_unix_server(self, factory, **kwargs):
|
|
|
|
path = test_utils.gen_unix_socket_path()
|
|
|
|
self.addCleanup(lambda: os.path.exists(path) and os.unlink(path))
|
|
|
|
|
|
|
|
f = self.loop.create_unix_server(factory, path, **kwargs)
|
|
|
|
server = self.loop.run_until_complete(f)
|
|
|
|
|
|
|
|
return server, path
|
|
|
|
|
2017-11-24 12:35:55 -04:00
|
|
|
@support.skip_unless_bind_unix_socket
|
2014-02-18 13:15:06 -04:00
|
|
|
def test_create_unix_server(self):
|
2014-03-05 20:00:36 -04:00
|
|
|
proto = MyProto(loop=self.loop)
|
2014-02-18 13:15:06 -04:00
|
|
|
server, path = self._make_unix_server(lambda: proto)
|
|
|
|
self.assertEqual(len(server.sockets), 1)
|
|
|
|
|
|
|
|
client = socket.socket(socket.AF_UNIX)
|
|
|
|
client.connect(path)
|
|
|
|
client.sendall(b'xxx')
|
|
|
|
|
2014-03-05 20:00:36 -04:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
2014-02-18 13:15:06 -04:00
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
|
2014-02-18 13:15:06 -04:00
|
|
|
self.assertEqual(3, proto.nbytes)
|
|
|
|
|
|
|
|
# close connection
|
|
|
|
proto.transport.close()
|
2014-03-05 20:00:36 -04:00
|
|
|
self.loop.run_until_complete(proto.done)
|
2014-02-18 13:15:06 -04:00
|
|
|
|
|
|
|
self.assertEqual('CLOSED', proto.state)
|
|
|
|
|
|
|
|
# the client socket must be closed after to avoid ECONNRESET upon
|
|
|
|
# recv()/send() on the serving socket
|
|
|
|
client.close()
|
|
|
|
|
|
|
|
# close server
|
|
|
|
server.close()
|
|
|
|
|
2014-04-07 06:18:54 -03:00
|
|
|
@unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'No UNIX Sockets')
|
|
|
|
def test_create_unix_server_path_socket_error(self):
|
|
|
|
proto = MyProto(loop=self.loop)
|
|
|
|
sock = socket.socket()
|
|
|
|
with sock:
|
|
|
|
f = self.loop.create_unix_server(lambda: proto, '/test', sock=sock)
|
|
|
|
with self.assertRaisesRegex(ValueError,
|
|
|
|
'path and sock can not be specified '
|
|
|
|
'at the same time'):
|
2014-07-11 06:58:33 -03:00
|
|
|
self.loop.run_until_complete(f)
|
2014-04-07 06:18:54 -03:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
def _create_ssl_context(self, certfile, keyfile=None):
|
2017-09-15 15:27:30 -03:00
|
|
|
sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
|
2013-12-05 19:23:13 -04:00
|
|
|
sslcontext.options |= ssl.OP_NO_SSLv2
|
|
|
|
sslcontext.load_cert_chain(certfile, keyfile)
|
2014-02-18 13:15:06 -04:00
|
|
|
return sslcontext
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
def _make_ssl_server(self, factory, certfile, keyfile=None):
|
|
|
|
sslcontext = self._create_ssl_context(certfile, keyfile)
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
f = self.loop.create_server(factory, '127.0.0.1', 0, ssl=sslcontext)
|
2013-12-05 19:23:13 -04:00
|
|
|
server = self.loop.run_until_complete(f)
|
2014-02-18 13:15:06 -04:00
|
|
|
|
2013-12-05 19:23:13 -04:00
|
|
|
sock = server.sockets[0]
|
|
|
|
host, port = sock.getsockname()
|
|
|
|
self.assertEqual(host, '127.0.0.1')
|
|
|
|
return server, host, port
|
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
def _make_ssl_unix_server(self, factory, certfile, keyfile=None):
|
|
|
|
sslcontext = self._create_ssl_context(certfile, keyfile)
|
|
|
|
return self._make_unix_server(factory, ssl=sslcontext)
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
@unittest.skipIf(ssl is None, 'No ssl module')
|
|
|
|
def test_create_server_ssl(self):
|
2014-02-18 13:15:06 -04:00
|
|
|
proto = MyProto(loop=self.loop)
|
|
|
|
server, host, port = self._make_ssl_server(
|
2017-12-30 01:35:36 -04:00
|
|
|
lambda: proto, test_utils.ONLYCERT, test_utils.ONLYKEY)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
f_c = self.loop.create_connection(MyBaseProto, host, port,
|
2013-10-17 17:40:50 -03:00
|
|
|
ssl=test_utils.dummy_ssl_context())
|
|
|
|
client, pr = self.loop.run_until_complete(f_c)
|
|
|
|
|
|
|
|
client.write(b'xxx')
|
2014-03-05 20:00:36 -04:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
2014-03-05 20:00:36 -04:00
|
|
|
|
|
|
|
test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual(3, proto.nbytes)
|
|
|
|
|
|
|
|
# extra info is available
|
2015-09-21 13:06:17 -03:00
|
|
|
self.check_ssl_extra_info(client, peername=(host, port))
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
# close connection
|
|
|
|
proto.transport.close()
|
|
|
|
self.loop.run_until_complete(proto.done)
|
|
|
|
self.assertEqual('CLOSED', proto.state)
|
|
|
|
|
|
|
|
# the client socket must be closed after to avoid ECONNRESET upon
|
|
|
|
# recv()/send() on the serving socket
|
|
|
|
client.close()
|
|
|
|
|
|
|
|
# stop serving
|
|
|
|
server.close()
|
|
|
|
|
2017-11-24 12:35:55 -04:00
|
|
|
@support.skip_unless_bind_unix_socket
|
2013-12-05 19:23:13 -04:00
|
|
|
@unittest.skipIf(ssl is None, 'No ssl module')
|
2014-02-18 13:15:06 -04:00
|
|
|
def test_create_unix_server_ssl(self):
|
|
|
|
proto = MyProto(loop=self.loop)
|
|
|
|
server, path = self._make_ssl_unix_server(
|
2017-12-30 01:35:36 -04:00
|
|
|
lambda: proto, test_utils.ONLYCERT, test_utils.ONLYKEY)
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
f_c = self.loop.create_unix_connection(
|
|
|
|
MyBaseProto, path, ssl=test_utils.dummy_ssl_context(),
|
|
|
|
server_hostname='')
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
client, pr = self.loop.run_until_complete(f_c)
|
|
|
|
|
|
|
|
client.write(b'xxx')
|
2014-03-05 20:00:36 -04:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
2014-02-18 13:15:06 -04:00
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
|
2014-02-18 13:15:06 -04:00
|
|
|
self.assertEqual(3, proto.nbytes)
|
|
|
|
|
|
|
|
# close connection
|
|
|
|
proto.transport.close()
|
|
|
|
self.loop.run_until_complete(proto.done)
|
|
|
|
self.assertEqual('CLOSED', proto.state)
|
|
|
|
|
|
|
|
# the client socket must be closed after to avoid ECONNRESET upon
|
|
|
|
# recv()/send() on the serving socket
|
|
|
|
client.close()
|
|
|
|
|
|
|
|
# stop serving
|
|
|
|
server.close()
|
|
|
|
|
|
|
|
@unittest.skipIf(ssl is None, 'No ssl module')
|
|
|
|
def test_create_server_ssl_verify_failed(self):
|
|
|
|
proto = MyProto(loop=self.loop)
|
|
|
|
server, host, port = self._make_ssl_server(
|
2017-12-30 01:35:36 -04:00
|
|
|
lambda: proto, test_utils.SIGNED_CERTFILE)
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2017-09-15 15:27:30 -03:00
|
|
|
sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
|
2013-12-05 19:23:13 -04:00
|
|
|
sslcontext_client.options |= ssl.OP_NO_SSLv2
|
|
|
|
sslcontext_client.verify_mode = ssl.CERT_REQUIRED
|
|
|
|
if hasattr(sslcontext_client, 'check_hostname'):
|
|
|
|
sslcontext_client.check_hostname = True
|
|
|
|
|
2015-01-29 09:15:19 -04:00
|
|
|
|
2013-12-05 19:23:13 -04:00
|
|
|
# no CA loaded
|
|
|
|
f_c = self.loop.create_connection(MyProto, host, port,
|
|
|
|
ssl=sslcontext_client)
|
2015-01-29 09:15:19 -04:00
|
|
|
with mock.patch.object(self.loop, 'call_exception_handler'):
|
|
|
|
with test_utils.disable_logger():
|
|
|
|
with self.assertRaisesRegex(ssl.SSLError,
|
2016-05-13 16:42:39 -03:00
|
|
|
'(?i)certificate.verify.failed'):
|
2015-01-29 09:15:19 -04:00
|
|
|
self.loop.run_until_complete(f_c)
|
|
|
|
|
|
|
|
# execute the loop to log the connection error
|
|
|
|
test_utils.run_briefly(self.loop)
|
2013-12-05 19:23:13 -04:00
|
|
|
|
|
|
|
# close connection
|
|
|
|
self.assertIsNone(proto.transport)
|
|
|
|
server.close()
|
|
|
|
|
2017-11-24 12:35:55 -04:00
|
|
|
@support.skip_unless_bind_unix_socket
|
2013-12-05 19:23:13 -04:00
|
|
|
@unittest.skipIf(ssl is None, 'No ssl module')
|
2014-02-18 13:15:06 -04:00
|
|
|
def test_create_unix_server_ssl_verify_failed(self):
|
|
|
|
proto = MyProto(loop=self.loop)
|
|
|
|
server, path = self._make_ssl_unix_server(
|
2017-12-30 01:35:36 -04:00
|
|
|
lambda: proto, test_utils.SIGNED_CERTFILE)
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2017-09-15 15:27:30 -03:00
|
|
|
sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
|
2014-02-18 13:15:06 -04:00
|
|
|
sslcontext_client.options |= ssl.OP_NO_SSLv2
|
|
|
|
sslcontext_client.verify_mode = ssl.CERT_REQUIRED
|
|
|
|
if hasattr(sslcontext_client, 'check_hostname'):
|
|
|
|
sslcontext_client.check_hostname = True
|
|
|
|
|
|
|
|
# no CA loaded
|
|
|
|
f_c = self.loop.create_unix_connection(MyProto, path,
|
|
|
|
ssl=sslcontext_client,
|
|
|
|
server_hostname='invalid')
|
2015-01-29 09:15:19 -04:00
|
|
|
with mock.patch.object(self.loop, 'call_exception_handler'):
|
|
|
|
with test_utils.disable_logger():
|
|
|
|
with self.assertRaisesRegex(ssl.SSLError,
|
2016-05-13 16:42:39 -03:00
|
|
|
'(?i)certificate.verify.failed'):
|
2015-01-29 09:15:19 -04:00
|
|
|
self.loop.run_until_complete(f_c)
|
|
|
|
|
|
|
|
# execute the loop to log the connection error
|
|
|
|
test_utils.run_briefly(self.loop)
|
2014-02-18 13:15:06 -04:00
|
|
|
|
|
|
|
# close connection
|
|
|
|
self.assertIsNone(proto.transport)
|
|
|
|
server.close()
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
@unittest.skipIf(ssl is None, 'No ssl module')
|
|
|
|
def test_create_server_ssl_match_failed(self):
|
|
|
|
proto = MyProto(loop=self.loop)
|
|
|
|
server, host, port = self._make_ssl_server(
|
2017-12-30 01:35:36 -04:00
|
|
|
lambda: proto, test_utils.SIGNED_CERTFILE)
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2017-09-15 15:27:30 -03:00
|
|
|
sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
|
2013-12-05 19:23:13 -04:00
|
|
|
sslcontext_client.options |= ssl.OP_NO_SSLv2
|
|
|
|
sslcontext_client.verify_mode = ssl.CERT_REQUIRED
|
|
|
|
sslcontext_client.load_verify_locations(
|
2017-12-30 01:35:36 -04:00
|
|
|
cafile=test_utils.SIGNING_CA)
|
2013-12-05 19:23:13 -04:00
|
|
|
if hasattr(sslcontext_client, 'check_hostname'):
|
|
|
|
sslcontext_client.check_hostname = True
|
|
|
|
|
|
|
|
# incorrect server_hostname
|
|
|
|
f_c = self.loop.create_connection(MyProto, host, port,
|
|
|
|
ssl=sslcontext_client)
|
2015-01-29 09:15:19 -04:00
|
|
|
with mock.patch.object(self.loop, 'call_exception_handler'):
|
|
|
|
with test_utils.disable_logger():
|
|
|
|
with self.assertRaisesRegex(
|
|
|
|
ssl.CertificateError,
|
2018-01-27 10:51:38 -04:00
|
|
|
"IP address mismatch, certificate is not valid for "
|
|
|
|
"'127.0.0.1'"):
|
2015-01-29 09:15:19 -04:00
|
|
|
self.loop.run_until_complete(f_c)
|
2013-12-05 19:23:13 -04:00
|
|
|
|
|
|
|
# close connection
|
2018-01-27 10:51:38 -04:00
|
|
|
# transport is None because TLS ALERT aborted the handshake
|
|
|
|
self.assertIsNone(proto.transport)
|
2013-12-05 19:23:13 -04:00
|
|
|
server.close()
|
|
|
|
|
2017-11-24 12:35:55 -04:00
|
|
|
@support.skip_unless_bind_unix_socket
|
2013-12-05 19:23:13 -04:00
|
|
|
@unittest.skipIf(ssl is None, 'No ssl module')
|
2014-02-18 13:15:06 -04:00
|
|
|
def test_create_unix_server_ssl_verified(self):
|
|
|
|
proto = MyProto(loop=self.loop)
|
|
|
|
server, path = self._make_ssl_unix_server(
|
2017-12-30 01:35:36 -04:00
|
|
|
lambda: proto, test_utils.SIGNED_CERTFILE)
|
2014-02-18 13:15:06 -04:00
|
|
|
|
2017-09-15 15:27:30 -03:00
|
|
|
sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
|
2014-02-18 13:15:06 -04:00
|
|
|
sslcontext_client.options |= ssl.OP_NO_SSLv2
|
|
|
|
sslcontext_client.verify_mode = ssl.CERT_REQUIRED
|
2017-12-30 01:35:36 -04:00
|
|
|
sslcontext_client.load_verify_locations(cafile=test_utils.SIGNING_CA)
|
2014-02-18 13:15:06 -04:00
|
|
|
if hasattr(sslcontext_client, 'check_hostname'):
|
|
|
|
sslcontext_client.check_hostname = True
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
# Connection succeeds with correct CA and server hostname.
|
|
|
|
f_c = self.loop.create_unix_connection(MyProto, path,
|
|
|
|
ssl=sslcontext_client,
|
|
|
|
server_hostname='localhost')
|
|
|
|
client, pr = self.loop.run_until_complete(f_c)
|
|
|
|
|
|
|
|
# close connection
|
|
|
|
proto.transport.close()
|
|
|
|
client.close()
|
|
|
|
server.close()
|
2015-01-13 19:19:09 -04:00
|
|
|
self.loop.run_until_complete(proto.done)
|
|
|
|
|
2014-02-18 13:15:06 -04:00
|
|
|
@unittest.skipIf(ssl is None, 'No ssl module')
|
|
|
|
def test_create_server_ssl_verified(self):
|
|
|
|
proto = MyProto(loop=self.loop)
|
|
|
|
server, host, port = self._make_ssl_server(
|
2017-12-30 01:35:36 -04:00
|
|
|
lambda: proto, test_utils.SIGNED_CERTFILE)
|
2013-12-05 19:23:13 -04:00
|
|
|
|
2017-09-15 15:27:30 -03:00
|
|
|
sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
|
2013-12-05 19:23:13 -04:00
|
|
|
sslcontext_client.options |= ssl.OP_NO_SSLv2
|
|
|
|
sslcontext_client.verify_mode = ssl.CERT_REQUIRED
|
2017-12-30 01:35:36 -04:00
|
|
|
sslcontext_client.load_verify_locations(cafile=test_utils.SIGNING_CA)
|
2013-12-05 19:23:13 -04:00
|
|
|
if hasattr(sslcontext_client, 'check_hostname'):
|
|
|
|
sslcontext_client.check_hostname = True
|
|
|
|
|
|
|
|
# Connection succeeds with correct CA and server hostname.
|
|
|
|
f_c = self.loop.create_connection(MyProto, host, port,
|
|
|
|
ssl=sslcontext_client,
|
|
|
|
server_hostname='localhost')
|
|
|
|
client, pr = self.loop.run_until_complete(f_c)
|
|
|
|
|
2015-09-21 13:06:17 -03:00
|
|
|
# extra info is available
|
|
|
|
self.check_ssl_extra_info(client,peername=(host, port),
|
2017-12-30 01:35:36 -04:00
|
|
|
peercert=test_utils.PEERCERT)
|
2015-09-21 13:06:17 -03:00
|
|
|
|
2013-12-05 19:23:13 -04:00
|
|
|
# close connection
|
|
|
|
proto.transport.close()
|
|
|
|
client.close()
|
|
|
|
server.close()
|
2015-01-13 19:19:09 -04:00
|
|
|
self.loop.run_until_complete(proto.done)
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_create_server_sock(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
proto = asyncio.Future(loop=self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
class TestMyProto(MyProto):
|
|
|
|
def connection_made(self, transport):
|
|
|
|
super().connection_made(transport)
|
|
|
|
proto.set_result(self)
|
|
|
|
|
|
|
|
sock_ob = socket.socket(type=socket.SOCK_STREAM)
|
|
|
|
sock_ob.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
|
|
|
sock_ob.bind(('0.0.0.0', 0))
|
|
|
|
|
|
|
|
f = self.loop.create_server(TestMyProto, sock=sock_ob)
|
|
|
|
server = self.loop.run_until_complete(f)
|
|
|
|
sock = server.sockets[0]
|
|
|
|
self.assertIs(sock, sock_ob)
|
|
|
|
|
|
|
|
host, port = sock.getsockname()
|
|
|
|
self.assertEqual(host, '0.0.0.0')
|
|
|
|
client = socket.socket()
|
|
|
|
client.connect(('127.0.0.1', port))
|
|
|
|
client.send(b'xxx')
|
|
|
|
client.close()
|
|
|
|
server.close()
|
|
|
|
|
|
|
|
def test_create_server_addr_in_use(self):
|
|
|
|
sock_ob = socket.socket(type=socket.SOCK_STREAM)
|
|
|
|
sock_ob.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
|
|
|
sock_ob.bind(('0.0.0.0', 0))
|
|
|
|
|
|
|
|
f = self.loop.create_server(MyProto, sock=sock_ob)
|
|
|
|
server = self.loop.run_until_complete(f)
|
|
|
|
sock = server.sockets[0]
|
|
|
|
host, port = sock.getsockname()
|
|
|
|
|
|
|
|
f = self.loop.create_server(MyProto, host=host, port=port)
|
|
|
|
with self.assertRaises(OSError) as cm:
|
|
|
|
self.loop.run_until_complete(f)
|
|
|
|
self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
|
|
|
|
|
|
|
|
server.close()
|
|
|
|
|
2013-12-05 19:23:13 -04:00
|
|
|
@unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 not supported or enabled')
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_create_server_dual_stack(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
f_proto = asyncio.Future(loop=self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
class TestMyProto(MyProto):
|
|
|
|
def connection_made(self, transport):
|
|
|
|
super().connection_made(transport)
|
|
|
|
f_proto.set_result(self)
|
|
|
|
|
|
|
|
try_count = 0
|
|
|
|
while True:
|
|
|
|
try:
|
2013-12-05 19:23:13 -04:00
|
|
|
port = support.find_unused_port()
|
2013-10-17 17:40:50 -03:00
|
|
|
f = self.loop.create_server(TestMyProto, host=None, port=port)
|
|
|
|
server = self.loop.run_until_complete(f)
|
|
|
|
except OSError as ex:
|
|
|
|
if ex.errno == errno.EADDRINUSE:
|
|
|
|
try_count += 1
|
|
|
|
self.assertGreaterEqual(5, try_count)
|
|
|
|
continue
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
else:
|
|
|
|
break
|
|
|
|
client = socket.socket()
|
|
|
|
client.connect(('127.0.0.1', port))
|
|
|
|
client.send(b'xxx')
|
|
|
|
proto = self.loop.run_until_complete(f_proto)
|
|
|
|
proto.transport.close()
|
|
|
|
client.close()
|
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
f_proto = asyncio.Future(loop=self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
client = socket.socket(socket.AF_INET6)
|
|
|
|
client.connect(('::1', port))
|
|
|
|
client.send(b'xxx')
|
|
|
|
proto = self.loop.run_until_complete(f_proto)
|
|
|
|
proto.transport.close()
|
|
|
|
client.close()
|
|
|
|
|
|
|
|
server.close()
|
|
|
|
|
|
|
|
def test_server_close(self):
|
|
|
|
f = self.loop.create_server(MyProto, '0.0.0.0', 0)
|
|
|
|
server = self.loop.run_until_complete(f)
|
|
|
|
sock = server.sockets[0]
|
|
|
|
host, port = sock.getsockname()
|
|
|
|
|
|
|
|
client = socket.socket()
|
|
|
|
client.connect(('127.0.0.1', port))
|
|
|
|
client.send(b'xxx')
|
|
|
|
client.close()
|
|
|
|
|
|
|
|
server.close()
|
|
|
|
|
|
|
|
client = socket.socket()
|
|
|
|
self.assertRaises(
|
|
|
|
ConnectionRefusedError, client.connect, ('127.0.0.1', port))
|
|
|
|
client.close()
|
|
|
|
|
|
|
|
def test_create_datagram_endpoint(self):
|
|
|
|
class TestMyDatagramProto(MyDatagramProto):
|
|
|
|
def __init__(inner_self):
|
|
|
|
super().__init__(loop=self.loop)
|
|
|
|
|
|
|
|
def datagram_received(self, data, addr):
|
|
|
|
super().datagram_received(data, addr)
|
|
|
|
self.transport.sendto(b'resp:'+data, addr)
|
|
|
|
|
|
|
|
coro = self.loop.create_datagram_endpoint(
|
|
|
|
TestMyDatagramProto, local_addr=('127.0.0.1', 0))
|
|
|
|
s_transport, server = self.loop.run_until_complete(coro)
|
|
|
|
host, port = s_transport.get_extra_info('sockname')
|
|
|
|
|
2014-07-08 18:57:31 -03:00
|
|
|
self.assertIsInstance(s_transport, asyncio.Transport)
|
|
|
|
self.assertIsInstance(server, TestMyDatagramProto)
|
|
|
|
self.assertEqual('INITIALIZED', server.state)
|
|
|
|
self.assertIs(server.transport, s_transport)
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
coro = self.loop.create_datagram_endpoint(
|
|
|
|
lambda: MyDatagramProto(loop=self.loop),
|
|
|
|
remote_addr=(host, port))
|
|
|
|
transport, client = self.loop.run_until_complete(coro)
|
|
|
|
|
2014-07-08 18:57:31 -03:00
|
|
|
self.assertIsInstance(transport, asyncio.Transport)
|
|
|
|
self.assertIsInstance(client, MyDatagramProto)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual('INITIALIZED', client.state)
|
2014-07-08 18:57:31 -03:00
|
|
|
self.assertIs(client.transport, transport)
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
transport.sendto(b'xxx')
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: server.nbytes)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual(3, server.nbytes)
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: client.nbytes)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
# received
|
|
|
|
self.assertEqual(8, client.nbytes)
|
|
|
|
|
|
|
|
# extra info is available
|
|
|
|
self.assertIsNotNone(transport.get_extra_info('sockname'))
|
|
|
|
|
|
|
|
# close connection
|
|
|
|
transport.close()
|
|
|
|
self.loop.run_until_complete(client.done)
|
|
|
|
self.assertEqual('CLOSED', client.state)
|
|
|
|
server.transport.close()
|
|
|
|
|
2015-10-05 13:15:28 -03:00
|
|
|
def test_create_datagram_endpoint_sock(self):
|
2016-11-09 16:47:00 -04:00
|
|
|
if (sys.platform == 'win32' and
|
|
|
|
isinstance(self.loop, proactor_events.BaseProactorEventLoop)):
|
|
|
|
raise unittest.SkipTest(
|
|
|
|
'UDP is not supported with proactor event loops')
|
|
|
|
|
2015-10-05 13:15:28 -03:00
|
|
|
sock = None
|
|
|
|
local_address = ('127.0.0.1', 0)
|
|
|
|
infos = self.loop.run_until_complete(
|
|
|
|
self.loop.getaddrinfo(
|
|
|
|
*local_address, type=socket.SOCK_DGRAM))
|
|
|
|
for family, type, proto, cname, address in infos:
|
|
|
|
try:
|
|
|
|
sock = socket.socket(family=family, type=type, proto=proto)
|
|
|
|
sock.setblocking(False)
|
|
|
|
sock.bind(address)
|
|
|
|
except:
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
break
|
|
|
|
else:
|
|
|
|
assert False, 'Can not create socket.'
|
|
|
|
|
2016-11-09 16:47:00 -04:00
|
|
|
f = self.loop.create_datagram_endpoint(
|
2015-10-05 13:15:28 -03:00
|
|
|
lambda: MyDatagramProto(loop=self.loop), sock=sock)
|
|
|
|
tr, pr = self.loop.run_until_complete(f)
|
|
|
|
self.assertIsInstance(tr, asyncio.Transport)
|
|
|
|
self.assertIsInstance(pr, MyDatagramProto)
|
|
|
|
tr.close()
|
|
|
|
self.loop.run_until_complete(pr.done)
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_internal_fds(self):
|
|
|
|
loop = self.create_event_loop()
|
2014-01-25 17:22:18 -04:00
|
|
|
if not isinstance(loop, selector_events.BaseSelectorEventLoop):
|
2014-06-03 19:23:26 -03:00
|
|
|
loop.close()
|
2013-12-08 02:44:27 -04:00
|
|
|
self.skipTest('loop is not a BaseSelectorEventLoop')
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
self.assertEqual(1, loop._internal_fds)
|
|
|
|
loop.close()
|
|
|
|
self.assertEqual(0, loop._internal_fds)
|
|
|
|
self.assertIsNone(loop._csock)
|
|
|
|
self.assertIsNone(loop._ssock)
|
|
|
|
|
|
|
|
@unittest.skipUnless(sys.platform != 'win32',
|
|
|
|
"Don't support pipes for Windows")
|
|
|
|
def test_read_pipe(self):
|
2014-02-18 13:15:06 -04:00
|
|
|
proto = MyReadPipeProto(loop=self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
rpipe, wpipe = os.pipe()
|
|
|
|
pipeobj = io.open(rpipe, 'rb', 1024)
|
|
|
|
|
2017-12-08 18:23:48 -04:00
|
|
|
async def connect():
|
|
|
|
t, p = await self.loop.connect_read_pipe(
|
2014-02-18 13:15:06 -04:00
|
|
|
lambda: proto, pipeobj)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIs(p, proto)
|
|
|
|
self.assertIs(t, proto.transport)
|
|
|
|
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
|
|
|
|
self.assertEqual(0, proto.nbytes)
|
|
|
|
|
|
|
|
self.loop.run_until_complete(connect())
|
|
|
|
|
|
|
|
os.write(wpipe, b'1')
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: proto.nbytes >= 1)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual(1, proto.nbytes)
|
|
|
|
|
|
|
|
os.write(wpipe, b'2345')
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
|
|
|
|
self.assertEqual(5, proto.nbytes)
|
|
|
|
|
|
|
|
os.close(wpipe)
|
|
|
|
self.loop.run_until_complete(proto.done)
|
|
|
|
self.assertEqual(
|
|
|
|
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
|
|
|
|
# extra info is available
|
|
|
|
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
|
|
|
|
|
2016-05-13 17:04:43 -03:00
|
|
|
@unittest.skipUnless(sys.platform != 'win32',
|
|
|
|
"Don't support pipes for Windows")
|
|
|
|
def test_unclosed_pipe_transport(self):
|
|
|
|
# This test reproduces the issue #314 on GitHub
|
|
|
|
loop = self.create_event_loop()
|
|
|
|
read_proto = MyReadPipeProto(loop=loop)
|
|
|
|
write_proto = MyWritePipeProto(loop=loop)
|
|
|
|
|
|
|
|
rpipe, wpipe = os.pipe()
|
|
|
|
rpipeobj = io.open(rpipe, 'rb', 1024)
|
|
|
|
wpipeobj = io.open(wpipe, 'w', 1024)
|
|
|
|
|
2017-12-08 18:23:48 -04:00
|
|
|
async def connect():
|
|
|
|
read_transport, _ = await loop.connect_read_pipe(
|
2016-05-13 17:04:43 -03:00
|
|
|
lambda: read_proto, rpipeobj)
|
2017-12-08 18:23:48 -04:00
|
|
|
write_transport, _ = await loop.connect_write_pipe(
|
2016-05-13 17:04:43 -03:00
|
|
|
lambda: write_proto, wpipeobj)
|
|
|
|
return read_transport, write_transport
|
|
|
|
|
|
|
|
# Run and close the loop without closing the transports
|
|
|
|
read_transport, write_transport = loop.run_until_complete(connect())
|
|
|
|
loop.close()
|
|
|
|
|
|
|
|
# These 'repr' calls used to raise an AttributeError
|
|
|
|
# See Issue #314 on GitHub
|
|
|
|
self.assertIn('open', repr(read_transport))
|
|
|
|
self.assertIn('open', repr(write_transport))
|
|
|
|
|
|
|
|
# Clean up (avoid ResourceWarning)
|
|
|
|
rpipeobj.close()
|
|
|
|
wpipeobj.close()
|
|
|
|
read_transport._pipe = None
|
|
|
|
write_transport._pipe = None
|
|
|
|
|
2014-01-10 17:30:04 -04:00
|
|
|
@unittest.skipUnless(sys.platform != 'win32',
|
|
|
|
"Don't support pipes for Windows")
|
|
|
|
def test_read_pty_output(self):
|
2014-02-18 13:15:06 -04:00
|
|
|
proto = MyReadPipeProto(loop=self.loop)
|
2014-01-10 17:30:04 -04:00
|
|
|
|
|
|
|
master, slave = os.openpty()
|
|
|
|
master_read_obj = io.open(master, 'rb', 0)
|
|
|
|
|
2017-12-08 18:23:48 -04:00
|
|
|
async def connect():
|
|
|
|
t, p = await self.loop.connect_read_pipe(lambda: proto,
|
|
|
|
master_read_obj)
|
2014-01-10 17:30:04 -04:00
|
|
|
self.assertIs(p, proto)
|
|
|
|
self.assertIs(t, proto.transport)
|
|
|
|
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
|
|
|
|
self.assertEqual(0, proto.nbytes)
|
|
|
|
|
|
|
|
self.loop.run_until_complete(connect())
|
|
|
|
|
|
|
|
os.write(slave, b'1')
|
|
|
|
test_utils.run_until(self.loop, lambda: proto.nbytes)
|
|
|
|
self.assertEqual(1, proto.nbytes)
|
|
|
|
|
|
|
|
os.write(slave, b'2345')
|
|
|
|
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
|
|
|
|
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
|
|
|
|
self.assertEqual(5, proto.nbytes)
|
|
|
|
|
|
|
|
os.close(slave)
|
2018-03-09 14:14:14 -04:00
|
|
|
proto.transport.close()
|
2014-01-10 17:30:04 -04:00
|
|
|
self.loop.run_until_complete(proto.done)
|
|
|
|
self.assertEqual(
|
|
|
|
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
|
|
|
|
# extra info is available
|
|
|
|
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
@unittest.skipUnless(sys.platform != 'win32',
|
|
|
|
"Don't support pipes for Windows")
|
|
|
|
def test_write_pipe(self):
|
|
|
|
rpipe, wpipe = os.pipe()
|
|
|
|
pipeobj = io.open(wpipe, 'wb', 1024)
|
|
|
|
|
2014-02-26 06:31:55 -04:00
|
|
|
proto = MyWritePipeProto(loop=self.loop)
|
|
|
|
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
|
|
|
|
transport, p = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIs(p, proto)
|
|
|
|
self.assertIs(transport, proto.transport)
|
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
transport.write(b'1')
|
2014-03-05 20:00:36 -04:00
|
|
|
|
|
|
|
data = bytearray()
|
|
|
|
def reader(data):
|
|
|
|
chunk = os.read(rpipe, 1024)
|
|
|
|
data += chunk
|
|
|
|
return len(data)
|
|
|
|
|
|
|
|
test_utils.run_until(self.loop, lambda: reader(data) >= 1)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual(b'1', data)
|
|
|
|
|
|
|
|
transport.write(b'2345')
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: reader(data) >= 5)
|
|
|
|
self.assertEqual(b'12345', data)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
|
|
|
|
|
|
|
os.close(rpipe)
|
|
|
|
|
|
|
|
# extra info is available
|
|
|
|
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
|
|
|
|
|
|
|
|
# close connection
|
|
|
|
proto.transport.close()
|
|
|
|
self.loop.run_until_complete(proto.done)
|
|
|
|
self.assertEqual('CLOSED', proto.state)
|
|
|
|
|
|
|
|
@unittest.skipUnless(sys.platform != 'win32',
|
|
|
|
"Don't support pipes for Windows")
|
|
|
|
def test_write_pipe_disconnect_on_close(self):
|
2017-11-28 16:33:20 -04:00
|
|
|
rsock, wsock = socket.socketpair()
|
2014-08-25 18:20:52 -03:00
|
|
|
rsock.setblocking(False)
|
2013-10-22 01:28:45 -03:00
|
|
|
pipeobj = io.open(wsock.detach(), 'wb', 1024)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-02-26 06:31:55 -04:00
|
|
|
proto = MyWritePipeProto(loop=self.loop)
|
|
|
|
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
|
|
|
|
transport, p = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIs(p, proto)
|
|
|
|
self.assertIs(transport, proto.transport)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
|
|
|
|
|
|
|
transport.write(b'1')
|
2013-10-22 01:28:45 -03:00
|
|
|
data = self.loop.run_until_complete(self.loop.sock_recv(rsock, 1024))
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual(b'1', data)
|
|
|
|
|
2013-10-22 01:28:45 -03:00
|
|
|
rsock.close()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
self.loop.run_until_complete(proto.done)
|
|
|
|
self.assertEqual('CLOSED', proto.state)
|
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
@unittest.skipUnless(sys.platform != 'win32',
|
|
|
|
"Don't support pipes for Windows")
|
2014-02-02 19:32:13 -04:00
|
|
|
# select, poll and kqueue don't support character devices (PTY) on Mac OS X
|
|
|
|
# older than 10.6 (Snow Leopard)
|
|
|
|
@support.requires_mac_ver(10, 6)
|
2014-01-25 10:32:06 -04:00
|
|
|
def test_write_pty(self):
|
|
|
|
master, slave = os.openpty()
|
|
|
|
slave_write_obj = io.open(slave, 'wb', 0)
|
|
|
|
|
2014-02-26 06:31:55 -04:00
|
|
|
proto = MyWritePipeProto(loop=self.loop)
|
|
|
|
connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
|
|
|
|
transport, p = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIs(p, proto)
|
|
|
|
self.assertIs(transport, proto.transport)
|
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
2014-01-25 10:32:06 -04:00
|
|
|
|
|
|
|
transport.write(b'1')
|
2014-03-05 20:00:36 -04:00
|
|
|
|
|
|
|
data = bytearray()
|
|
|
|
def reader(data):
|
|
|
|
chunk = os.read(master, 1024)
|
|
|
|
data += chunk
|
|
|
|
return len(data)
|
|
|
|
|
|
|
|
test_utils.run_until(self.loop, lambda: reader(data) >= 1,
|
|
|
|
timeout=10)
|
2014-01-25 10:32:06 -04:00
|
|
|
self.assertEqual(b'1', data)
|
|
|
|
|
|
|
|
transport.write(b'2345')
|
2014-03-05 20:00:36 -04:00
|
|
|
test_utils.run_until(self.loop, lambda: reader(data) >= 5,
|
|
|
|
timeout=10)
|
|
|
|
self.assertEqual(b'12345', data)
|
2014-01-25 10:32:06 -04:00
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
|
|
|
|
|
|
|
os.close(master)
|
|
|
|
|
|
|
|
# extra info is available
|
|
|
|
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
|
|
|
|
|
|
|
|
# close connection
|
|
|
|
proto.transport.close()
|
|
|
|
self.loop.run_until_complete(proto.done)
|
|
|
|
self.assertEqual('CLOSED', proto.state)
|
|
|
|
|
2016-08-31 13:40:18 -03:00
|
|
|
@unittest.skipUnless(sys.platform != 'win32',
|
|
|
|
"Don't support pipes for Windows")
|
|
|
|
# select, poll and kqueue don't support character devices (PTY) on Mac OS X
|
|
|
|
# older than 10.6 (Snow Leopard)
|
|
|
|
@support.requires_mac_ver(10, 6)
|
|
|
|
def test_bidirectional_pty(self):
|
|
|
|
master, read_slave = os.openpty()
|
|
|
|
write_slave = os.dup(read_slave)
|
|
|
|
tty.setraw(read_slave)
|
|
|
|
|
|
|
|
slave_read_obj = io.open(read_slave, 'rb', 0)
|
|
|
|
read_proto = MyReadPipeProto(loop=self.loop)
|
|
|
|
read_connect = self.loop.connect_read_pipe(lambda: read_proto,
|
|
|
|
slave_read_obj)
|
|
|
|
read_transport, p = self.loop.run_until_complete(read_connect)
|
|
|
|
self.assertIs(p, read_proto)
|
|
|
|
self.assertIs(read_transport, read_proto.transport)
|
|
|
|
self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
|
|
|
|
self.assertEqual(0, read_proto.nbytes)
|
|
|
|
|
|
|
|
|
|
|
|
slave_write_obj = io.open(write_slave, 'wb', 0)
|
|
|
|
write_proto = MyWritePipeProto(loop=self.loop)
|
|
|
|
write_connect = self.loop.connect_write_pipe(lambda: write_proto,
|
|
|
|
slave_write_obj)
|
|
|
|
write_transport, p = self.loop.run_until_complete(write_connect)
|
|
|
|
self.assertIs(p, write_proto)
|
|
|
|
self.assertIs(write_transport, write_proto.transport)
|
|
|
|
self.assertEqual('CONNECTED', write_proto.state)
|
|
|
|
|
|
|
|
data = bytearray()
|
|
|
|
def reader(data):
|
|
|
|
chunk = os.read(master, 1024)
|
|
|
|
data += chunk
|
|
|
|
return len(data)
|
|
|
|
|
|
|
|
write_transport.write(b'1')
|
|
|
|
test_utils.run_until(self.loop, lambda: reader(data) >= 1, timeout=10)
|
|
|
|
self.assertEqual(b'1', data)
|
|
|
|
self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
|
|
|
|
self.assertEqual('CONNECTED', write_proto.state)
|
|
|
|
|
|
|
|
os.write(master, b'a')
|
|
|
|
test_utils.run_until(self.loop, lambda: read_proto.nbytes >= 1,
|
|
|
|
timeout=10)
|
|
|
|
self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
|
|
|
|
self.assertEqual(1, read_proto.nbytes)
|
|
|
|
self.assertEqual('CONNECTED', write_proto.state)
|
|
|
|
|
|
|
|
write_transport.write(b'2345')
|
|
|
|
test_utils.run_until(self.loop, lambda: reader(data) >= 5, timeout=10)
|
|
|
|
self.assertEqual(b'12345', data)
|
|
|
|
self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
|
|
|
|
self.assertEqual('CONNECTED', write_proto.state)
|
|
|
|
|
|
|
|
os.write(master, b'bcde')
|
|
|
|
test_utils.run_until(self.loop, lambda: read_proto.nbytes >= 5,
|
|
|
|
timeout=10)
|
|
|
|
self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
|
|
|
|
self.assertEqual(5, read_proto.nbytes)
|
|
|
|
self.assertEqual('CONNECTED', write_proto.state)
|
|
|
|
|
|
|
|
os.close(master)
|
|
|
|
|
|
|
|
read_transport.close()
|
|
|
|
self.loop.run_until_complete(read_proto.done)
|
|
|
|
self.assertEqual(
|
|
|
|
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], read_proto.state)
|
|
|
|
|
|
|
|
write_transport.close()
|
|
|
|
self.loop.run_until_complete(write_proto.done)
|
|
|
|
self.assertEqual('CLOSED', write_proto.state)
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_prompt_cancellation(self):
|
2017-11-28 16:33:20 -04:00
|
|
|
r, w = socket.socketpair()
|
2013-10-17 17:40:50 -03:00
|
|
|
r.setblocking(False)
|
2017-12-14 21:53:26 -04:00
|
|
|
f = self.loop.create_task(self.loop.sock_recv(r, 1))
|
2013-10-17 17:40:50 -03:00
|
|
|
ov = getattr(f, 'ov', None)
|
2013-11-14 17:10:51 -04:00
|
|
|
if ov is not None:
|
|
|
|
self.assertTrue(ov.pending)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2017-12-08 18:23:48 -04:00
|
|
|
async def main():
|
2013-10-17 17:40:50 -03:00
|
|
|
try:
|
|
|
|
self.loop.call_soon(f.cancel)
|
2017-12-08 18:23:48 -04:00
|
|
|
await f
|
2014-01-25 10:32:06 -04:00
|
|
|
except asyncio.CancelledError:
|
2013-10-17 17:40:50 -03:00
|
|
|
res = 'cancelled'
|
|
|
|
else:
|
|
|
|
res = None
|
|
|
|
finally:
|
|
|
|
self.loop.stop()
|
|
|
|
return res
|
|
|
|
|
|
|
|
start = time.monotonic()
|
2014-01-25 10:32:06 -04:00
|
|
|
t = asyncio.Task(main(), loop=self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_forever()
|
|
|
|
elapsed = time.monotonic() - start
|
|
|
|
|
|
|
|
self.assertLess(elapsed, 0.1)
|
|
|
|
self.assertEqual(t.result(), 'cancelled')
|
2014-01-25 10:32:06 -04:00
|
|
|
self.assertRaises(asyncio.CancelledError, f.result)
|
2013-11-14 17:10:51 -04:00
|
|
|
if ov is not None:
|
|
|
|
self.assertFalse(ov.pending)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop._stop_serving(r)
|
|
|
|
|
|
|
|
r.close()
|
|
|
|
w.close()
|
|
|
|
|
2014-01-25 10:01:33 -04:00
|
|
|
def test_timeout_rounding(self):
|
|
|
|
def _run_once():
|
|
|
|
self.loop._run_once_counter += 1
|
|
|
|
orig_run_once()
|
|
|
|
|
|
|
|
orig_run_once = self.loop._run_once
|
|
|
|
self.loop._run_once_counter = 0
|
|
|
|
self.loop._run_once = _run_once
|
|
|
|
|
2017-12-08 18:23:48 -04:00
|
|
|
async def wait():
|
2014-01-25 10:01:33 -04:00
|
|
|
loop = self.loop
|
2017-12-08 18:23:48 -04:00
|
|
|
await asyncio.sleep(1e-2, loop=loop)
|
|
|
|
await asyncio.sleep(1e-4, loop=loop)
|
|
|
|
await asyncio.sleep(1e-6, loop=loop)
|
|
|
|
await asyncio.sleep(1e-8, loop=loop)
|
|
|
|
await asyncio.sleep(1e-10, loop=loop)
|
2014-01-25 10:01:33 -04:00
|
|
|
|
|
|
|
self.loop.run_until_complete(wait())
|
2014-02-10 18:42:32 -04:00
|
|
|
# The ideal number of call is 12, but on some platforms, the selector
|
2014-02-07 18:34:58 -04:00
|
|
|
# may sleep at little bit less than timeout depending on the resolution
|
2014-02-10 18:42:32 -04:00
|
|
|
# of the clock used by the kernel. Tolerate a few useless calls on
|
|
|
|
# these platforms.
|
|
|
|
self.assertLessEqual(self.loop._run_once_counter, 20,
|
|
|
|
{'clock_resolution': self.loop._clock_resolution,
|
2014-02-10 06:47:50 -04:00
|
|
|
'selector': self.loop._selector.__class__.__name__})
|
2014-02-03 18:59:52 -04:00
|
|
|
|
2014-03-05 19:52:53 -04:00
|
|
|
def test_remove_fds_after_closing(self):
|
|
|
|
loop = self.create_event_loop()
|
|
|
|
callback = lambda: None
|
2017-11-28 16:33:20 -04:00
|
|
|
r, w = socket.socketpair()
|
2014-03-05 19:52:53 -04:00
|
|
|
self.addCleanup(r.close)
|
|
|
|
self.addCleanup(w.close)
|
|
|
|
loop.add_reader(r, callback)
|
|
|
|
loop.add_writer(w, callback)
|
|
|
|
loop.close()
|
|
|
|
self.assertFalse(loop.remove_reader(r))
|
|
|
|
self.assertFalse(loop.remove_writer(w))
|
|
|
|
|
|
|
|
def test_add_fds_after_closing(self):
|
|
|
|
loop = self.create_event_loop()
|
|
|
|
callback = lambda: None
|
2017-11-28 16:33:20 -04:00
|
|
|
r, w = socket.socketpair()
|
2014-03-05 19:52:53 -04:00
|
|
|
self.addCleanup(r.close)
|
|
|
|
self.addCleanup(w.close)
|
|
|
|
loop.close()
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
loop.add_reader(r, callback)
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
loop.add_writer(w, callback)
|
|
|
|
|
2014-06-22 20:02:37 -03:00
|
|
|
def test_close_running_event_loop(self):
|
|
|
|
@asyncio.coroutine
|
|
|
|
def close_loop(loop):
|
|
|
|
self.loop.close()
|
|
|
|
|
|
|
|
coro = close_loop(self.loop)
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
self.loop.run_until_complete(coro)
|
|
|
|
|
2014-12-04 18:07:47 -04:00
|
|
|
def test_close(self):
|
|
|
|
self.loop.close()
|
|
|
|
|
|
|
|
@asyncio.coroutine
|
|
|
|
def test():
|
|
|
|
pass
|
|
|
|
|
|
|
|
func = lambda: False
|
|
|
|
coro = test()
|
|
|
|
self.addCleanup(coro.close)
|
|
|
|
|
|
|
|
# operation blocked when the loop is closed
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
self.loop.run_forever()
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
fut = asyncio.Future(loop=self.loop)
|
|
|
|
self.loop.run_until_complete(fut)
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
self.loop.call_soon(func)
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
self.loop.call_soon_threadsafe(func)
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
self.loop.call_later(1.0, func)
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
self.loop.call_at(self.loop.time() + .0, func)
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
self.loop.create_task(coro)
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
self.loop.add_signal_handler(signal.SIGTERM, func)
|
|
|
|
|
2017-12-23 17:03:27 -04:00
|
|
|
# run_in_executor test is tricky: the method is a coroutine,
|
|
|
|
# but run_until_complete cannot be called on closed loop.
|
|
|
|
# Thus iterate once explicitly.
|
|
|
|
with self.assertRaises(RuntimeError):
|
|
|
|
it = self.loop.run_in_executor(None, func).__await__()
|
|
|
|
next(it)
|
|
|
|
|
2013-10-30 18:52:03 -03:00
|
|
|
|
|
|
|
class SubprocessTestsMixin:
|
|
|
|
|
|
|
|
def check_terminated(self, returncode):
|
|
|
|
if sys.platform == 'win32':
|
|
|
|
self.assertIsInstance(returncode, int)
|
2013-11-02 13:38:58 -03:00
|
|
|
# expect 1 but sometimes get 0
|
2013-10-30 18:52:03 -03:00
|
|
|
else:
|
|
|
|
self.assertEqual(-signal.SIGTERM, returncode)
|
|
|
|
|
|
|
|
def check_killed(self, returncode):
|
|
|
|
if sys.platform == 'win32':
|
|
|
|
self.assertIsInstance(returncode, int)
|
2013-11-02 13:38:58 -03:00
|
|
|
# expect 1 but sometimes get 0
|
2013-10-30 18:52:03 -03:00
|
|
|
else:
|
|
|
|
self.assertEqual(-signal.SIGKILL, returncode)
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_subprocess_exec(self):
|
|
|
|
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
|
|
|
|
|
2014-02-26 06:31:55 -04:00
|
|
|
connect = self.loop.subprocess_exec(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
sys.executable, prog)
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
|
|
|
|
|
|
|
stdin = transp.get_pipe_transport(0)
|
|
|
|
stdin.write(b'Python The Winner')
|
|
|
|
self.loop.run_until_complete(proto.got_data[1].wait())
|
2015-01-29 19:05:19 -04:00
|
|
|
with test_utils.disable_logger():
|
|
|
|
transp.close()
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.completed)
|
2015-01-29 19:05:19 -04:00
|
|
|
self.check_killed(proto.returncode)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual(b'Python The Winner', proto.data[1])
|
|
|
|
|
|
|
|
def test_subprocess_interactive(self):
|
|
|
|
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
|
|
|
|
|
2014-02-26 06:31:55 -04:00
|
|
|
connect = self.loop.subprocess_exec(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
sys.executable, prog)
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
|
|
|
self.assertEqual('CONNECTED', proto.state)
|
|
|
|
|
2015-01-29 19:05:19 -04:00
|
|
|
stdin = transp.get_pipe_transport(0)
|
|
|
|
stdin.write(b'Python ')
|
|
|
|
self.loop.run_until_complete(proto.got_data[1].wait())
|
|
|
|
proto.got_data[1].clear()
|
|
|
|
self.assertEqual(b'Python ', proto.data[1])
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2015-01-29 19:05:19 -04:00
|
|
|
stdin.write(b'The Winner')
|
|
|
|
self.loop.run_until_complete(proto.got_data[1].wait())
|
|
|
|
self.assertEqual(b'Python The Winner', proto.data[1])
|
|
|
|
|
|
|
|
with test_utils.disable_logger():
|
|
|
|
transp.close()
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.completed)
|
2015-01-29 19:05:19 -04:00
|
|
|
self.check_killed(proto.returncode)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_subprocess_shell(self):
|
2014-02-26 06:31:55 -04:00
|
|
|
connect = self.loop.subprocess_shell(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
'echo Python')
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
|
|
|
|
|
|
|
transp.get_pipe_transport(0).close()
|
|
|
|
self.loop.run_until_complete(proto.completed)
|
|
|
|
self.assertEqual(0, proto.returncode)
|
|
|
|
self.assertTrue(all(f.done() for f in proto.disconnects.values()))
|
2013-10-30 18:52:03 -03:00
|
|
|
self.assertEqual(proto.data[1].rstrip(b'\r\n'), b'Python')
|
|
|
|
self.assertEqual(proto.data[2], b'')
|
2015-01-14 19:04:21 -04:00
|
|
|
transp.close()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_subprocess_exitcode(self):
|
2014-02-26 06:31:55 -04:00
|
|
|
connect = self.loop.subprocess_shell(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
'exit 7', stdin=None, stdout=None, stderr=None)
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.completed)
|
|
|
|
self.assertEqual(7, proto.returncode)
|
2015-01-14 19:04:21 -04:00
|
|
|
transp.close()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_subprocess_close_after_finish(self):
|
2014-02-26 06:31:55 -04:00
|
|
|
connect = self.loop.subprocess_shell(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
'exit 7', stdin=None, stdout=None, stderr=None)
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIsNone(transp.get_pipe_transport(0))
|
|
|
|
self.assertIsNone(transp.get_pipe_transport(1))
|
|
|
|
self.assertIsNone(transp.get_pipe_transport(2))
|
|
|
|
self.loop.run_until_complete(proto.completed)
|
|
|
|
self.assertEqual(7, proto.returncode)
|
|
|
|
self.assertIsNone(transp.close())
|
|
|
|
|
|
|
|
def test_subprocess_kill(self):
|
|
|
|
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
|
|
|
|
|
2014-02-26 06:31:55 -04:00
|
|
|
connect = self.loop.subprocess_exec(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
sys.executable, prog)
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
|
|
|
|
|
|
|
transp.kill()
|
|
|
|
self.loop.run_until_complete(proto.completed)
|
2013-10-30 18:52:03 -03:00
|
|
|
self.check_killed(proto.returncode)
|
2015-01-14 19:04:21 -04:00
|
|
|
transp.close()
|
2013-10-30 18:52:03 -03:00
|
|
|
|
|
|
|
def test_subprocess_terminate(self):
|
|
|
|
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
|
|
|
|
|
2014-02-26 06:31:55 -04:00
|
|
|
connect = self.loop.subprocess_exec(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
sys.executable, prog)
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-30 18:52:03 -03:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
|
|
|
|
|
|
|
transp.terminate()
|
|
|
|
self.loop.run_until_complete(proto.completed)
|
|
|
|
self.check_terminated(proto.returncode)
|
2015-01-14 19:04:21 -04:00
|
|
|
transp.close()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2013-10-30 18:52:03 -03:00
|
|
|
@unittest.skipIf(sys.platform == 'win32', "Don't have SIGHUP")
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_subprocess_send_signal(self):
|
2017-07-25 14:19:09 -03:00
|
|
|
# bpo-31034: Make sure that we get the default signal handler (killing
|
|
|
|
# the process). The parent process may have decided to ignore SIGHUP,
|
|
|
|
# and signal handlers are inherited.
|
|
|
|
old_handler = signal.signal(signal.SIGHUP, signal.SIG_DFL)
|
|
|
|
try:
|
|
|
|
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
|
|
|
|
|
|
|
|
connect = self.loop.subprocess_exec(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
sys.executable, prog)
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
|
|
|
self.loop.run_until_complete(proto.connected)
|
|
|
|
|
|
|
|
transp.send_signal(signal.SIGHUP)
|
|
|
|
self.loop.run_until_complete(proto.completed)
|
|
|
|
self.assertEqual(-signal.SIGHUP, proto.returncode)
|
|
|
|
transp.close()
|
|
|
|
finally:
|
|
|
|
signal.signal(signal.SIGHUP, old_handler)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_subprocess_stderr(self):
|
|
|
|
prog = os.path.join(os.path.dirname(__file__), 'echo2.py')
|
|
|
|
|
2014-02-26 06:31:55 -04:00
|
|
|
connect = self.loop.subprocess_exec(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
sys.executable, prog)
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
|
|
|
|
|
|
|
stdin = transp.get_pipe_transport(0)
|
|
|
|
stdin.write(b'test')
|
|
|
|
|
|
|
|
self.loop.run_until_complete(proto.completed)
|
|
|
|
|
|
|
|
transp.close()
|
|
|
|
self.assertEqual(b'OUT:test', proto.data[1])
|
|
|
|
self.assertTrue(proto.data[2].startswith(b'ERR:test'), proto.data[2])
|
|
|
|
self.assertEqual(0, proto.returncode)
|
|
|
|
|
|
|
|
def test_subprocess_stderr_redirect_to_stdout(self):
|
|
|
|
prog = os.path.join(os.path.dirname(__file__), 'echo2.py')
|
|
|
|
|
2014-02-26 06:31:55 -04:00
|
|
|
connect = self.loop.subprocess_exec(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
sys.executable, prog, stderr=subprocess.STDOUT)
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
|
|
|
|
|
|
|
stdin = transp.get_pipe_transport(0)
|
|
|
|
self.assertIsNotNone(transp.get_pipe_transport(1))
|
|
|
|
self.assertIsNone(transp.get_pipe_transport(2))
|
|
|
|
|
|
|
|
stdin.write(b'test')
|
|
|
|
self.loop.run_until_complete(proto.completed)
|
|
|
|
self.assertTrue(proto.data[1].startswith(b'OUT:testERR:test'),
|
|
|
|
proto.data[1])
|
|
|
|
self.assertEqual(b'', proto.data[2])
|
|
|
|
|
|
|
|
transp.close()
|
|
|
|
self.assertEqual(0, proto.returncode)
|
|
|
|
|
|
|
|
def test_subprocess_close_client_stream(self):
|
|
|
|
prog = os.path.join(os.path.dirname(__file__), 'echo3.py')
|
|
|
|
|
2014-02-26 06:31:55 -04:00
|
|
|
connect = self.loop.subprocess_exec(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
sys.executable, prog)
|
|
|
|
transp, proto = self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.connected)
|
|
|
|
|
|
|
|
stdin = transp.get_pipe_transport(0)
|
|
|
|
stdout = transp.get_pipe_transport(1)
|
|
|
|
stdin.write(b'test')
|
|
|
|
self.loop.run_until_complete(proto.got_data[1].wait())
|
|
|
|
self.assertEqual(b'OUT:test', proto.data[1])
|
|
|
|
|
|
|
|
stdout.close()
|
|
|
|
self.loop.run_until_complete(proto.disconnects[1])
|
|
|
|
stdin.write(b'xxx')
|
|
|
|
self.loop.run_until_complete(proto.got_data[2].wait())
|
2013-10-30 18:52:03 -03:00
|
|
|
if sys.platform != 'win32':
|
|
|
|
self.assertEqual(b'ERR:BrokenPipeError', proto.data[2])
|
|
|
|
else:
|
|
|
|
# After closing the read-end of a pipe, writing to the
|
|
|
|
# write-end using os.write() fails with errno==EINVAL and
|
|
|
|
# GetLastError()==ERROR_INVALID_NAME on Windows!?! (Using
|
|
|
|
# WriteFile() we get ERROR_BROKEN_PIPE as expected.)
|
|
|
|
self.assertEqual(b'ERR:OSError', proto.data[2])
|
2015-01-29 19:05:19 -04:00
|
|
|
with test_utils.disable_logger():
|
|
|
|
transp.close()
|
2013-10-17 17:40:50 -03:00
|
|
|
self.loop.run_until_complete(proto.completed)
|
2015-01-29 19:05:19 -04:00
|
|
|
self.check_killed(proto.returncode)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2013-10-20 15:31:43 -03:00
|
|
|
def test_subprocess_wait_no_same_group(self):
|
2014-02-26 06:31:55 -04:00
|
|
|
# start the new process in a new session
|
|
|
|
connect = self.loop.subprocess_shell(
|
|
|
|
functools.partial(MySubprocessProtocol, self.loop),
|
|
|
|
'exit 7', stdin=None, stdout=None, stderr=None,
|
|
|
|
start_new_session=True)
|
|
|
|
_, proto = yield self.loop.run_until_complete(connect)
|
|
|
|
self.assertIsInstance(proto, MySubprocessProtocol)
|
2013-10-20 15:31:43 -03:00
|
|
|
self.loop.run_until_complete(proto.completed)
|
|
|
|
self.assertEqual(7, proto.returncode)
|
|
|
|
|
2014-01-29 18:35:15 -04:00
|
|
|
def test_subprocess_exec_invalid_args(self):
|
2017-12-08 18:23:48 -04:00
|
|
|
|
|
|
|
async def connect(**kwds):
|
|
|
|
await self.loop.subprocess_exec(
|
2014-01-29 18:35:15 -04:00
|
|
|
asyncio.SubprocessProtocol,
|
|
|
|
'pwd', **kwds)
|
|
|
|
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(connect(universal_newlines=True))
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(connect(bufsize=4096))
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(connect(shell=True))
|
|
|
|
|
|
|
|
def test_subprocess_shell_invalid_args(self):
|
2017-12-08 18:23:48 -04:00
|
|
|
|
|
|
|
async def connect(cmd=None, **kwds):
|
2014-01-29 18:35:15 -04:00
|
|
|
if not cmd:
|
|
|
|
cmd = 'pwd'
|
2017-12-08 18:23:48 -04:00
|
|
|
await self.loop.subprocess_shell(
|
2014-01-29 18:35:15 -04:00
|
|
|
asyncio.SubprocessProtocol,
|
|
|
|
cmd, **kwds)
|
|
|
|
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(connect(['ls', '-l']))
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(connect(universal_newlines=True))
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(connect(bufsize=4096))
|
|
|
|
with self.assertRaises(ValueError):
|
|
|
|
self.loop.run_until_complete(connect(shell=False))
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2018-02-25 13:10:58 -04:00
|
|
|
class SendfileBase:
|
2018-01-27 15:22:47 -04:00
|
|
|
|
2018-05-29 11:21:46 -03:00
|
|
|
DATA = b"SendfileBaseData" * (1024 * 8) # 128 KiB
|
|
|
|
|
|
|
|
# Reduce socket buffer size to test on relative small data sets.
|
|
|
|
BUF_SIZE = 4 * 1024 # 4 KiB
|
2018-01-27 15:22:47 -04:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def setUpClass(cls):
|
|
|
|
with open(support.TESTFN, 'wb') as fp:
|
|
|
|
fp.write(cls.DATA)
|
|
|
|
super().setUpClass()
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def tearDownClass(cls):
|
|
|
|
support.unlink(support.TESTFN)
|
|
|
|
super().tearDownClass()
|
|
|
|
|
|
|
|
def setUp(self):
|
|
|
|
self.file = open(support.TESTFN, 'rb')
|
|
|
|
self.addCleanup(self.file.close)
|
|
|
|
super().setUp()
|
|
|
|
|
|
|
|
def run_loop(self, coro):
|
|
|
|
return self.loop.run_until_complete(coro)
|
|
|
|
|
2018-02-25 13:10:58 -04:00
|
|
|
|
|
|
|
class SockSendfileMixin(SendfileBase):
|
|
|
|
|
|
|
|
class MyProto(asyncio.Protocol):
|
|
|
|
|
|
|
|
def __init__(self, loop):
|
|
|
|
self.started = False
|
|
|
|
self.closed = False
|
|
|
|
self.data = bytearray()
|
|
|
|
self.fut = loop.create_future()
|
|
|
|
self.transport = None
|
|
|
|
|
|
|
|
def connection_made(self, transport):
|
|
|
|
self.started = True
|
|
|
|
self.transport = transport
|
|
|
|
|
|
|
|
def data_received(self, data):
|
|
|
|
self.data.extend(data)
|
|
|
|
|
|
|
|
def connection_lost(self, exc):
|
|
|
|
self.closed = True
|
|
|
|
self.fut.set_result(None)
|
|
|
|
|
|
|
|
async def wait_closed(self):
|
|
|
|
await self.fut
|
|
|
|
|
2018-05-28 22:42:45 -03:00
|
|
|
@classmethod
|
|
|
|
def setUpClass(cls):
|
|
|
|
cls.__old_bufsize = constants.SENDFILE_FALLBACK_READBUFFER_SIZE
|
|
|
|
constants.SENDFILE_FALLBACK_READBUFFER_SIZE = 1024 * 16
|
|
|
|
super().setUpClass()
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def tearDownClass(cls):
|
|
|
|
constants.SENDFILE_FALLBACK_READBUFFER_SIZE = cls.__old_bufsize
|
|
|
|
super().tearDownClass()
|
|
|
|
|
2018-02-25 13:10:58 -04:00
|
|
|
def make_socket(self, cleanup=True):
|
|
|
|
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
|
|
sock.setblocking(False)
|
|
|
|
if cleanup:
|
|
|
|
self.addCleanup(sock.close)
|
|
|
|
return sock
|
|
|
|
|
2018-05-29 11:21:46 -03:00
|
|
|
def reduce_receive_buffer_size(self, sock):
|
|
|
|
# Reduce receive socket buffer size to test on relative
|
|
|
|
# small data sets.
|
|
|
|
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, self.BUF_SIZE)
|
|
|
|
|
|
|
|
def reduce_send_buffer_size(self, sock, transport=None):
|
|
|
|
# Reduce send socket buffer size to test on relative small data sets.
|
|
|
|
|
|
|
|
# On macOS, SO_SNDBUF is reset by connect(). So this method
|
|
|
|
# should be called after the socket is connected.
|
|
|
|
sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, self.BUF_SIZE)
|
|
|
|
|
|
|
|
if transport is not None:
|
|
|
|
transport.set_write_buffer_limits(high=self.BUF_SIZE)
|
|
|
|
|
2018-02-25 13:10:58 -04:00
|
|
|
def prepare_socksendfile(self):
|
|
|
|
proto = self.MyProto(self.loop)
|
|
|
|
port = support.find_unused_port()
|
|
|
|
srv_sock = self.make_socket(cleanup=False)
|
|
|
|
srv_sock.bind((support.HOST, port))
|
|
|
|
server = self.run_loop(self.loop.create_server(
|
|
|
|
lambda: proto, sock=srv_sock))
|
2018-05-29 11:21:46 -03:00
|
|
|
self.reduce_receive_buffer_size(srv_sock)
|
|
|
|
|
|
|
|
sock = self.make_socket()
|
2018-02-25 13:10:58 -04:00
|
|
|
self.run_loop(self.loop.sock_connect(sock, ('127.0.0.1', port)))
|
2018-05-29 11:21:46 -03:00
|
|
|
self.reduce_send_buffer_size(sock)
|
2018-02-25 13:10:58 -04:00
|
|
|
|
|
|
|
def cleanup():
|
|
|
|
if proto.transport is not None:
|
|
|
|
# can be None if the task was cancelled before
|
|
|
|
# connection_made callback
|
|
|
|
proto.transport.close()
|
|
|
|
self.run_loop(proto.wait_closed())
|
|
|
|
|
|
|
|
server.close()
|
|
|
|
self.run_loop(server.wait_closed())
|
|
|
|
|
|
|
|
self.addCleanup(cleanup)
|
|
|
|
|
|
|
|
return sock, proto
|
|
|
|
|
|
|
|
def test_sock_sendfile_success(self):
|
|
|
|
sock, proto = self.prepare_socksendfile()
|
|
|
|
ret = self.run_loop(self.loop.sock_sendfile(sock, self.file))
|
|
|
|
sock.close()
|
|
|
|
self.run_loop(proto.wait_closed())
|
|
|
|
|
|
|
|
self.assertEqual(ret, len(self.DATA))
|
|
|
|
self.assertEqual(proto.data, self.DATA)
|
|
|
|
self.assertEqual(self.file.tell(), len(self.DATA))
|
|
|
|
|
|
|
|
def test_sock_sendfile_with_offset_and_count(self):
|
|
|
|
sock, proto = self.prepare_socksendfile()
|
|
|
|
ret = self.run_loop(self.loop.sock_sendfile(sock, self.file,
|
|
|
|
1000, 2000))
|
|
|
|
sock.close()
|
|
|
|
self.run_loop(proto.wait_closed())
|
|
|
|
|
|
|
|
self.assertEqual(proto.data, self.DATA[1000:3000])
|
|
|
|
self.assertEqual(self.file.tell(), 3000)
|
|
|
|
self.assertEqual(ret, 2000)
|
|
|
|
|
|
|
|
def test_sock_sendfile_zero_size(self):
|
|
|
|
sock, proto = self.prepare_socksendfile()
|
|
|
|
with tempfile.TemporaryFile() as f:
|
|
|
|
ret = self.run_loop(self.loop.sock_sendfile(sock, f,
|
|
|
|
0, None))
|
|
|
|
sock.close()
|
|
|
|
self.run_loop(proto.wait_closed())
|
|
|
|
|
|
|
|
self.assertEqual(ret, 0)
|
|
|
|
self.assertEqual(self.file.tell(), 0)
|
|
|
|
|
|
|
|
def test_sock_sendfile_mix_with_regular_send(self):
|
2018-05-29 11:21:46 -03:00
|
|
|
buf = b"mix_regular_send" * (4 * 1024) # 64 KiB
|
2018-02-25 13:10:58 -04:00
|
|
|
sock, proto = self.prepare_socksendfile()
|
|
|
|
self.run_loop(self.loop.sock_sendall(sock, buf))
|
|
|
|
ret = self.run_loop(self.loop.sock_sendfile(sock, self.file))
|
|
|
|
self.run_loop(self.loop.sock_sendall(sock, buf))
|
|
|
|
sock.close()
|
|
|
|
self.run_loop(proto.wait_closed())
|
|
|
|
|
|
|
|
self.assertEqual(ret, len(self.DATA))
|
|
|
|
expected = buf + self.DATA + buf
|
|
|
|
self.assertEqual(proto.data, expected)
|
|
|
|
self.assertEqual(self.file.tell(), len(self.DATA))
|
|
|
|
|
|
|
|
|
|
|
|
class SendfileMixin(SendfileBase):
|
|
|
|
|
|
|
|
class MySendfileProto(MyBaseProto):
|
|
|
|
|
|
|
|
def __init__(self, loop=None, close_after=0):
|
|
|
|
super().__init__(loop)
|
|
|
|
self.data = bytearray()
|
|
|
|
self.close_after = close_after
|
|
|
|
|
|
|
|
def data_received(self, data):
|
|
|
|
self.data.extend(data)
|
|
|
|
super().data_received(data)
|
|
|
|
if self.close_after and self.nbytes >= self.close_after:
|
|
|
|
self.transport.close()
|
|
|
|
|
|
|
|
|
|
|
|
# Note: sendfile via SSL transport is equal to sendfile fallback
|
|
|
|
|
|
|
|
def prepare_sendfile(self, *, is_ssl=False, close_after=0):
|
2018-01-27 15:22:47 -04:00
|
|
|
port = support.find_unused_port()
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto = self.MySendfileProto(loop=self.loop,
|
|
|
|
close_after=close_after)
|
2018-01-27 15:22:47 -04:00
|
|
|
if is_ssl:
|
2018-01-27 18:00:37 -04:00
|
|
|
if not ssl:
|
|
|
|
self.skipTest("No ssl module")
|
2018-01-27 15:22:47 -04:00
|
|
|
srv_ctx = test_utils.simple_server_sslcontext()
|
|
|
|
cli_ctx = test_utils.simple_client_sslcontext()
|
|
|
|
else:
|
|
|
|
srv_ctx = None
|
|
|
|
cli_ctx = None
|
|
|
|
srv_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
|
|
srv_sock.bind((support.HOST, port))
|
|
|
|
server = self.run_loop(self.loop.create_server(
|
|
|
|
lambda: srv_proto, sock=srv_sock, ssl=srv_ctx))
|
2018-05-29 11:21:46 -03:00
|
|
|
self.reduce_receive_buffer_size(srv_sock)
|
2018-01-27 15:22:47 -04:00
|
|
|
|
|
|
|
if is_ssl:
|
|
|
|
server_hostname = support.HOST
|
|
|
|
else:
|
|
|
|
server_hostname = None
|
|
|
|
cli_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
2018-05-23 22:21:14 -03:00
|
|
|
cli_sock.connect((support.HOST, port))
|
2018-05-29 11:21:46 -03:00
|
|
|
|
2018-02-25 13:10:58 -04:00
|
|
|
cli_proto = self.MySendfileProto(loop=self.loop)
|
2018-01-27 15:22:47 -04:00
|
|
|
tr, pr = self.run_loop(self.loop.create_connection(
|
|
|
|
lambda: cli_proto, sock=cli_sock,
|
|
|
|
ssl=cli_ctx, server_hostname=server_hostname))
|
2018-05-29 11:21:46 -03:00
|
|
|
self.reduce_send_buffer_size(cli_sock, transport=tr)
|
2018-01-27 15:22:47 -04:00
|
|
|
|
|
|
|
def cleanup():
|
|
|
|
srv_proto.transport.close()
|
|
|
|
cli_proto.transport.close()
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.run_loop(cli_proto.done)
|
|
|
|
|
|
|
|
server.close()
|
|
|
|
self.run_loop(server.wait_closed())
|
|
|
|
|
|
|
|
self.addCleanup(cleanup)
|
|
|
|
return srv_proto, cli_proto
|
|
|
|
|
|
|
|
@unittest.skipIf(sys.platform == 'win32', "UDP sockets are not supported")
|
|
|
|
def test_sendfile_not_supported(self):
|
|
|
|
tr, pr = self.run_loop(
|
|
|
|
self.loop.create_datagram_endpoint(
|
|
|
|
lambda: MyDatagramProto(loop=self.loop),
|
|
|
|
family=socket.AF_INET))
|
|
|
|
try:
|
|
|
|
with self.assertRaisesRegex(RuntimeError, "not supported"):
|
|
|
|
self.run_loop(
|
|
|
|
self.loop.sendfile(tr, self.file))
|
|
|
|
self.assertEqual(0, self.file.tell())
|
|
|
|
finally:
|
|
|
|
# don't use self.addCleanup because it produces resource warning
|
|
|
|
tr.close()
|
|
|
|
|
|
|
|
def test_sendfile(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile()
|
2018-01-27 15:22:47 -04:00
|
|
|
ret = self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file))
|
|
|
|
cli_proto.transport.close()
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(ret, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.nbytes, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.data, self.DATA)
|
|
|
|
self.assertEqual(self.file.tell(), len(self.DATA))
|
|
|
|
|
|
|
|
def test_sendfile_force_fallback(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile()
|
2018-01-27 15:22:47 -04:00
|
|
|
|
|
|
|
def sendfile_native(transp, file, offset, count):
|
|
|
|
# to raise SendfileNotAvailableError
|
|
|
|
return base_events.BaseEventLoop._sendfile_native(
|
|
|
|
self.loop, transp, file, offset, count)
|
|
|
|
|
|
|
|
self.loop._sendfile_native = sendfile_native
|
|
|
|
|
|
|
|
ret = self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file))
|
|
|
|
cli_proto.transport.close()
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(ret, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.nbytes, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.data, self.DATA)
|
|
|
|
self.assertEqual(self.file.tell(), len(self.DATA))
|
|
|
|
|
|
|
|
def test_sendfile_force_unsupported_native(self):
|
|
|
|
if sys.platform == 'win32':
|
|
|
|
if isinstance(self.loop, asyncio.ProactorEventLoop):
|
|
|
|
self.skipTest("Fails on proactor event loop")
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile()
|
2018-01-27 15:22:47 -04:00
|
|
|
|
|
|
|
def sendfile_native(transp, file, offset, count):
|
|
|
|
# to raise SendfileNotAvailableError
|
|
|
|
return base_events.BaseEventLoop._sendfile_native(
|
|
|
|
self.loop, transp, file, offset, count)
|
|
|
|
|
|
|
|
self.loop._sendfile_native = sendfile_native
|
|
|
|
|
|
|
|
with self.assertRaisesRegex(events.SendfileNotAvailableError,
|
|
|
|
"not supported"):
|
|
|
|
self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file,
|
|
|
|
fallback=False))
|
|
|
|
|
|
|
|
cli_proto.transport.close()
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(srv_proto.nbytes, 0)
|
|
|
|
self.assertEqual(self.file.tell(), 0)
|
|
|
|
|
|
|
|
def test_sendfile_ssl(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile(is_ssl=True)
|
2018-01-27 15:22:47 -04:00
|
|
|
ret = self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file))
|
|
|
|
cli_proto.transport.close()
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(ret, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.nbytes, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.data, self.DATA)
|
|
|
|
self.assertEqual(self.file.tell(), len(self.DATA))
|
|
|
|
|
|
|
|
def test_sendfile_for_closing_transp(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile()
|
2018-01-27 15:22:47 -04:00
|
|
|
cli_proto.transport.close()
|
|
|
|
with self.assertRaisesRegex(RuntimeError, "is closing"):
|
|
|
|
self.run_loop(self.loop.sendfile(cli_proto.transport, self.file))
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(srv_proto.nbytes, 0)
|
|
|
|
self.assertEqual(self.file.tell(), 0)
|
|
|
|
|
|
|
|
def test_sendfile_pre_and_post_data(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile()
|
2018-05-29 11:21:46 -03:00
|
|
|
PREFIX = b'PREFIX__' * 1024 # 8 KiB
|
|
|
|
SUFFIX = b'--SUFFIX' * 1024 # 8 KiB
|
2018-01-27 15:22:47 -04:00
|
|
|
cli_proto.transport.write(PREFIX)
|
|
|
|
ret = self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file))
|
|
|
|
cli_proto.transport.write(SUFFIX)
|
|
|
|
cli_proto.transport.close()
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(ret, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.data, PREFIX + self.DATA + SUFFIX)
|
|
|
|
self.assertEqual(self.file.tell(), len(self.DATA))
|
|
|
|
|
|
|
|
def test_sendfile_ssl_pre_and_post_data(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile(is_ssl=True)
|
2018-01-27 15:22:47 -04:00
|
|
|
PREFIX = b'zxcvbnm' * 1024
|
|
|
|
SUFFIX = b'0987654321' * 1024
|
|
|
|
cli_proto.transport.write(PREFIX)
|
|
|
|
ret = self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file))
|
|
|
|
cli_proto.transport.write(SUFFIX)
|
|
|
|
cli_proto.transport.close()
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(ret, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.data, PREFIX + self.DATA + SUFFIX)
|
|
|
|
self.assertEqual(self.file.tell(), len(self.DATA))
|
|
|
|
|
|
|
|
def test_sendfile_partial(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile()
|
2018-01-27 15:22:47 -04:00
|
|
|
ret = self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file, 1000, 100))
|
|
|
|
cli_proto.transport.close()
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(ret, 100)
|
|
|
|
self.assertEqual(srv_proto.nbytes, 100)
|
|
|
|
self.assertEqual(srv_proto.data, self.DATA[1000:1100])
|
|
|
|
self.assertEqual(self.file.tell(), 1100)
|
|
|
|
|
|
|
|
def test_sendfile_ssl_partial(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile(is_ssl=True)
|
2018-01-27 15:22:47 -04:00
|
|
|
ret = self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file, 1000, 100))
|
|
|
|
cli_proto.transport.close()
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(ret, 100)
|
|
|
|
self.assertEqual(srv_proto.nbytes, 100)
|
|
|
|
self.assertEqual(srv_proto.data, self.DATA[1000:1100])
|
|
|
|
self.assertEqual(self.file.tell(), 1100)
|
|
|
|
|
|
|
|
def test_sendfile_close_peer_after_receiving(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile(
|
|
|
|
close_after=len(self.DATA))
|
2018-01-27 15:22:47 -04:00
|
|
|
ret = self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file))
|
|
|
|
cli_proto.transport.close()
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(ret, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.nbytes, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.data, self.DATA)
|
|
|
|
self.assertEqual(self.file.tell(), len(self.DATA))
|
|
|
|
|
|
|
|
def test_sendfile_ssl_close_peer_after_receiving(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile(
|
|
|
|
is_ssl=True, close_after=len(self.DATA))
|
2018-01-27 15:22:47 -04:00
|
|
|
ret = self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file))
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
self.assertEqual(ret, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.nbytes, len(self.DATA))
|
|
|
|
self.assertEqual(srv_proto.data, self.DATA)
|
|
|
|
self.assertEqual(self.file.tell(), len(self.DATA))
|
|
|
|
|
2018-05-28 15:50:45 -03:00
|
|
|
def test_sendfile_close_peer_in_the_middle_of_receiving(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile(close_after=1024)
|
2018-01-27 15:22:47 -04:00
|
|
|
with self.assertRaises(ConnectionError):
|
|
|
|
self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file))
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
|
|
|
|
self.assertTrue(1024 <= srv_proto.nbytes < len(self.DATA),
|
|
|
|
srv_proto.nbytes)
|
|
|
|
self.assertTrue(1024 <= self.file.tell() < len(self.DATA),
|
|
|
|
self.file.tell())
|
2018-02-25 13:10:58 -04:00
|
|
|
self.assertTrue(cli_proto.transport.is_closing())
|
2018-01-27 15:22:47 -04:00
|
|
|
|
2018-05-28 15:50:45 -03:00
|
|
|
def test_sendfile_fallback_close_peer_in_the_middle_of_receiving(self):
|
2018-01-27 15:22:47 -04:00
|
|
|
|
|
|
|
def sendfile_native(transp, file, offset, count):
|
|
|
|
# to raise SendfileNotAvailableError
|
|
|
|
return base_events.BaseEventLoop._sendfile_native(
|
|
|
|
self.loop, transp, file, offset, count)
|
|
|
|
|
|
|
|
self.loop._sendfile_native = sendfile_native
|
|
|
|
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile(close_after=1024)
|
2018-01-27 15:22:47 -04:00
|
|
|
with self.assertRaises(ConnectionError):
|
|
|
|
self.run_loop(
|
|
|
|
self.loop.sendfile(cli_proto.transport, self.file))
|
|
|
|
self.run_loop(srv_proto.done)
|
|
|
|
|
|
|
|
self.assertTrue(1024 <= srv_proto.nbytes < len(self.DATA),
|
|
|
|
srv_proto.nbytes)
|
|
|
|
self.assertTrue(1024 <= self.file.tell() < len(self.DATA),
|
|
|
|
self.file.tell())
|
|
|
|
|
|
|
|
@unittest.skipIf(not hasattr(os, 'sendfile'),
|
|
|
|
"Don't have native sendfile support")
|
|
|
|
def test_sendfile_prevents_bare_write(self):
|
2018-02-25 13:10:58 -04:00
|
|
|
srv_proto, cli_proto = self.prepare_sendfile()
|
2018-01-27 15:22:47 -04:00
|
|
|
fut = self.loop.create_future()
|
|
|
|
|
|
|
|
async def coro():
|
|
|
|
fut.set_result(None)
|
|
|
|
return await self.loop.sendfile(cli_proto.transport, self.file)
|
|
|
|
|
|
|
|
t = self.loop.create_task(coro())
|
|
|
|
self.run_loop(fut)
|
|
|
|
with self.assertRaisesRegex(RuntimeError,
|
|
|
|
"sendfile is in progress"):
|
|
|
|
cli_proto.transport.write(b'data')
|
|
|
|
ret = self.run_loop(t)
|
|
|
|
self.assertEqual(ret, len(self.DATA))
|
|
|
|
|
2018-01-27 16:52:52 -04:00
|
|
|
def test_sendfile_no_fallback_for_fallback_transport(self):
|
|
|
|
transport = mock.Mock()
|
|
|
|
transport.is_closing.side_effect = lambda: False
|
|
|
|
transport._sendfile_compatible = constants._SendfileMode.FALLBACK
|
|
|
|
with self.assertRaisesRegex(RuntimeError, 'fallback is disabled'):
|
|
|
|
self.loop.run_until_complete(
|
|
|
|
self.loop.sendfile(transport, None, fallback=False))
|
|
|
|
|
2018-01-27 15:22:47 -04:00
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
if sys.platform == 'win32':
|
|
|
|
|
2018-01-27 15:22:47 -04:00
|
|
|
class SelectEventLoopTests(EventLoopTestsMixin,
|
|
|
|
SendfileMixin,
|
2018-02-25 13:10:58 -04:00
|
|
|
SockSendfileMixin,
|
2018-01-27 15:22:47 -04:00
|
|
|
test_utils.TestCase):
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def create_event_loop(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
return asyncio.SelectorEventLoop()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2013-10-30 18:52:03 -03:00
|
|
|
class ProactorEventLoopTests(EventLoopTestsMixin,
|
2018-01-27 15:22:47 -04:00
|
|
|
SendfileMixin,
|
2018-02-25 13:10:58 -04:00
|
|
|
SockSendfileMixin,
|
2013-10-30 18:52:03 -03:00
|
|
|
SubprocessTestsMixin,
|
2014-06-17 20:36:32 -03:00
|
|
|
test_utils.TestCase):
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def create_event_loop(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
return asyncio.ProactorEventLoop()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_reader_callback(self):
|
|
|
|
raise unittest.SkipTest("IocpEventLoop does not have add_reader()")
|
|
|
|
|
|
|
|
def test_reader_callback_cancel(self):
|
|
|
|
raise unittest.SkipTest("IocpEventLoop does not have add_reader()")
|
|
|
|
|
|
|
|
def test_writer_callback(self):
|
|
|
|
raise unittest.SkipTest("IocpEventLoop does not have add_writer()")
|
|
|
|
|
|
|
|
def test_writer_callback_cancel(self):
|
|
|
|
raise unittest.SkipTest("IocpEventLoop does not have add_writer()")
|
|
|
|
|
|
|
|
def test_create_datagram_endpoint(self):
|
|
|
|
raise unittest.SkipTest(
|
|
|
|
"IocpEventLoop does not have create_datagram_endpoint()")
|
2014-03-05 19:52:53 -04:00
|
|
|
|
|
|
|
def test_remove_fds_after_closing(self):
|
|
|
|
raise unittest.SkipTest("IocpEventLoop does not have add_reader()")
|
2013-10-17 17:40:50 -03:00
|
|
|
else:
|
2017-11-28 10:19:56 -04:00
|
|
|
import selectors
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2018-02-25 13:10:58 -04:00
|
|
|
class UnixEventLoopTestsMixin(EventLoopTestsMixin,
|
|
|
|
SendfileMixin,
|
|
|
|
SockSendfileMixin):
|
2013-11-04 19:50:46 -04:00
|
|
|
def setUp(self):
|
|
|
|
super().setUp()
|
2014-01-25 10:32:06 -04:00
|
|
|
watcher = asyncio.SafeChildWatcher()
|
2013-11-13 19:50:08 -04:00
|
|
|
watcher.attach_loop(self.loop)
|
2014-01-25 10:32:06 -04:00
|
|
|
asyncio.set_child_watcher(watcher)
|
2013-11-04 19:50:46 -04:00
|
|
|
|
|
|
|
def tearDown(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
asyncio.set_child_watcher(None)
|
2013-11-04 19:50:46 -04:00
|
|
|
super().tearDown()
|
|
|
|
|
2017-03-02 21:07:11 -04:00
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
if hasattr(selectors, 'KqueueSelector'):
|
2013-11-04 19:50:46 -04:00
|
|
|
class KqueueEventLoopTests(UnixEventLoopTestsMixin,
|
2013-10-30 18:52:03 -03:00
|
|
|
SubprocessTestsMixin,
|
2014-06-17 20:36:32 -03:00
|
|
|
test_utils.TestCase):
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def create_event_loop(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
return asyncio.SelectorEventLoop(
|
2013-10-17 17:40:50 -03:00
|
|
|
selectors.KqueueSelector())
|
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
# kqueue doesn't support character devices (PTY) on Mac OS X older
|
|
|
|
# than 10.9 (Maverick)
|
|
|
|
@support.requires_mac_ver(10, 9)
|
2014-02-17 20:30:03 -04:00
|
|
|
# Issue #20667: KqueueEventLoopTests.test_read_pty_output()
|
2014-02-18 04:13:47 -04:00
|
|
|
# hangs on OpenBSD 5.5
|
|
|
|
@unittest.skipIf(sys.platform.startswith('openbsd'),
|
|
|
|
'test hangs on OpenBSD')
|
2014-01-25 10:32:06 -04:00
|
|
|
def test_read_pty_output(self):
|
|
|
|
super().test_read_pty_output()
|
|
|
|
|
|
|
|
# kqueue doesn't support character devices (PTY) on Mac OS X older
|
|
|
|
# than 10.9 (Maverick)
|
|
|
|
@support.requires_mac_ver(10, 9)
|
|
|
|
def test_write_pty(self):
|
|
|
|
super().test_write_pty()
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
if hasattr(selectors, 'EpollSelector'):
|
2013-11-04 19:50:46 -04:00
|
|
|
class EPollEventLoopTests(UnixEventLoopTestsMixin,
|
2013-10-30 18:52:03 -03:00
|
|
|
SubprocessTestsMixin,
|
2014-06-17 20:36:32 -03:00
|
|
|
test_utils.TestCase):
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def create_event_loop(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
return asyncio.SelectorEventLoop(selectors.EpollSelector())
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
if hasattr(selectors, 'PollSelector'):
|
2013-11-04 19:50:46 -04:00
|
|
|
class PollEventLoopTests(UnixEventLoopTestsMixin,
|
2013-10-30 18:52:03 -03:00
|
|
|
SubprocessTestsMixin,
|
2014-06-17 20:36:32 -03:00
|
|
|
test_utils.TestCase):
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def create_event_loop(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
return asyncio.SelectorEventLoop(selectors.PollSelector())
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
# Should always exist.
|
2013-11-04 19:50:46 -04:00
|
|
|
class SelectEventLoopTests(UnixEventLoopTestsMixin,
|
2013-10-30 18:52:03 -03:00
|
|
|
SubprocessTestsMixin,
|
2014-06-17 20:36:32 -03:00
|
|
|
test_utils.TestCase):
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def create_event_loop(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
return asyncio.SelectorEventLoop(selectors.SelectSelector())
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
|
2016-09-15 16:58:15 -03:00
|
|
|
def noop(*args, **kwargs):
|
2014-06-12 13:39:26 -03:00
|
|
|
pass
|
|
|
|
|
|
|
|
|
2014-06-27 08:52:20 -03:00
|
|
|
class HandleTests(test_utils.TestCase):
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-06-12 13:39:26 -03:00
|
|
|
def setUp(self):
|
2016-11-04 15:29:28 -03:00
|
|
|
super().setUp()
|
2014-06-27 08:52:20 -03:00
|
|
|
self.loop = mock.Mock()
|
|
|
|
self.loop.get_debug.return_value = True
|
2014-06-12 13:39:26 -03:00
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_handle(self):
|
|
|
|
def callback(*args):
|
|
|
|
return args
|
|
|
|
|
|
|
|
args = ()
|
2014-06-12 13:39:26 -03:00
|
|
|
h = asyncio.Handle(callback, args, self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIs(h._callback, callback)
|
|
|
|
self.assertIs(h._args, args)
|
2017-11-07 05:06:05 -04:00
|
|
|
self.assertFalse(h.cancelled())
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
h.cancel()
|
2017-11-07 05:06:05 -04:00
|
|
|
self.assertTrue(h.cancelled())
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-02-18 19:02:19 -04:00
|
|
|
def test_callback_with_exception(self):
|
2013-10-17 17:40:50 -03:00
|
|
|
def callback():
|
|
|
|
raise ValueError()
|
|
|
|
|
2014-06-12 13:39:26 -03:00
|
|
|
self.loop = mock.Mock()
|
|
|
|
self.loop.call_exception_handler = mock.Mock()
|
2014-02-18 19:02:19 -04:00
|
|
|
|
2014-06-12 13:39:26 -03:00
|
|
|
h = asyncio.Handle(callback, (), self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
h._run()
|
2014-02-18 19:02:19 -04:00
|
|
|
|
2014-06-12 13:39:26 -03:00
|
|
|
self.loop.call_exception_handler.assert_called_with({
|
2014-02-18 19:02:19 -04:00
|
|
|
'message': test_utils.MockPattern('Exception in callback.*'),
|
2014-02-26 05:25:02 -04:00
|
|
|
'exception': mock.ANY,
|
2014-06-27 08:52:20 -03:00
|
|
|
'handle': h,
|
|
|
|
'source_traceback': h._source_traceback,
|
2014-02-18 19:02:19 -04:00
|
|
|
})
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-04-27 14:44:22 -03:00
|
|
|
def test_handle_weakref(self):
|
|
|
|
wd = weakref.WeakValueDictionary()
|
2014-06-12 13:39:26 -03:00
|
|
|
h = asyncio.Handle(lambda: None, (), self.loop)
|
2014-04-27 14:44:22 -03:00
|
|
|
wd['h'] = h # Would fail without __weakref__ slot.
|
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
def test_handle_repr(self):
|
2014-07-10 17:32:58 -03:00
|
|
|
self.loop.get_debug.return_value = False
|
|
|
|
|
2014-06-12 13:39:26 -03:00
|
|
|
# simple function
|
2014-07-10 17:32:58 -03:00
|
|
|
h = asyncio.Handle(noop, (1, 2), self.loop)
|
|
|
|
filename, lineno = test_utils.get_function_source(noop)
|
2014-06-12 13:39:26 -03:00
|
|
|
self.assertEqual(repr(h),
|
2014-07-10 17:32:58 -03:00
|
|
|
'<Handle noop(1, 2) at %s:%s>'
|
|
|
|
% (filename, lineno))
|
2014-06-12 13:39:26 -03:00
|
|
|
|
|
|
|
# cancelled handle
|
|
|
|
h.cancel()
|
|
|
|
self.assertEqual(repr(h),
|
2014-07-10 17:32:58 -03:00
|
|
|
'<Handle cancelled>')
|
2014-06-12 13:39:26 -03:00
|
|
|
|
|
|
|
# decorated function
|
|
|
|
cb = asyncio.coroutine(noop)
|
|
|
|
h = asyncio.Handle(cb, (), self.loop)
|
|
|
|
self.assertEqual(repr(h),
|
2014-07-10 17:32:58 -03:00
|
|
|
'<Handle noop() at %s:%s>'
|
|
|
|
% (filename, lineno))
|
2014-06-12 13:39:26 -03:00
|
|
|
|
|
|
|
# partial function
|
2014-06-25 16:41:58 -03:00
|
|
|
cb = functools.partial(noop, 1, 2)
|
|
|
|
h = asyncio.Handle(cb, (3,), self.loop)
|
|
|
|
regex = (r'^<Handle noop\(1, 2\)\(3\) at %s:%s>$'
|
|
|
|
% (re.escape(filename), lineno))
|
2014-06-12 13:39:26 -03:00
|
|
|
self.assertRegex(repr(h), regex)
|
|
|
|
|
2016-09-15 16:58:15 -03:00
|
|
|
# partial function with keyword args
|
|
|
|
cb = functools.partial(noop, x=1)
|
|
|
|
h = asyncio.Handle(cb, (2, 3), self.loop)
|
|
|
|
regex = (r'^<Handle noop\(x=1\)\(2, 3\) at %s:%s>$'
|
|
|
|
% (re.escape(filename), lineno))
|
|
|
|
self.assertRegex(repr(h), regex)
|
|
|
|
|
2014-06-12 13:39:26 -03:00
|
|
|
# partial method
|
|
|
|
if sys.version_info >= (3, 4):
|
2014-06-25 16:41:58 -03:00
|
|
|
method = HandleTests.test_handle_repr
|
2014-06-12 13:39:26 -03:00
|
|
|
cb = functools.partialmethod(method)
|
2014-07-10 17:32:58 -03:00
|
|
|
filename, lineno = test_utils.get_function_source(method)
|
2014-06-12 13:39:26 -03:00
|
|
|
h = asyncio.Handle(cb, (), self.loop)
|
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
cb_regex = r'<function HandleTests.test_handle_repr .*>'
|
|
|
|
cb_regex = (r'functools.partialmethod\(%s, , \)\(\)' % cb_regex)
|
|
|
|
regex = (r'^<Handle %s at %s:%s>$'
|
|
|
|
% (cb_regex, re.escape(filename), lineno))
|
2014-06-12 13:39:26 -03:00
|
|
|
self.assertRegex(repr(h), regex)
|
|
|
|
|
2014-07-10 17:32:58 -03:00
|
|
|
def test_handle_repr_debug(self):
|
|
|
|
self.loop.get_debug.return_value = True
|
|
|
|
|
|
|
|
# simple function
|
|
|
|
create_filename = __file__
|
|
|
|
create_lineno = sys._getframe().f_lineno + 1
|
|
|
|
h = asyncio.Handle(noop, (1, 2), self.loop)
|
|
|
|
filename, lineno = test_utils.get_function_source(noop)
|
|
|
|
self.assertEqual(repr(h),
|
|
|
|
'<Handle noop(1, 2) at %s:%s created at %s:%s>'
|
|
|
|
% (filename, lineno, create_filename, create_lineno))
|
|
|
|
|
|
|
|
# cancelled handle
|
|
|
|
h.cancel()
|
2014-09-25 13:07:56 -03:00
|
|
|
self.assertEqual(
|
|
|
|
repr(h),
|
|
|
|
'<Handle cancelled noop(1, 2) at %s:%s created at %s:%s>'
|
|
|
|
% (filename, lineno, create_filename, create_lineno))
|
|
|
|
|
|
|
|
# double cancellation won't overwrite _repr
|
|
|
|
h.cancel()
|
|
|
|
self.assertEqual(
|
|
|
|
repr(h),
|
|
|
|
'<Handle cancelled noop(1, 2) at %s:%s created at %s:%s>'
|
|
|
|
% (filename, lineno, create_filename, create_lineno))
|
2014-07-10 17:32:58 -03:00
|
|
|
|
2014-06-27 08:52:20 -03:00
|
|
|
def test_handle_source_traceback(self):
|
|
|
|
loop = asyncio.get_event_loop_policy().new_event_loop()
|
|
|
|
loop.set_debug(True)
|
|
|
|
self.set_event_loop(loop)
|
|
|
|
|
|
|
|
def check_source_traceback(h):
|
|
|
|
lineno = sys._getframe(1).f_lineno - 1
|
|
|
|
self.assertIsInstance(h._source_traceback, list)
|
|
|
|
self.assertEqual(h._source_traceback[-1][:3],
|
|
|
|
(__file__,
|
|
|
|
lineno,
|
|
|
|
'test_handle_source_traceback'))
|
|
|
|
|
|
|
|
# call_soon
|
|
|
|
h = loop.call_soon(noop)
|
|
|
|
check_source_traceback(h)
|
|
|
|
|
|
|
|
# call_soon_threadsafe
|
|
|
|
h = loop.call_soon_threadsafe(noop)
|
|
|
|
check_source_traceback(h)
|
|
|
|
|
|
|
|
# call_later
|
|
|
|
h = loop.call_later(0, noop)
|
|
|
|
check_source_traceback(h)
|
|
|
|
|
|
|
|
# call_at
|
|
|
|
h = loop.call_later(0, noop)
|
|
|
|
check_source_traceback(h)
|
|
|
|
|
2016-10-05 20:32:49 -03:00
|
|
|
@unittest.skipUnless(hasattr(collections.abc, 'Coroutine'),
|
|
|
|
'No collections.abc.Coroutine')
|
|
|
|
def test_coroutine_like_object_debug_formatting(self):
|
|
|
|
# Test that asyncio can format coroutines that are instances of
|
|
|
|
# collections.abc.Coroutine, but lack cr_core or gi_code attributes
|
|
|
|
# (such as ones compiled with Cython).
|
|
|
|
|
2017-12-23 13:44:29 -04:00
|
|
|
coro = CoroLike()
|
2016-11-08 20:16:01 -04:00
|
|
|
coro.__name__ = 'AAA'
|
2016-10-05 20:32:49 -03:00
|
|
|
self.assertTrue(asyncio.iscoroutine(coro))
|
|
|
|
self.assertEqual(coroutines._format_coroutine(coro), 'AAA()')
|
|
|
|
|
|
|
|
coro.__qualname__ = 'BBB'
|
|
|
|
self.assertEqual(coroutines._format_coroutine(coro), 'BBB()')
|
|
|
|
|
|
|
|
coro.cr_running = True
|
|
|
|
self.assertEqual(coroutines._format_coroutine(coro), 'BBB() running')
|
|
|
|
|
2018-05-28 19:31:07 -03:00
|
|
|
coro.__name__ = coro.__qualname__ = None
|
|
|
|
self.assertEqual(coroutines._format_coroutine(coro),
|
|
|
|
'<CoroLike without __name__>() running')
|
|
|
|
|
2017-12-23 13:44:29 -04:00
|
|
|
coro = CoroLike()
|
2018-05-28 19:31:07 -03:00
|
|
|
coro.__qualname__ = 'CoroLike'
|
2016-11-08 20:16:01 -04:00
|
|
|
# Some coroutines might not have '__name__', such as
|
|
|
|
# built-in async_gen.asend().
|
2017-12-23 13:44:29 -04:00
|
|
|
self.assertEqual(coroutines._format_coroutine(coro), 'CoroLike()')
|
2016-11-08 20:16:01 -04:00
|
|
|
|
2018-05-28 19:31:07 -03:00
|
|
|
coro = CoroLike()
|
|
|
|
coro.__qualname__ = 'AAA'
|
|
|
|
coro.cr_code = None
|
|
|
|
self.assertEqual(coroutines._format_coroutine(coro), 'AAA()')
|
|
|
|
|
2014-06-12 13:39:26 -03:00
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
class TimerTests(unittest.TestCase):
|
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
def setUp(self):
|
2016-11-04 15:29:28 -03:00
|
|
|
super().setUp()
|
2014-06-25 16:41:58 -03:00
|
|
|
self.loop = mock.Mock()
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_hash(self):
|
|
|
|
when = time.monotonic()
|
2014-02-18 19:02:19 -04:00
|
|
|
h = asyncio.TimerHandle(when, lambda: False, (),
|
2014-02-26 05:25:02 -04:00
|
|
|
mock.Mock())
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertEqual(hash(h), hash(when))
|
|
|
|
|
2018-02-01 15:56:03 -04:00
|
|
|
def test_when(self):
|
|
|
|
when = time.monotonic()
|
|
|
|
h = asyncio.TimerHandle(when, lambda: False, (),
|
|
|
|
mock.Mock())
|
|
|
|
self.assertEqual(when, h.when())
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_timer(self):
|
|
|
|
def callback(*args):
|
|
|
|
return args
|
|
|
|
|
2014-07-10 17:32:58 -03:00
|
|
|
args = (1, 2, 3)
|
2013-10-17 17:40:50 -03:00
|
|
|
when = time.monotonic()
|
2014-02-26 05:25:02 -04:00
|
|
|
h = asyncio.TimerHandle(when, callback, args, mock.Mock())
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIs(h._callback, callback)
|
|
|
|
self.assertIs(h._args, args)
|
2017-11-07 05:06:05 -04:00
|
|
|
self.assertFalse(h.cancelled())
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
# cancel
|
2013-10-17 17:40:50 -03:00
|
|
|
h.cancel()
|
2017-11-07 05:06:05 -04:00
|
|
|
self.assertTrue(h.cancelled())
|
2014-07-10 17:32:58 -03:00
|
|
|
self.assertIsNone(h._callback)
|
|
|
|
self.assertIsNone(h._args)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
# when cannot be None
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertRaises(AssertionError,
|
2014-02-18 19:02:19 -04:00
|
|
|
asyncio.TimerHandle, None, callback, args,
|
2014-06-25 16:41:58 -03:00
|
|
|
self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
def test_timer_repr(self):
|
2014-07-10 17:32:58 -03:00
|
|
|
self.loop.get_debug.return_value = False
|
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
# simple function
|
|
|
|
h = asyncio.TimerHandle(123, noop, (), self.loop)
|
|
|
|
src = test_utils.get_function_source(noop)
|
|
|
|
self.assertEqual(repr(h),
|
|
|
|
'<TimerHandle when=123 noop() at %s:%s>' % src)
|
2014-02-18 19:02:19 -04:00
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
# cancelled handle
|
|
|
|
h.cancel()
|
|
|
|
self.assertEqual(repr(h),
|
2014-07-10 17:32:58 -03:00
|
|
|
'<TimerHandle cancelled when=123>')
|
|
|
|
|
|
|
|
def test_timer_repr_debug(self):
|
|
|
|
self.loop.get_debug.return_value = True
|
|
|
|
|
|
|
|
# simple function
|
|
|
|
create_filename = __file__
|
|
|
|
create_lineno = sys._getframe().f_lineno + 1
|
|
|
|
h = asyncio.TimerHandle(123, noop, (), self.loop)
|
|
|
|
filename, lineno = test_utils.get_function_source(noop)
|
|
|
|
self.assertEqual(repr(h),
|
|
|
|
'<TimerHandle when=123 noop() '
|
|
|
|
'at %s:%s created at %s:%s>'
|
|
|
|
% (filename, lineno, create_filename, create_lineno))
|
|
|
|
|
|
|
|
# cancelled handle
|
|
|
|
h.cancel()
|
|
|
|
self.assertEqual(repr(h),
|
2014-09-17 18:24:13 -03:00
|
|
|
'<TimerHandle cancelled when=123 noop() '
|
|
|
|
'at %s:%s created at %s:%s>'
|
|
|
|
% (filename, lineno, create_filename, create_lineno))
|
2014-07-10 17:32:58 -03:00
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
|
|
|
|
def test_timer_comparison(self):
|
2013-10-17 17:40:50 -03:00
|
|
|
def callback(*args):
|
|
|
|
return args
|
|
|
|
|
|
|
|
when = time.monotonic()
|
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
h1 = asyncio.TimerHandle(when, callback, (), self.loop)
|
|
|
|
h2 = asyncio.TimerHandle(when, callback, (), self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
# TODO: Use assertLess etc.
|
|
|
|
self.assertFalse(h1 < h2)
|
|
|
|
self.assertFalse(h2 < h1)
|
|
|
|
self.assertTrue(h1 <= h2)
|
|
|
|
self.assertTrue(h2 <= h1)
|
|
|
|
self.assertFalse(h1 > h2)
|
|
|
|
self.assertFalse(h2 > h1)
|
|
|
|
self.assertTrue(h1 >= h2)
|
|
|
|
self.assertTrue(h2 >= h1)
|
|
|
|
self.assertTrue(h1 == h2)
|
|
|
|
self.assertFalse(h1 != h2)
|
|
|
|
|
|
|
|
h2.cancel()
|
|
|
|
self.assertFalse(h1 == h2)
|
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
h1 = asyncio.TimerHandle(when, callback, (), self.loop)
|
|
|
|
h2 = asyncio.TimerHandle(when + 10.0, callback, (), self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertTrue(h1 < h2)
|
|
|
|
self.assertFalse(h2 < h1)
|
|
|
|
self.assertTrue(h1 <= h2)
|
|
|
|
self.assertFalse(h2 <= h1)
|
|
|
|
self.assertFalse(h1 > h2)
|
|
|
|
self.assertTrue(h2 > h1)
|
|
|
|
self.assertFalse(h1 >= h2)
|
|
|
|
self.assertTrue(h2 >= h1)
|
|
|
|
self.assertFalse(h1 == h2)
|
|
|
|
self.assertTrue(h1 != h2)
|
|
|
|
|
2014-06-25 16:41:58 -03:00
|
|
|
h3 = asyncio.Handle(callback, (), self.loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIs(NotImplemented, h1.__eq__(h3))
|
|
|
|
self.assertIs(NotImplemented, h1.__ne__(h3))
|
|
|
|
|
|
|
|
|
|
|
|
class AbstractEventLoopTests(unittest.TestCase):
|
|
|
|
|
|
|
|
def test_not_implemented(self):
|
2014-02-26 05:25:02 -04:00
|
|
|
f = mock.Mock()
|
2014-01-25 10:32:06 -04:00
|
|
|
loop = asyncio.AbstractEventLoop()
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.run_forever)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.run_until_complete, None)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.stop)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.is_running)
|
2014-07-08 06:29:25 -03:00
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.is_closed)
|
2013-11-01 18:19:04 -03:00
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.close)
|
2014-07-08 06:29:25 -03:00
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.create_task, None)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.call_later, None, None)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.call_at, f, f)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.call_soon, None)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.time)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.call_soon_threadsafe, None)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.set_default_executor, f)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.add_reader, 1, f)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.remove_reader, 1)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.add_writer, 1, f)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.remove_writer, 1)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.add_signal_handler, 1, f)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.remove_signal_handler, 1)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.remove_signal_handler, 1)
|
2014-07-08 06:29:25 -03:00
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.set_exception_handler, f)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.default_exception_handler, f)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.call_exception_handler, f)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.get_debug)
|
|
|
|
self.assertRaises(
|
|
|
|
NotImplementedError, loop.set_debug, f)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2017-12-08 18:23:48 -04:00
|
|
|
def test_not_implemented_async(self):
|
|
|
|
|
|
|
|
async def inner():
|
|
|
|
f = mock.Mock()
|
|
|
|
loop = asyncio.AbstractEventLoop()
|
|
|
|
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.run_in_executor(f, f)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.getaddrinfo('localhost', 8080)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.getnameinfo(('localhost', 8080))
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.create_connection(f)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.create_server(f)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.create_datagram_endpoint(f)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.sock_recv(f, 10)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.sock_recv_into(f, 10)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.sock_sendall(f, 10)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.sock_connect(f, f)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.sock_accept(f)
|
2018-01-16 13:59:34 -04:00
|
|
|
with self.assertRaises(NotImplementedError):
|
2018-01-27 15:22:47 -04:00
|
|
|
await loop.sock_sendfile(f, f)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.sendfile(f, f)
|
2017-12-08 18:23:48 -04:00
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.connect_read_pipe(f, mock.sentinel.pipe)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.connect_write_pipe(f, mock.sentinel.pipe)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.subprocess_shell(f, mock.sentinel)
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
await loop.subprocess_exec(f)
|
|
|
|
|
|
|
|
loop = asyncio.new_event_loop()
|
|
|
|
loop.run_until_complete(inner())
|
|
|
|
loop.close()
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
class ProtocolsAbsTests(unittest.TestCase):
|
|
|
|
|
|
|
|
def test_empty(self):
|
2014-02-26 05:25:02 -04:00
|
|
|
f = mock.Mock()
|
2014-01-25 10:32:06 -04:00
|
|
|
p = asyncio.Protocol()
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIsNone(p.connection_made(f))
|
|
|
|
self.assertIsNone(p.connection_lost(f))
|
|
|
|
self.assertIsNone(p.data_received(f))
|
|
|
|
self.assertIsNone(p.eof_received())
|
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
dp = asyncio.DatagramProtocol()
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIsNone(dp.connection_made(f))
|
|
|
|
self.assertIsNone(dp.connection_lost(f))
|
2013-11-15 20:51:48 -04:00
|
|
|
self.assertIsNone(dp.error_received(f))
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIsNone(dp.datagram_received(f, f))
|
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
sp = asyncio.SubprocessProtocol()
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIsNone(sp.connection_made(f))
|
|
|
|
self.assertIsNone(sp.connection_lost(f))
|
|
|
|
self.assertIsNone(sp.pipe_data_received(1, f))
|
|
|
|
self.assertIsNone(sp.pipe_connection_lost(1, f))
|
|
|
|
self.assertIsNone(sp.process_exited())
|
|
|
|
|
|
|
|
|
|
|
|
class PolicyTests(unittest.TestCase):
|
|
|
|
|
|
|
|
def test_event_loop_policy(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
policy = asyncio.AbstractEventLoopPolicy()
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertRaises(NotImplementedError, policy.get_event_loop)
|
|
|
|
self.assertRaises(NotImplementedError, policy.set_event_loop, object())
|
|
|
|
self.assertRaises(NotImplementedError, policy.new_event_loop)
|
2013-11-04 19:50:46 -04:00
|
|
|
self.assertRaises(NotImplementedError, policy.get_child_watcher)
|
|
|
|
self.assertRaises(NotImplementedError, policy.set_child_watcher,
|
|
|
|
object())
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_get_event_loop(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
policy = asyncio.DefaultEventLoopPolicy()
|
2013-11-04 19:50:46 -04:00
|
|
|
self.assertIsNone(policy._local._loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
loop = policy.get_event_loop()
|
2014-01-25 10:32:06 -04:00
|
|
|
self.assertIsInstance(loop, asyncio.AbstractEventLoop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2013-11-04 19:50:46 -04:00
|
|
|
self.assertIs(policy._local._loop, loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIs(loop, policy.get_event_loop())
|
|
|
|
loop.close()
|
|
|
|
|
2013-11-27 14:37:13 -04:00
|
|
|
def test_get_event_loop_calls_set_event_loop(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
policy = asyncio.DefaultEventLoopPolicy()
|
2013-11-27 14:37:13 -04:00
|
|
|
|
2014-02-26 05:25:02 -04:00
|
|
|
with mock.patch.object(
|
2013-11-27 14:37:13 -04:00
|
|
|
policy, "set_event_loop",
|
|
|
|
wraps=policy.set_event_loop) as m_set_event_loop:
|
|
|
|
|
|
|
|
loop = policy.get_event_loop()
|
|
|
|
|
|
|
|
# policy._local._loop must be set through .set_event_loop()
|
|
|
|
# (the unix DefaultEventLoopPolicy needs this call to attach
|
|
|
|
# the child watcher correctly)
|
|
|
|
m_set_event_loop.assert_called_with(loop)
|
|
|
|
|
|
|
|
loop.close()
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_get_event_loop_after_set_none(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
policy = asyncio.DefaultEventLoopPolicy()
|
2013-10-17 17:40:50 -03:00
|
|
|
policy.set_event_loop(None)
|
2014-12-17 20:20:10 -04:00
|
|
|
self.assertRaises(RuntimeError, policy.get_event_loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-02-26 05:25:02 -04:00
|
|
|
@mock.patch('asyncio.events.threading.current_thread')
|
2013-10-17 17:40:50 -03:00
|
|
|
def test_get_event_loop_thread(self, m_current_thread):
|
|
|
|
|
|
|
|
def f():
|
2014-01-25 10:32:06 -04:00
|
|
|
policy = asyncio.DefaultEventLoopPolicy()
|
2014-12-17 20:20:10 -04:00
|
|
|
self.assertRaises(RuntimeError, policy.get_event_loop)
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
th = threading.Thread(target=f)
|
|
|
|
th.start()
|
|
|
|
th.join()
|
|
|
|
|
|
|
|
def test_new_event_loop(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
policy = asyncio.DefaultEventLoopPolicy()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
loop = policy.new_event_loop()
|
2014-01-25 10:32:06 -04:00
|
|
|
self.assertIsInstance(loop, asyncio.AbstractEventLoop)
|
2013-10-17 17:40:50 -03:00
|
|
|
loop.close()
|
|
|
|
|
|
|
|
def test_set_event_loop(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
policy = asyncio.DefaultEventLoopPolicy()
|
2013-10-17 17:40:50 -03:00
|
|
|
old_loop = policy.get_event_loop()
|
|
|
|
|
|
|
|
self.assertRaises(AssertionError, policy.set_event_loop, object())
|
|
|
|
|
|
|
|
loop = policy.new_event_loop()
|
|
|
|
policy.set_event_loop(loop)
|
|
|
|
self.assertIs(loop, policy.get_event_loop())
|
|
|
|
self.assertIsNot(old_loop, policy.get_event_loop())
|
|
|
|
loop.close()
|
|
|
|
old_loop.close()
|
|
|
|
|
|
|
|
def test_get_event_loop_policy(self):
|
2014-01-25 10:32:06 -04:00
|
|
|
policy = asyncio.get_event_loop_policy()
|
|
|
|
self.assertIsInstance(policy, asyncio.AbstractEventLoopPolicy)
|
|
|
|
self.assertIs(policy, asyncio.get_event_loop_policy())
|
2013-10-17 17:40:50 -03:00
|
|
|
|
|
|
|
def test_set_event_loop_policy(self):
|
|
|
|
self.assertRaises(
|
2014-01-25 10:32:06 -04:00
|
|
|
AssertionError, asyncio.set_event_loop_policy, object())
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
old_policy = asyncio.get_event_loop_policy()
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2014-01-25 10:32:06 -04:00
|
|
|
policy = asyncio.DefaultEventLoopPolicy()
|
|
|
|
asyncio.set_event_loop_policy(policy)
|
|
|
|
self.assertIs(policy, asyncio.get_event_loop_policy())
|
2013-10-17 17:40:50 -03:00
|
|
|
self.assertIsNot(policy, old_policy)
|
|
|
|
|
2017-12-13 15:49:42 -04:00
|
|
|
|
|
|
|
class GetEventLoopTestsMixin:
|
|
|
|
|
|
|
|
_get_running_loop_impl = None
|
|
|
|
_set_running_loop_impl = None
|
|
|
|
get_running_loop_impl = None
|
|
|
|
get_event_loop_impl = None
|
|
|
|
|
|
|
|
def setUp(self):
|
|
|
|
self._get_running_loop_saved = events._get_running_loop
|
|
|
|
self._set_running_loop_saved = events._set_running_loop
|
|
|
|
self.get_running_loop_saved = events.get_running_loop
|
|
|
|
self.get_event_loop_saved = events.get_event_loop
|
|
|
|
|
|
|
|
events._get_running_loop = type(self)._get_running_loop_impl
|
|
|
|
events._set_running_loop = type(self)._set_running_loop_impl
|
|
|
|
events.get_running_loop = type(self).get_running_loop_impl
|
|
|
|
events.get_event_loop = type(self).get_event_loop_impl
|
|
|
|
|
|
|
|
asyncio._get_running_loop = type(self)._get_running_loop_impl
|
|
|
|
asyncio._set_running_loop = type(self)._set_running_loop_impl
|
|
|
|
asyncio.get_running_loop = type(self).get_running_loop_impl
|
|
|
|
asyncio.get_event_loop = type(self).get_event_loop_impl
|
|
|
|
|
|
|
|
super().setUp()
|
|
|
|
|
|
|
|
self.loop = asyncio.new_event_loop()
|
|
|
|
asyncio.set_event_loop(self.loop)
|
|
|
|
|
2017-12-13 18:28:41 -04:00
|
|
|
if sys.platform != 'win32':
|
|
|
|
watcher = asyncio.SafeChildWatcher()
|
|
|
|
watcher.attach_loop(self.loop)
|
|
|
|
asyncio.set_child_watcher(watcher)
|
2017-12-13 15:49:42 -04:00
|
|
|
|
|
|
|
def tearDown(self):
|
|
|
|
try:
|
2017-12-13 18:28:41 -04:00
|
|
|
if sys.platform != 'win32':
|
|
|
|
asyncio.set_child_watcher(None)
|
|
|
|
|
2017-12-13 15:49:42 -04:00
|
|
|
super().tearDown()
|
|
|
|
finally:
|
|
|
|
self.loop.close()
|
|
|
|
asyncio.set_event_loop(None)
|
|
|
|
|
|
|
|
events._get_running_loop = self._get_running_loop_saved
|
|
|
|
events._set_running_loop = self._set_running_loop_saved
|
|
|
|
events.get_running_loop = self.get_running_loop_saved
|
|
|
|
events.get_event_loop = self.get_event_loop_saved
|
|
|
|
|
|
|
|
asyncio._get_running_loop = self._get_running_loop_saved
|
|
|
|
asyncio._set_running_loop = self._set_running_loop_saved
|
|
|
|
asyncio.get_running_loop = self.get_running_loop_saved
|
|
|
|
asyncio.get_event_loop = self.get_event_loop_saved
|
|
|
|
|
|
|
|
if sys.platform != 'win32':
|
|
|
|
|
|
|
|
def test_get_event_loop_new_process(self):
|
|
|
|
# Issue bpo-32126: The multiprocessing module used by
|
|
|
|
# ProcessPoolExecutor is not functional when the
|
|
|
|
# multiprocessing.synchronize module cannot be imported.
|
|
|
|
support.import_module('multiprocessing.synchronize')
|
|
|
|
|
|
|
|
async def main():
|
|
|
|
pool = concurrent.futures.ProcessPoolExecutor()
|
|
|
|
result = await self.loop.run_in_executor(
|
|
|
|
pool, _test_get_event_loop_new_process__sub_proc)
|
|
|
|
pool.shutdown()
|
|
|
|
return result
|
|
|
|
|
|
|
|
self.assertEqual(
|
|
|
|
self.loop.run_until_complete(main()),
|
|
|
|
'hello')
|
|
|
|
|
2016-11-04 15:29:28 -03:00
|
|
|
def test_get_event_loop_returns_running_loop(self):
|
2017-12-13 15:49:42 -04:00
|
|
|
class TestError(Exception):
|
|
|
|
pass
|
|
|
|
|
2016-11-04 15:29:28 -03:00
|
|
|
class Policy(asyncio.DefaultEventLoopPolicy):
|
|
|
|
def get_event_loop(self):
|
2017-12-13 15:49:42 -04:00
|
|
|
raise TestError
|
2016-11-04 15:29:28 -03:00
|
|
|
|
|
|
|
old_policy = asyncio.get_event_loop_policy()
|
|
|
|
try:
|
|
|
|
asyncio.set_event_loop_policy(Policy())
|
|
|
|
loop = asyncio.new_event_loop()
|
2017-12-13 15:49:42 -04:00
|
|
|
|
|
|
|
with self.assertRaises(TestError):
|
|
|
|
asyncio.get_event_loop()
|
|
|
|
asyncio.set_event_loop(None)
|
|
|
|
with self.assertRaises(TestError):
|
|
|
|
asyncio.get_event_loop()
|
|
|
|
|
2017-12-11 11:07:44 -04:00
|
|
|
with self.assertRaisesRegex(RuntimeError, 'no running'):
|
|
|
|
self.assertIs(asyncio.get_running_loop(), None)
|
2016-11-07 20:00:46 -04:00
|
|
|
self.assertIs(asyncio._get_running_loop(), None)
|
2016-11-04 15:29:28 -03:00
|
|
|
|
|
|
|
async def func():
|
|
|
|
self.assertIs(asyncio.get_event_loop(), loop)
|
2017-12-11 11:07:44 -04:00
|
|
|
self.assertIs(asyncio.get_running_loop(), loop)
|
2016-11-07 20:00:46 -04:00
|
|
|
self.assertIs(asyncio._get_running_loop(), loop)
|
2016-11-04 15:29:28 -03:00
|
|
|
|
|
|
|
loop.run_until_complete(func())
|
2017-12-13 15:49:42 -04:00
|
|
|
|
|
|
|
asyncio.set_event_loop(loop)
|
|
|
|
with self.assertRaises(TestError):
|
|
|
|
asyncio.get_event_loop()
|
|
|
|
|
|
|
|
asyncio.set_event_loop(None)
|
|
|
|
with self.assertRaises(TestError):
|
|
|
|
asyncio.get_event_loop()
|
|
|
|
|
2016-11-04 15:29:28 -03:00
|
|
|
finally:
|
|
|
|
asyncio.set_event_loop_policy(old_policy)
|
|
|
|
if loop is not None:
|
|
|
|
loop.close()
|
|
|
|
|
2017-12-11 11:07:44 -04:00
|
|
|
with self.assertRaisesRegex(RuntimeError, 'no running'):
|
|
|
|
self.assertIs(asyncio.get_running_loop(), None)
|
|
|
|
|
2016-11-07 20:00:46 -04:00
|
|
|
self.assertIs(asyncio._get_running_loop(), None)
|
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
|
2017-12-13 15:49:42 -04:00
|
|
|
class TestPyGetEventLoop(GetEventLoopTestsMixin, unittest.TestCase):
|
|
|
|
|
|
|
|
_get_running_loop_impl = events._py__get_running_loop
|
|
|
|
_set_running_loop_impl = events._py__set_running_loop
|
|
|
|
get_running_loop_impl = events._py_get_running_loop
|
|
|
|
get_event_loop_impl = events._py_get_event_loop
|
|
|
|
|
|
|
|
|
|
|
|
try:
|
|
|
|
import _asyncio # NoQA
|
|
|
|
except ImportError:
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
|
|
|
|
class TestCGetEventLoop(GetEventLoopTestsMixin, unittest.TestCase):
|
|
|
|
|
|
|
|
_get_running_loop_impl = events._c__get_running_loop
|
|
|
|
_set_running_loop_impl = events._c__set_running_loop
|
|
|
|
get_running_loop_impl = events._c_get_running_loop
|
|
|
|
get_event_loop_impl = events._c_get_event_loop
|
|
|
|
|
2017-12-30 12:52:56 -04:00
|
|
|
|
2017-12-30 11:09:32 -04:00
|
|
|
class TestServer(unittest.TestCase):
|
|
|
|
|
|
|
|
def test_get_loop(self):
|
|
|
|
loop = asyncio.new_event_loop()
|
2017-12-30 12:52:56 -04:00
|
|
|
self.addCleanup(loop.close)
|
2017-12-30 11:09:32 -04:00
|
|
|
proto = MyProto(loop)
|
|
|
|
server = loop.run_until_complete(loop.create_server(lambda: proto, '0.0.0.0', 0))
|
|
|
|
self.assertEqual(server.get_loop(), loop)
|
2017-12-30 12:52:56 -04:00
|
|
|
server.close()
|
|
|
|
loop.run_until_complete(server.wait_closed())
|
|
|
|
|
2017-12-30 11:09:32 -04:00
|
|
|
|
|
|
|
class TestAbstractServer(unittest.TestCase):
|
|
|
|
|
2017-12-30 12:52:56 -04:00
|
|
|
def test_close(self):
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
events.AbstractServer().close()
|
|
|
|
|
|
|
|
def test_wait_closed(self):
|
|
|
|
loop = asyncio.new_event_loop()
|
|
|
|
self.addCleanup(loop.close)
|
|
|
|
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
loop.run_until_complete(events.AbstractServer().wait_closed())
|
|
|
|
|
2017-12-30 11:09:32 -04:00
|
|
|
def test_get_loop(self):
|
2017-12-30 12:52:56 -04:00
|
|
|
with self.assertRaises(NotImplementedError):
|
|
|
|
events.AbstractServer().get_loop()
|
|
|
|
|
2017-12-13 15:49:42 -04:00
|
|
|
|
2013-10-17 17:40:50 -03:00
|
|
|
if __name__ == '__main__':
|
|
|
|
unittest.main()
|