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)
