def _run(self): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) # Related to the current thread only. self._loop = loop async def enter_stack(stack): manager = await stack.enter_async_context( AgileMeshNetworkManager(**self._amn_kwargs) ) return manager stack = AsyncExitStack() try: self._manager = loop.run_until_complete(enter_stack(stack)) self._thread_started_event.set() self._start_initialization_event.wait() self._manager.start_initialization() loop.run_forever() except Exception as e: logger.error("Uncaught exception in the AMN event loop", exc_info=True) # TODO shutdown the app? It's harmful to keep it alive at this point. # Obviously, everything is horribly broken: there's no manager # controlling the app. finally: logger.info("Shutting down AMN event loop") loop.run_until_complete(stack.aclose()) loop.run_until_complete(loop.shutdown_asyncgens()) pending = asyncio.Task.all_tasks() loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True)) loop.close()
def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) self.server = MockupDB(auto_ismaster={"maxWireVersion": 6}) self.server.run() self.server.autoresponds( Command("find", "switch_collection", namespace="topology_database"), { "cursor": { "id": 0, "firstBatch": [{ **d, "_id": i } for i, d in enumerate(TOPOLOGY_DATABASE_DATA)], } }, ) self._stack = AsyncExitStack() td = self._stack.enter_context(tempfile.TemporaryDirectory()) self.rpc_unix_sock = os.path.join(td, "l.sock") self._stack.enter_context( patch.object(settings, "REMOTE_DATABASE_MONGO_URI", self.server.uri)) self._stack.enter_context( patch.object(settings, "NEGOTIATOR_RPC_UNIX_SOCK_PATH", self.rpc_unix_sock)) self._stack.enter_context( patch("agile_mesh_network.ryu.amn_manager.OVSManager", DummyOVSManager)) self._stack.enter_context( # To avoid automatic connection to a relay. patch.object(settings, "IS_RELAY", True)) self._stack.enter_context( patch.object(events_scheduler, "RyuAppEventLoopScheduler")) self.ryu_ev_loop_scheduler = events_scheduler.RyuAppEventLoopScheduler( ) self._stack.enter_context(self.ryu_ev_loop_scheduler) async def command_cb(session, msg): assert isinstance(msg, RPCCommand) await self._rpc_command_cb(msg) self.rpc_server = self.loop.run_until_complete( self._stack.enter_async_context( RPCUnixServer(self.rpc_unix_sock, command_cb)))
async def do_run(cls, boot_info: BootInfo, event_bus: EndpointAPI) -> None: trinity_config = boot_info.trinity_config chain = chain_for_config(trinity_config, event_bus) if trinity_config.has_app_config(Eth1AppConfig): modules = initialize_eth1_modules(chain, event_bus) elif trinity_config.has_app_config(BeaconAppConfig): modules = initialize_beacon_modules(chain, event_bus) else: raise Exception("Unsupported Node Type") rpc = RPCServer(modules, chain, event_bus) # Run IPC Server ipc_server = IPCServer(rpc, boot_info.trinity_config.jsonrpc_ipc_path) services_to_exit: Tuple[BaseService, ...] = (ipc_server, ) # Run HTTP Server if boot_info.args.enable_http: http_server = HTTPServer(rpc, port=boot_info.args.rpcport) services_to_exit += (http_server, ) async with AsyncExitStack() as stack: for service in services_to_exit: await stack.enter_async_context(run_service(service)) await ipc_server.cancellation()
async def amain(args, group_config, loop): # pragma: no cover logger = logging.getLogger('MAIN') exit_event = asyncio.Event() sig_handler = partial(utils.exit_handler, exit_event) signal.signal(signal.SIGTERM, sig_handler) signal.signal(signal.SIGINT, sig_handler) beat = asyncio.ensure_future(utils.heartbeat()) mixer = crypto.StatefulHKDFEntropyMixer() nodes = [ net.Identity(I['Address'], I['Key'], I['TLS']) for I in group_config["Nodes"] ] with ProcessPoolExecutor() as pool_executor: sources = [ net.DrandRESTSource(identity, args.timeout, pool=pool_executor) for identity in nodes ] async with AsyncExitStack() as stack: await asyncio.gather(*(stack.enter_async_context(source) for source in sources)) async with net.PollingSource(sources, mixer, quorum=args.quorum, period=args.period, backoff=args.backoff) as aggregate: async with args.output.value(aggregate) as output: async with AsyncSystemdNotifier() as notifier: await notifier.notify(b"READY=1") await exit_event.wait() logger.debug( "Eventloop interrupted. Shutting down server...") await notifier.notify(b"STOPPING=1") beat.cancel()
async def _run(self) -> None: async with AsyncExitStack() as stack: await stack.enter_async_context(P2PAPI().as_behavior().apply( self.connection)) self.p2p_api = self.connection.get_logic('p2p', P2PAPI) for behavior in self.get_behaviors(): if behavior.should_apply_to(self.connection): await stack.enter_async_context( behavior.apply(self.connection)) # setup handler for protocol messages to pass messages to subscribers for protocol in self.connection.get_protocols(): self.connection.add_protocol_handler( type(protocol), self._handle_subscriber_message, ) self.setup_protocol_handlers() # The `boot` process is run in the background to allow the `run` loop # to continue so that all of the Peer APIs can be used within the # `boot` task. self.run_child_service(self.boot_manager) # Trigger the connection to start feeding messages though the handlers self.connection.start_protocol_streams() self.ready.set() await self.cancellation()
async def test_proxy_peer_requests(request, event_bus, other_event_bus, event_loop, chaindb_20, client_and_server): server_event_bus = event_bus client_event_bus = other_event_bus client_peer, server_peer = client_and_server client_peer_pool = MockPeerPoolWithConnectedPeers( [client_peer], event_bus=client_event_bus) server_peer_pool = MockPeerPoolWithConnectedPeers( [server_peer], event_bus=server_event_bus) async with AsyncExitStack() as stack: await stack.enter_async_context( run_peer_pool_event_server(client_event_bus, client_peer_pool, handler_type=ETHPeerPoolEventServer)) await stack.enter_async_context( run_peer_pool_event_server(server_event_bus, server_peer_pool, handler_type=ETHPeerPoolEventServer)) await stack.enter_async_context( background_asyncio_service( ETHRequestServer(server_event_bus, TO_NETWORKING_BROADCAST_CONFIG, AsyncChainDB(chaindb_20.db)))) client_proxy_peer_pool = ETHProxyPeerPool( client_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context( background_asyncio_service(client_proxy_peer_pool)) proxy_peer_pool = ETHProxyPeerPool(server_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context( background_asyncio_service(proxy_peer_pool)) proxy_peer = await client_proxy_peer_pool.ensure_proxy_peer( client_peer.session) headers = await proxy_peer.eth_api.get_block_headers(0, 1, 0, False) assert len(headers) == 1 block_header = headers[0] assert block_header.block_number == 0 receipts = await proxy_peer.eth_api.get_receipts(headers) assert len(receipts) == 1 receipt = receipts[0] assert receipt[1][0] == block_header.receipt_root block_bundles = await proxy_peer.eth_api.get_block_bodies(headers) assert len(block_bundles) == 1 first_bundle = block_bundles[0] assert first_bundle[1][0] == block_header.transaction_root node_data = await proxy_peer.eth_api.get_node_data( (block_header.state_root, )) assert node_data[0][0] == block_header.state_root
async def p2pds( num_p2pds, security_protocol, is_gossipsub, is_pubsub_signing, is_pubsub_signing_strict, ): async with AsyncExitStack() as stack: p2pds = [ await stack.enter_async_context( make_p2pd( get_unused_tcp_port(), get_unused_tcp_port(), security_protocol, is_gossipsub=is_gossipsub, is_pubsub_signing=is_pubsub_signing, is_pubsub_signing_strict=is_pubsub_signing_strict, ) ) for _ in range(num_p2pds) ] try: yield p2pds finally: for p2pd in p2pds: await p2pd.close()
async def do_run(cls, boot_info: BootInfo, event_bus: EndpointAPI) -> None: metrics_service = MetricsService( influx_server=boot_info.args.metrics_influx_server, influx_user=boot_info.args.metrics_influx_user, influx_password=boot_info.args.metrics_influx_password, influx_database=boot_info.args.metrics_influx_database, host=boot_info.args.metrics_host, reporting_frequency=boot_info.args.metrics_reporting_frequency, ) # types ignored due to https://github.com/ethereum/async-service/issues/5 system_metrics_collector = collect_process_metrics( # type: ignore metrics_service.registry, frequency_seconds=boot_info.args.metrics_system_collector_frequency ) services_to_exit = (metrics_service, system_metrics_collector,) async with AsyncExitStack() as stack: managers = tuple([ await stack.enter_async_context(background_trio_service(service)) for service in services_to_exit ]) await managers[0].wait_finished()
async def do_run(cls, boot_info: BootInfo, event_bus: EndpointAPI) -> None: trinity_config = boot_info.trinity_config with chain_for_config(trinity_config, event_bus) as chain: if trinity_config.has_app_config(Eth1AppConfig): modules = initialize_eth1_modules(chain, event_bus) elif trinity_config.has_app_config(BeaconAppConfig): modules = initialize_beacon_modules(chain, event_bus) else: raise Exception("Unsupported Node Type") rpc = RPCServer(modules, chain, event_bus) # Run IPC Server ipc_server = IPCServer(rpc, boot_info.trinity_config.jsonrpc_ipc_path) services_to_exit: Tuple[Service, ...] = (ipc_server, ) # Run HTTP Server if boot_info.args.enable_http: http_server = HTTPServer( handler=RPCHandler.handle(rpc.execute), port=boot_info.args.rpcport, ) services_to_exit += (http_server, ) async with AsyncExitStack() as stack: managers = tuple([ await stack.enter_async_context( background_asyncio_service(service)) for service in services_to_exit ]) await managers[0].wait_finished()
async def start_loading(self): if self.is_loading: return if self.is_completed: assert await self.is_cached_locally( ), "Cache file %s is gone." % self.local_path return await self.aclose() # ensure old Future was properly awaited first async with AsyncExitStack() as stack: await stack.enter_async_context(self.state_manager()) if await self.is_cached_locally(): self.state = DownloadState.DONE return await self.validate_headers() aiofile = await stack.enter_async_context( aiofiles.open(self.local_path, "wb", buffering=0)) await aiofile.truncate(self.total_length) await aiofile.seek(0, os.SEEK_SET) resp = await stack.enter_async_context( self.http_session.get(self.url, chunked=True)) resp.raise_for_status() self.future = asyncio.ensure_future( self.run_in_background(stack.pop_all(), aiofile, resp), # After stack.pop_all(), the former exit stack will be contained in the self.future/run_in_background() 'closure' # and reliably cleaned up by self.aclose() right after the background Task completed. loop=self.loop)
async def test_async_callback(self): expected = [ ((), {}), ((1,), {}), ((1,2), {}), ((), dict(example=1)), ((1,), dict(example=1)), ((1,2), dict(example=1)), ] result = [] async def _exit(*args, **kwds): """Test metadata propagation""" result.append((args, kwds)) async with AsyncExitStack() as stack: for args, kwds in reversed(expected): if args and kwds: f = stack.push_async_callback(_exit, *args, **kwds) elif args: f = stack.push_async_callback(_exit, *args) elif kwds: f = stack.push_async_callback(_exit, **kwds) else: f = stack.push_async_callback(_exit) self.assertIs(f, _exit) for wrapper in stack._exit_callbacks: self.assertIs(wrapper[1].__wrapped__, _exit) self.assertNotEqual(wrapper[1].__name__, _exit.__name__) self.assertIsNone(wrapper[1].__doc__, _exit.__doc__) self.assertEqual(result, expected)
async def test_proxy_peer_requests_with_timeouts(request, event_bus, other_event_bus, event_loop, client_and_server): server_event_bus = event_bus client_event_bus = other_event_bus client_peer, server_peer = client_and_server client_peer_pool = MockPeerPoolWithConnectedPeers( [client_peer], event_bus=client_event_bus) server_peer_pool = MockPeerPoolWithConnectedPeers( [server_peer], event_bus=server_event_bus) async with AsyncExitStack() as stack: await stack.enter_async_context( run_peer_pool_event_server(client_event_bus, client_peer_pool, handler_type=ETHPeerPoolEventServer)) await stack.enter_async_context( run_peer_pool_event_server(server_event_bus, server_peer_pool, handler_type=ETHPeerPoolEventServer)) # We just want an ETHRequestServer that doesn't answer us but we still have to run # *something* to at least subscribe to the events. Otherwise Lahja's safety check will yell # at us for sending requests into the void. for event_type in ETHRequestServer(None, None, None)._subscribed_events: server_event_bus.subscribe(event_type, lambda _: None) client_proxy_peer_pool = ETHProxyPeerPool( client_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context( background_asyncio_service(client_proxy_peer_pool)) server_proxy_peer_pool = ETHProxyPeerPool( server_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context( background_asyncio_service(server_proxy_peer_pool)) proxy_peer = await client_proxy_peer_pool.ensure_proxy_peer( client_peer.session) with pytest.raises(asyncio.TimeoutError): await proxy_peer.eth_api.get_block_headers(0, 1, 0, False, timeout=0.01) with pytest.raises(asyncio.TimeoutError): await proxy_peer.eth_api.get_receipts((), timeout=0.01) with pytest.raises(asyncio.TimeoutError): await proxy_peer.eth_api.get_block_bodies((), timeout=0.01) with pytest.raises(asyncio.TimeoutError): await proxy_peer.eth_api.get_node_data((), timeout=0.01)
async def main_async_exit_stack(*, tcp_port, socket_path): loop: asyncio.AbstractEventLoop = asyncio.get_event_loop() stack = AsyncExitStack() tunnels_state = await stack.enter_async_context(TunnelsState(loop=loop)) await stack.enter_async_context( RPCResponder(tunnels_state, socket_path=socket_path)) await stack.enter_async_context( TCPExteriorServer(tunnels_state, tcp_port=tcp_port)) return stack
def __init__(self, *, ryu_ev_loop_scheduler: RyuAppEventLoopScheduler) -> None: self.ryu_ev_loop_scheduler = ryu_ev_loop_scheduler self.topology_database = TopologyDatabase() self.negotiator_rpc = NegotiatorRPC(settings.NEGOTIATOR_RPC_UNIX_SOCK_PATH) self.ovs_manager = OVSManager( datapath_id=settings.OVS_DATAPATH_ID, # TODO ryu_app.CONF? ) self._stack = AsyncExitStack() self._initialization_task = None self._tunnel_creation_tasks: Mapping[asyncio.Future, asyncio.Future] = {} self.topology_database.add_local_db_synced_callback(self._event_db_synced) self.negotiator_rpc.add_tunnels_changed_callback( self._event_negotiator_tunnels_update )
def __init__(self, *, tmpdir: Optional[str] = None): self.__exit_stack = AsyncExitStack() # Directory for temporal files created by this provider self._temp_dir: Optional[Path] = Path(tmpdir) if tmpdir else None # Mapping of URLs to info on files published with this URL self._published_sources: Dict[str, GftpProvider.URLInfo] = dict() # Lock used to synchronize access to self._published_sources self._lock: asyncio.Lock = asyncio.Lock() # Flag indicating if this `GftpProvider` will close unpublished URLs. # See this class' docstring for more details. self._close_urls: Optional[bool] = read_use_gftp_close_env_var() # Reference to an external process running the `gftp server` command self._process: Optional["__Process"] = None
async def setUp(self): async with AsyncExitStack() as stack: self._db = await stack.enter_async_context( wd.connect('sqlite:///:memory:')) self._stack = stack.pop_all() async with wd.ReadWrite(self._db) as query: for sql in u.SQL_CREATE_TABLE: await query.execute(sql)
async def create_batch_with_gossipsub( cls, number: int, *, cache_size: int = None, strict_signing: bool = False, protocols: Sequence[TProtocol] = None, degree: int = GOSSIPSUB_PARAMS.degree, degree_low: int = GOSSIPSUB_PARAMS.degree_low, degree_high: int = GOSSIPSUB_PARAMS.degree_high, time_to_live: int = GOSSIPSUB_PARAMS.time_to_live, gossip_window: int = GOSSIPSUB_PARAMS.gossip_window, gossip_history: int = GOSSIPSUB_PARAMS.gossip_history, heartbeat_interval: float = GOSSIPSUB_PARAMS.heartbeat_interval, heartbeat_initial_delay: float = GOSSIPSUB_PARAMS. heartbeat_initial_delay, security_protocol: TProtocol = None, muxer_opt: TMuxerOptions = None, msg_id_constructor: Callable[[rpc_pb2.Message], bytes] = get_peer_and_seqno_msg_id, ) -> AsyncIterator[Tuple[Pubsub, ...]]: if protocols is not None: gossipsubs = GossipsubFactory.create_batch( number, protocols=protocols, degree=degree, degree_low=degree_low, degree_high=degree_high, time_to_live=time_to_live, gossip_window=gossip_window, heartbeat_interval=heartbeat_interval, ) else: gossipsubs = GossipsubFactory.create_batch( number, degree=degree, degree_low=degree_low, degree_high=degree_high, time_to_live=time_to_live, gossip_window=gossip_window, heartbeat_interval=heartbeat_interval, ) async with cls._create_batch_with_router( number, gossipsubs, cache_size, strict_signing, security_protocol=security_protocol, muxer_opt=muxer_opt, msg_id_constructor=msg_id_constructor, ) as pubsubs: async with AsyncExitStack() as stack: for router in gossipsubs: await stack.enter_async_context( background_trio_service(router)) yield pubsubs
async def test_requests_when_peer_in_client_vanishs(request, event_bus, other_event_bus, event_loop, chaindb_20, client_and_server): server_event_bus = event_bus client_event_bus = other_event_bus client_peer, server_peer = client_and_server client_peer_pool = MockPeerPoolWithConnectedPeers( [client_peer], event_bus=client_event_bus) server_peer_pool = MockPeerPoolWithConnectedPeers( [server_peer], event_bus=server_event_bus) async with AsyncExitStack() as stack: await stack.enter_async_context( run_peer_pool_event_server(client_event_bus, client_peer_pool, handler_type=ETHPeerPoolEventServer)) await stack.enter_async_context( run_peer_pool_event_server(server_event_bus, server_peer_pool, handler_type=ETHPeerPoolEventServer)) await stack.enter_async_context( background_asyncio_service( ETHRequestServer(server_event_bus, TO_NETWORKING_BROADCAST_CONFIG, AsyncChainDB(chaindb_20.db)))) client_proxy_peer_pool = ETHProxyPeerPool( client_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context( background_asyncio_service(client_proxy_peer_pool)) server_proxy_peer_pool = ETHProxyPeerPool( server_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context( background_asyncio_service(server_proxy_peer_pool)) proxy_peer = await client_proxy_peer_pool.ensure_proxy_peer( client_peer.session) # We remove the peer from the client and assume to see PeerConnectionLost exceptions raised client_peer_pool.connected_nodes.pop(client_peer.session) with pytest.raises(PeerConnectionLost): await proxy_peer.eth_api.get_block_headers(0, 1, 0, False) with pytest.raises(PeerConnectionLost): await proxy_peer.eth_api.get_receipts(()) with pytest.raises(PeerConnectionLost): await proxy_peer.eth_api.get_block_bodies(()) with pytest.raises(PeerConnectionLost): await proxy_peer.eth_api.get_node_data(())
async def two_connected_tx_pools(event_bus, other_event_bus, event_loop, funded_address_private_key, chain_with_block_validation, tx_validator, client_and_server): alice_event_bus = event_bus bob_event_bus = other_event_bus bob, alice = client_and_server bob_peer_pool = MockPeerPoolWithConnectedPeers([bob], event_bus=bob_event_bus) alice_peer_pool = MockPeerPoolWithConnectedPeers([alice], event_bus=alice_event_bus) async with AsyncExitStack() as stack: await stack.enter_async_context( run_peer_pool_event_server(bob_event_bus, bob_peer_pool, handler_type=ETHPeerPoolEventServer)) await stack.enter_async_context( run_peer_pool_event_server(alice_event_bus, alice_peer_pool, handler_type=ETHPeerPoolEventServer)) bob_proxy_peer_pool = ETHProxyPeerPool(bob_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context( background_asyncio_service(bob_proxy_peer_pool)) alice_proxy_peer_pool = ETHProxyPeerPool( alice_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context( background_asyncio_service(alice_proxy_peer_pool)) alice_tx_pool = TxPool( alice_event_bus, alice_proxy_peer_pool, tx_validator, ) await stack.enter_async_context( background_asyncio_service(alice_tx_pool)) bob_tx_pool = TxPool( bob_event_bus, bob_proxy_peer_pool, tx_validator, ) await stack.enter_async_context(background_asyncio_service(bob_tx_pool) ) yield ( alice, alice_event_bus, alice_tx_pool, ), (bob, bob_event_bus, bob_tx_pool)
async def _start_container(self, config: Any): # noinspection PyTupleAssignmentBalance impls, container_config = self._before_start(config) async with AsyncExitStack() as exit_stack: yield AsyncContainer( impls=impls, config=container_config, exit_stack=exit_stack, )
async def run(self) -> None: connection_config = ConnectionConfig.from_name( MAIN_EVENTBUS_ENDPOINT, self._boot_info.trinity_config.ipc_dir ) async with AsyncioEndpoint.serve(connection_config) as endpoint: self._endpoint = endpoint # start the background process that tracks and propagates available # endpoints to the other connected endpoints self.manager.run_daemon_task(self._track_and_propagate_available_endpoints) self.manager.run_daemon_task(self._handle_shutdown_request) await endpoint.wait_until_any_endpoint_subscribed_to(ShutdownRequest) await endpoint.wait_until_any_endpoint_subscribed_to(EventBusConnected) # signal the endpoint is up and running and available self._endpoint_available.set() # instantiate all of the components all_components = tuple( component_cls(self._boot_info) for component_cls in self._component_types ) # filter out any components that should not be enabled. enabled_components = tuple( component for component in all_components if component.is_enabled ) # a little bit of extra try/finally structure here to produce good # logging messages about the component lifecycle. try: async with AsyncExitStack() as stack: self.logger.info( "Starting components: %s", '/'.join(component.name for component in enabled_components), ) # Concurrently start the components. await asyncio.gather(*( stack.enter_async_context(run_component(component)) for component in enabled_components )) self.logger.info("Components started") try: await self._trigger_component_exit.wait() finally: self.logger.info("Stopping components") finally: self.logger.info("Components stopped.") self.manager.cancel()
async def do_run(cls, boot_info: BootInfo, event_bus: EndpointAPI) -> None: try: tracker_services = cls._get_services(boot_info, event_bus) except BadDatabaseError as err: cls.logger.exception( f"Unrecoverable error in Network Component: {err}") async with AsyncExitStack() as stack: for service in tracker_services: await stack.enter_async_context(run_service(service)) await asyncio.gather(*(service.cancellation() for service in tracker_services))
async def apply(self, connection: ConnectionAPI) -> AsyncIterator[None]: self.connection = connection async with AsyncExitStack() as stack: # First apply all the child behaviors for behavior in self._behaviors: if behavior.should_apply_to(connection): await stack.enter_async_context(behavior.apply(connection)) # Now register ourselves with the connection. with connection.add_logic(self.name, self): yield
async def wait_signals(self, signals): __tracebackhide__ = True try: async with real_clock_timeout(): async with AsyncExitStack() as stack: for signal in signals: await stack.enter_async_context( qtrio._core.wait_signal_context(signal)) yield # Supress context in order to simplify the tracebacks in pytest except trio.TooSlowError: raise trio.TooSlowError from None
async def f(): async with AsyncExitStack() as stack: tunnels_state = await stack.enter_async_context( TunnelsState(loop=loop)) await stack.enter_async_context( RPCResponder(tunnels_state, rpc_sock_path)) rpc_c = await stack.enter_async_context( RPCUnixClient(rpc_sock_path, command_cb)) rpc = rpc_c.session resp = await rpc.issue_command("dump_tunnels_state") self.assertDictEqual(resp, {"tunnels": []})
async def test_get_pooled_transactions_request(request, event_bus, other_event_bus, event_loop, chaindb_20, client_and_server): server_event_bus = event_bus client_event_bus = other_event_bus client_peer, server_peer = client_and_server if get_highest_eth_protocol_version(client_peer) < ETHProtocolV65.version: pytest.skip("Test not applicable below eth/65") client_peer_pool = MockPeerPoolWithConnectedPeers( [client_peer], event_bus=client_event_bus) server_peer_pool = MockPeerPoolWithConnectedPeers( [server_peer], event_bus=server_event_bus) async with AsyncExitStack() as stack: await stack.enter_async_context( run_peer_pool_event_server(client_event_bus, client_peer_pool, handler_type=ETHPeerPoolEventServer)) await stack.enter_async_context( run_peer_pool_event_server(server_event_bus, server_peer_pool, handler_type=ETHPeerPoolEventServer)) client_proxy_peer_pool = ETHProxyPeerPool( client_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context( background_asyncio_service(client_proxy_peer_pool)) proxy_peer_pool = ETHProxyPeerPool(server_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context( background_asyncio_service(proxy_peer_pool)) proxy_peer = await client_proxy_peer_pool.ensure_proxy_peer( client_peer.session) # The reason we run this test separately from the other request tests is because # GetPooledTransactions requests should be answered from the tx pool which the previous # test does not depend on. await stack.enter_async_context( background_asyncio_service( TxPool(server_event_bus, proxy_peer_pool, lambda _: True))) # The tx pool always answers these with an empty response txs = await proxy_peer.eth_api.get_pooled_transactions((decode_hex( '0x9ea39df6210064648ecbc465cd628fe52f69af53792e1c2f27840133435159d4' ), )) assert len(txs) == 0
async def apply(self, connection: ConnectionAPI) -> AsyncIterator[None]: if hasattr(self, '_connection') is True: raise Exception("Reentrance!") self._connection = connection async with AsyncExitStack() as stack: for behavior in self.get_behaviors(): if behavior.applies_to(connection): await stack.enter_async_context(behavior.apply(connection)) with connection.add_behavior(self.name, self): self.on_apply(connection) yield
async def create_batch_and_listen( cls, number: int, security_protocol: TProtocol = None, muxer_opt: TMuxerOptions = None, ) -> AsyncIterator[Tuple[Swarm, ...]]: async with AsyncExitStack() as stack: ctx_mgrs = [ await stack.enter_async_context( cls.create_and_listen(security_protocol=security_protocol, muxer_opt=muxer_opt)) for _ in range(number) ] yield tuple(ctx_mgrs)
async def create(cls, number: int) -> AsyncIterator[Tuple["DummyAccountNode", ...]]: """ Create a new DummyAccountNode and attach a libp2p node, a floodsub, and a pubsub instance to this new node. We use create as this serves as a factory function and allows us to use async await, unlike the init function """ async with PubsubFactory.create_batch_with_floodsub(number) as pubsubs: async with AsyncExitStack() as stack: dummy_acount_nodes = tuple(cls(pubsub) for pubsub in pubsubs) for node in dummy_acount_nodes: await stack.enter_async_context(background_trio_service(node)) yield dummy_acount_nodes
async def test_proxy_peer_requests_with_timeouts(request, event_bus, other_event_bus, event_loop, client_and_server): server_event_bus = event_bus client_event_bus = other_event_bus client_peer, server_peer = client_and_server client_peer_pool = MockPeerPoolWithConnectedPeers( [client_peer], event_bus=client_event_bus) server_peer_pool = MockPeerPoolWithConnectedPeers( [server_peer], event_bus=server_event_bus) async with AsyncExitStack() as stack: await stack.enter_async_context( run_peer_pool_event_server(client_event_bus, client_peer_pool, handler_type=ETHPeerPoolEventServer)) await stack.enter_async_context( run_peer_pool_event_server(server_event_bus, server_peer_pool, handler_type=ETHPeerPoolEventServer)) client_proxy_peer_pool = ETHProxyPeerPool( client_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context(run_service(client_proxy_peer_pool)) server_proxy_peer_pool = ETHProxyPeerPool( server_event_bus, TO_NETWORKING_BROADCAST_CONFIG) await stack.enter_async_context(run_service(server_proxy_peer_pool)) proxy_peer = await client_proxy_peer_pool.ensure_proxy_peer( client_peer.session) with pytest.raises(asyncio.TimeoutError): await proxy_peer.eth_api.get_block_headers(0, 1, 0, False, timeout=0.01) with pytest.raises(asyncio.TimeoutError): await proxy_peer.eth_api.get_receipts((), timeout=0.01) with pytest.raises(asyncio.TimeoutError): await proxy_peer.eth_api.get_block_bodies((), timeout=0.01) with pytest.raises(asyncio.TimeoutError): await proxy_peer.eth_api.get_node_data((), timeout=0.01)