async def test_client(addr):
t, p = await self.loop.create_connection(
lambda: asyncio.Protocol(), *addr)
if hasattr(t, 'get_protocol'):
p2 = asyncio.Protocol()
self.assertIs(t.get_protocol(), p)
t.set_protocol(p2)
self.assertIs(t.get_protocol(), p2)
t.set_protocol(p)
self.assertFalse(t._paused)
self.assertTrue(t.is_reading())
t.pause_reading()
t.pause_reading() # Check that it's OK to call it 2nd time.
self.assertTrue(t._paused)
self.assertFalse(t.is_reading())
t.resume_reading()
t.resume_reading() # Check that it's OK to call it 2nd time.
self.assertFalse(t._paused)
self.assertTrue(t.is_reading())
sock = t.get_extra_info('socket')
self.assertIs(sock, t.get_extra_info('socket'))
sockname = sock.getsockname()
peername = sock.getpeername()
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_writer(sock.fileno(), lambda: None)
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_writer(sock.fileno())
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_reader(sock.fileno(), lambda: None)
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_reader(sock.fileno())
self.assertTrue(isinstance(sock, socket.socket))
self.assertEqual(t.get_extra_info('sockname'), sockname)
self.assertEqual(t.get_extra_info('peername'), peername)
t.write(b'OK') # We want server to fail.
self.assertFalse(t._closing)
t.abort()
self.assertTrue(t._closing)
self.assertFalse(t.is_reading())
# Check that pause_reading and resume_reading don't raise
# errors if called after the transport is closed.
t.pause_reading()
t.resume_reading()
await fut
# Test that peername and sockname are available after
# the transport is closed.
self.assertEqual(t.get_extra_info('peername'), peername)
self.assertEqual(t.get_extra_info('sockname'), sockname)
def test_cancel_handshake(self):
# Python issue #23197: cancelling an handshake must not raise an
# exception or log an error, even if the handshake failed
sslcontext = test_utils.dummy_ssl_context()
app_proto = asyncio.Protocol()
waiter = asyncio.Future(loop=self.loop)
ssl_proto = sslproto.SSLProtocol(self.loop, app_proto, sslcontext,
waiter)
handshake_fut = asyncio.Future(loop=self.loop)
def do_handshake(callback):
exc = Exception()
callback(exc)
handshake_fut.set_result(None)
return []
waiter.cancel()
transport = mock.Mock()
sslpipe = mock.Mock()
sslpipe.shutdown.return_value = b''
sslpipe.do_handshake.side_effect = do_handshake
with mock.patch('asyncio.sslproto._SSLPipe', return_value=sslpipe):
ssl_proto.connection_made(transport)
with test_utils.disable_logger():
self.loop.run_until_complete(handshake_fut)
# Close the transport
ssl_proto._app_transport.close()
async def check_server_running(loop, *, live_reload, check_errors=False):
port_open = False
for i in range(50):
try:
await loop.create_connection(lambda: asyncio.Protocol(),
host='localhost',
port=8000)
except OSError:
await asyncio.sleep(0.1, loop=loop)
else:
port_open = True
break
assert port_open
async with aiohttp.ClientSession(loop=loop) as session:
async with session.get('http://localhost:8000/') as r:
assert r.status == 200
assert r.headers['content-type'].startswith('text/html')
text = await r.text()
assert '<h1>hello world</h1>' in text
if live_reload:
assert '<script src="http://localhost:8001/livereload.js"></script>' in text
else:
assert '<script src="http://localhost:8001/livereload.js"></script>' not in text
if check_errors:
async with session.get('http://localhost:8000/error') as r:
assert r.status == 500
assert 'raise ValueError()' in (await r.text())
def ssl_protocol(self, waiter=None):
sslcontext = test_utils.dummy_ssl_context()
app_proto = asyncio.Protocol()
proto = sslproto.SSLProtocol(self.loop, app_proto, sslcontext, waiter)
self.assertIs(proto._app_transport.get_protocol(), app_proto)
self.addCleanup(proto._app_transport.close)
return proto
def _test_connection(self, timeout=60):
self._connection_addr = None
loop = asyncio.new_event_loop()
pf = lambda: asyncio.Protocol()
try:
for i in range(timeout):
try:
tr, pr = loop.run_until_complete(
loop.create_connection(pf,
host='localhost',
port=self._effective_port))
except (OSError, asyncio.TimeoutError):
time.sleep(1)
continue
else:
tr.close()
loop.run_until_complete(asyncio.sleep(0, loop=loop))
break
else:
raise ClusterError(
f'could not connect to edgedb-server within {timeout}s')
finally:
loop.close()
return 'running'
async def runner():
tr, pr = await self.loop.create_connection(
lambda: asyncio.Protocol(), sock=rsock)
try:
cb = lambda: None
sock = tr.get_extra_info('socket')
with assert_raises():
self.loop.add_reader(sock, cb)
with assert_raises():
self.loop.add_reader(sock.fileno(), cb)
with assert_raises():
self.loop.remove_reader(sock)
with assert_raises():
self.loop.remove_reader(sock.fileno())
with assert_raises():
self.loop.add_writer(sock, cb)
with assert_raises():
self.loop.add_writer(sock.fileno(), cb)
with assert_raises():
self.loop.remove_writer(sock)
with assert_raises():
self.loop.remove_writer(sock.fileno())
finally:
tr.close()
def test_set_new_app_protocol(self):
waiter = asyncio.Future(loop=self.loop)
ssl_proto = self.ssl_protocol(waiter)
new_app_proto = asyncio.Protocol()
ssl_proto._app_transport.set_protocol(new_app_proto)
self.assertIs(ssl_proto._app_transport.get_protocol(), new_app_proto)
self.assertIs(ssl_proto._app_protocol, new_app_proto)
async def test_client(addr):
t, p = await self.loop.create_connection(
lambda: asyncio.Protocol(), *addr)
self.assertFalse(t._paused)
t.pause_reading()
self.assertTrue(t._paused)
t.resume_reading()
self.assertFalse(t._paused)
sock = t.get_extra_info('socket')
sockname = sock.getsockname()
peername = sock.getpeername()
self.assertTrue(isinstance(sock, socket.socket))
self.assertEqual(t.get_extra_info('sockname'), sockname)
self.assertEqual(t.get_extra_info('peername'), peername)
t.write(b'OK') # We want server to fail.
self.assertFalse(t._closing)
t.abort()
self.assertTrue(t._closing)
await fut
# Test that peername and sockname are available after
# the transport is closed.
self.assertEqual(t.get_extra_info('peername'), peername)
self.assertEqual(t.get_extra_info('sockname'), sockname)
def ssl_protocol(self, *, waiter=None, proto=None):
sslcontext = test_utils.dummy_ssl_context()
if proto is None: # app protocol
proto = asyncio.Protocol()
ssl_proto = sslproto.SSLProtocol(self.loop, proto, sslcontext, waiter)
self.assertIs(ssl_proto._app_transport.get_protocol(), proto)
self.addCleanup(ssl_proto._app_transport.close)
return ssl_proto
def test_close(self):
a, b = self.loop._socketpair()
trans = self.loop._make_socket_transport(a, asyncio.Protocol())
f = asyncio. async (self.loop.sock_recv(b, 100))
trans.close()
self.loop.run_until_complete(f)
self.assertEqual(f.result(), b'')
b.close()
async def runner():
tr, pr = await self.loop.create_connection(
lambda: asyncio.Protocol(), sock=rsock)
try:
sock = tr.get_extra_info('socket')
test_pseudo(rsock, sock)
finally:
tr.close()
async def test_base_negotiate_with_app_proto(loop):
waiter = asyncio.Future(loop=loop)
proto = make_base(loop, waiter=waiter,
ap_factory=lambda: asyncio.Protocol())
proto.socks_request = make_mocked_coro((None, None))
await proto.negotiate(None, None)
await waiter
assert waiter.done()
async def connect_stdin_stdout():
loop = asyncio.get_event_loop()
reader = asyncio.StreamReader()
protocol = asyncio.StreamReaderProtocol(reader)
dummy = asyncio.Protocol()
await loop.connect_read_pipe(lambda: protocol, sys.stdin)
w_transport, _ = await loop.connect_write_pipe(lambda: dummy, sys.stdout)
writer = asyncio.StreamWriter(w_transport, protocol, reader, loop)
return reader, writer
def test_negotiate_with_app_proto(self):
waiter = asyncio.Future(loop=self.loop)
proto = make_base(self.loop,
waiter=waiter,
ap_factory=lambda: asyncio.Protocol())
proto.socks_request = fake_coroutine((None, None))
self.loop.run_until_complete(proto.negotiate(None, None))
self.assertTrue(waiter.done())
def test_protocol(self):
f = mock.Mock()
p = asyncio.Protocol()
self.assertIsNone(p.connection_made(f))
self.assertIsNone(p.connection_lost(f))
self.assertIsNone(p.data_received(f))
self.assertIsNone(p.eof_received())
self.assertIsNone(p.pause_writing())
self.assertIsNone(p.resume_writing())
self.assertFalse(hasattr(p, '__dict__'))
def test_make_socket_transport(self):
m = mock.Mock()
self.loop.add_reader = mock.Mock()
self.loop.add_reader._is_coroutine = False
transport = self.loop._make_socket_transport(m, asyncio.Protocol())
self.assertIsInstance(transport, _SelectorSocketTransport)
# Calling repr() must not fail when the event loop is closed
self.loop.close()
repr(transport)
close_transport(transport)
async def check_server_running(loop, check_callback):
port_open = False
for i in range(50):
try:
await loop.create_connection(lambda: asyncio.Protocol(), host='localhost', port=8000)
except OSError:
await asyncio.sleep(0.1, loop=loop)
else:
port_open = True
break
assert port_open
async with aiohttp.ClientSession(loop=loop) as session:
await check_callback(session)
async def _check_port_open(host, port, loop):
steps, delay = 40, 0.5
for i in range(steps):
try:
await loop.create_connection(lambda: asyncio.Protocol(),
host=host,
port=port)
except OSError:
await asyncio.sleep(delay, loop=loop)
else:
logger.info('Connected successfully to %s:%s after %0.2fs', host,
port, delay * i)
return
raise RuntimeError(
f'Unable to connect to {host}:{port} after {steps * delay}s')
async def handle_data(self):
"""handle data via stdin and stdout"""
loop = asyncio.get_running_loop()
reader = asyncio.StreamReader(loop=loop)
reader_protocol = asyncio.StreamReaderProtocol(reader, loop=loop)
await loop.connect_read_pipe(lambda: reader_protocol, sys.stdin)
writer_transport, writer_protocol = await loop.connect_write_pipe(
lambda: asyncio.Protocol(), sys.stdout)
writer = asyncio.StreamWriter(writer_transport, writer_protocol, None,
loop)
# list of item update methods, each of which should be an awaitable
itemlist = list(item.update() for item in self.items)
await asyncio.gather(self.reader(reader), self.writer(writer),
*itemlist)
async def check_port_open(port, loop, delay=1):
# the "s = socket.socket; s.bind" approach sometimes says a port is in use when it's not
# this approach replicates aiohttp so should always give the same answer
for i in range(5, 0, -1):
try:
server = await loop.create_server(asyncio.Protocol(), host=HOST, port=port)
except OSError as e:
if e.errno != 98: # pragma: no cover
raise
dft_logger.warning('port %d is already in use, waiting %d...', port, i)
await asyncio.sleep(delay, loop=loop)
else:
server.close()
await server.wait_closed()
return
raise AiohttpDevException('The port {} is already is use'.format(port))
async def test_connection(host: str,
port: int = MODBUS_PORT,
*,
timeout: int = None) -> bool:
loop = asyncio.get_running_loop()
conn_lost = asyncio.Event()
protocol = asyncio.Protocol()
protocol.connection_lost = lambda e: conn_lost.set()
try:
coro = loop.create_connection(lambda: protocol, host, port)
transport, _ = await asyncio.wait_for(coro, timeout=timeout)
except Exception:
return False
else:
transport.close()
await conn_lost.wait()
return True
def start():
logger.debug("Starting netconf tool jar: %s",
self._netconf_tool_jar)
self._netconf_tool_proc = yield from asyncio.subprocess.create_subprocess_shell(
self.test_tool_cmd,
loop=self.loop,
)
logger.debug("Started netconf tool jar (pid: %s)",
self._netconf_tool_proc.pid)
while True:
yield from asyncio.sleep(1, loop=self.loop)
try:
yield from self.loop.create_connection(
lambda: asyncio.Protocol(), self._netconf_tool_host,
self.NETCONF_TOOL_PORT)
break
except OSError as e:
logger.warning("Connection failed: %s", str(e))
async def async_wait_port_open(host, port, delay, loop):
step_size = 0.05
steps = int(delay / step_size)
start = loop.time()
for i in range(steps):
step_start = loop.time()
try:
async with timeout(step_size, loop=loop):
transport, proto = await loop.create_connection(
lambda: asyncio.Protocol(), host=host, port=port)
except (asyncio.TimeoutError, OSError):
elapsed = loop.time() - step_start
await asyncio.sleep(max(0, step_size - elapsed), loop=loop)
else:
transport.close()
logger.debug('Connected successfully to %s:%s after %0.2fs', host,
port,
loop.time() - start)
return
raise RuntimeError(
f'Unable to connect to {host}:{port} after {loop.time() - start:0.2f}s'
)
def start():
logger.info("Starting rwmain")
rwmain_cmd = self.rwmain_path + " -m " + self.manifest_path
# Launch rwmain as a session leader, so that this script is not
# killed when rwmain terminates (different process group)
self.rwmain_proc = yield from asyncio.subprocess.create_subprocess_shell(
rwmain_cmd,
loop=self.loop,
preexec_fn=os.setsid,
)
# wait till confd is accepting connections
while True:
yield from asyncio.sleep(3, loop=self.loop)
try:
yield from self.loop.create_connection(
lambda: asyncio.Protocol(),
"127.0.0.1",
"2022",
)
break
except OSError as e:
logger.warning("Connection failed: %s", str(e))
async def test_client(addr):
t, p = await self.loop.create_connection(
lambda: asyncio.Protocol(), *addr)
self.assertFalse(t._paused)
t.pause_reading()
self.assertTrue(t._paused)
t.resume_reading()
self.assertFalse(t._paused)
sock = t.get_extra_info('socket')
self.assertIs(sock, t.get_extra_info('socket'))
sockname = sock.getsockname()
peername = sock.getpeername()
# Test that adding a writer on the returned socket
# does not crash uvloop. aiohttp does that to implement
# sendfile, for instance.
self.loop.add_writer(sock.fileno(), lambda: None)
self.loop.remove_writer(sock.fileno())
self.assertTrue(isinstance(sock, socket.socket))
self.assertEqual(t.get_extra_info('sockname'), sockname)
self.assertEqual(t.get_extra_info('peername'), peername)
t.write(b'OK') # We want server to fail.
self.assertFalse(t._closing)
t.abort()
self.assertTrue(t._closing)
await fut
# Test that peername and sockname are available after
# the transport is closed.
self.assertEqual(t.get_extra_info('peername'), peername)
self.assertEqual(t.get_extra_info('sockname'), sockname)
def test_make_ssl_transport(self):
m = mock.Mock()
self.loop._add_reader = mock.Mock()
self.loop._add_reader._is_coroutine = False
self.loop._add_writer = mock.Mock()
self.loop._remove_reader = mock.Mock()
self.loop._remove_writer = mock.Mock()
waiter = asyncio.Future(loop=self.loop)
with test_utils.disable_logger():
transport = self.loop._make_ssl_transport(m, asyncio.Protocol(), m,
waiter)
with self.assertRaisesRegex(RuntimeError,
r'SSL transport.*not.*initialized'):
transport.is_reading()
# execute the handshake while the logger is disabled
# to ignore SSL handshake failure
test_utils.run_briefly(self.loop)
self.assertTrue(transport.is_reading())
transport.pause_reading()
transport.pause_reading()
self.assertFalse(transport.is_reading())
transport.resume_reading()
transport.resume_reading()
self.assertTrue(transport.is_reading())
# Sanity check
class_name = transport.__class__.__name__
self.assertIn("ssl", class_name.lower())
self.assertIn("transport", class_name.lower())
transport.close()
# execute pending callbacks to close the socket transport
test_utils.run_briefly(self.loop)
def test_make_socket_transport(self):
tr = self.loop._make_socket_transport(self.sock, asyncio.Protocol())
self.assertIsInstance(tr, _ProactorSocketTransport)
close_transport(tr)
