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)