def mock_network_loop(loop: asyncio.AbstractEventLoop): dht_network: typing.Dict[typing.Tuple[str, int], 'KademliaProtocol'] = {} async def create_datagram_endpoint(proto_lam: typing.Callable[[], 'KademliaProtocol'], from_addr: typing.Tuple[str, int]): def sendto(data, to_addr): rx = dht_network.get(to_addr) if rx and rx.external_ip: # print(f"{from_addr[0]}:{from_addr[1]} -{len(data)} bytes-> {rx.external_ip}:{rx.udp_port}") return rx.datagram_received(data, from_addr) protocol = proto_lam() transport = asyncio.DatagramTransport(extra={'socket': mock_sock}) transport.is_closing = lambda: False transport.close = lambda: mock_sock.close() mock_sock.sendto = sendto transport.sendto = mock_sock.sendto protocol.connection_made(transport) dht_network[from_addr] = protocol return transport, protocol with mock.patch('socket.socket') as mock_socket: mock_sock = mock.Mock(spec=socket.socket) mock_sock.setsockopt = lambda *_: None mock_sock.bind = lambda *_: None mock_sock.setblocking = lambda *_: None mock_sock.getsockname = lambda: "0.0.0.0" mock_sock.getpeername = lambda: "" mock_sock.close = lambda: None mock_sock.type = socket.SOCK_DGRAM mock_sock.fileno = lambda: 7 mock_socket.return_value = mock_sock loop.create_datagram_endpoint = create_datagram_endpoint yield
def __init__(self, loop: asyncio.AbstractEventLoop): self._loop = loop socket = loop.create_datagram_endpoint( lambda: self.UDPListener(self), local_addr=(NETWORK_LISTEN_ADDR, NETWORK_PORT), reuse_address=True, allow_broadcast=True, ) (self._socket, _) = loop.run_until_complete(socket)
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 _get_udp_server(loop: aio.AbstractEventLoop, protocol_factory: Type[aio.Protocol], **params) -> \ Tuple[aio.DatagramTransport, Server]: listener = loop.create_datagram_endpoint(protocol_factory, **params) return loop.run_until_complete(listener)