async def request_blob(loop: asyncio.AbstractEventLoop, blob: Optional['AbstractBlob'], address: str, tcp_port: int, peer_connect_timeout: float, blob_download_timeout: float, connected_protocol: Optional['BlobExchangeClientProtocol'] = None, connection_id: int = 0, connection_manager: Optional['ConnectionManager'] = None)\ -> typing.Tuple[int, Optional['BlobExchangeClientProtocol']]: """ Returns [<amount of bytes received>, <client protocol if connected>] """ protocol = connected_protocol if not connected_protocol or not connected_protocol.transport or connected_protocol.transport.is_closing( ): connected_protocol = None protocol = BlobExchangeClientProtocol(loop, blob_download_timeout, connection_manager) else: log.debug("reusing connection for %s:%d", address, tcp_port) try: if not connected_protocol: await asyncio.wait_for(loop.create_connection( lambda: protocol, address, tcp_port), peer_connect_timeout, loop=loop) connected_protocol = protocol if blob is None or blob.get_is_verified() or not blob.is_writeable(): # blob is None happens when we are just opening a connection # file exists but not verified means someone is writing right now, give it time, come back later return 0, connected_protocol return await connected_protocol.download_blob(blob) except (asyncio.TimeoutError, ConnectionRefusedError, ConnectionAbortedError, OSError): return 0, None
def create_client(dest_host: str, dest_port: int, server_host: str, server_port: int = 8000, mode: Mode = Mode.tcp, loop: asyncio.AbstractEventLoop = None): loop = loop or asyncio.get_event_loop() return loop.create_connection( partial(Client, dest_host, dest_port, mode, loop), server_host, server_port)
def run_app( loop: asyncio.AbstractEventLoop, dedicated_server: DedicatedServer, config: ServerConfig, state: DotAccessDict, start_ack: Callable[[], None], error_ack: Callable[[], None], stop_request: Awaitable[None], trace: bool = False, ) -> None: asyncio.set_event_loop(loop) LOG.info("init dedicated server clients") console_client = ConsoleClient( loop=loop, trace=trace, ) loop.create_task( loop.create_connection( protocol_factory=lambda: console_client, host=dedicated_server.config.connection.host or "localhost", port=dedicated_server.config.console.connection.port, )) device_link_address = ( dedicated_server.config.device_link.connection.host or "localhost", dedicated_server.config.device_link.connection.port, ) device_link_client = DeviceLinkClient( loop=loop, remote_address=device_link_address, trace=trace, ) loop.create_task( loop.create_datagram_endpoint( protocol_factory=lambda: device_link_client, remote_addr=device_link_client.remote_address, )) loop.run_until_complete( asyncio.gather( console_client.wait_connected(), device_link_client.wait_connected(), loop=loop, )) LOG.info("create application") app = Airbridge( loop=loop, config=config, state=state, dedicated_server=dedicated_server, console_client=console_client, device_link_client=device_link_client, ) LOG.info("start application") app_start_task = loop.create_task(app.start()) loop.run_until_complete(app_start_task) start_ack() try: LOG.info("run application until stop is requested") loop.run_until_complete(stop_request) except AirbridgeException: LOG.fatal("fatal error has occured") except Exception: LOG.fatal("fatal error has occured", exc_info=True) error_ack() else: LOG.info("application stop was requested") finally: console_client.close() device_link_client.close() loop.run_until_complete( asyncio.gather( console_client.wait_closed(), device_link_client.wait_closed(), loop=loop, )) loop.run_until_complete(app.stop())
def create_connection(loop: asyncio.AbstractEventLoop, *args, **kwargs): if not PY37_OR_LATER: kwargs.pop("ssl_handshake_timeout") return loop.create_connection(*args, **kwargs)