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)
