async def mock_nanovault_ws_handler(request):
shutdown_flag = request.app["shutdown_flag"]
ws_mock_node = request.app["ws_mock_node"]
ws = web.WebSocketResponse()
await ws.prepare(request)
while not shutdown_flag.is_set():
# Receive and handle subscriptions and unsubscriptions
try:
try:
response = await ws.receive_json(timeout=0.1)
await ws_mock_node.handle_subscription(response)
except asyncio.TimeoutError:
pass
except TypeError:
# TypeError might be raised if WSMsgType.CLOSED was received
if ws.closed:
break
else:
raise
await ws_mock_node.broadcast_replay_responses(ws)
except Exception:
import traceback
print(traceback.format_exc())
raise web.GracefulExit()
def _on_event(self, msg: str):
if msg.startswith(const.WELCOME_PREFIX):
welcome = commands.HandshakeMessage(*msg.split(','))
LOGGER.info(welcome)
device = service_status.DeviceInfo(
welcome.firmware_version,
welcome.proto_version,
welcome.firmware_date,
welcome.proto_date,
welcome.device_id,
welcome.system_version,
welcome.platform,
welcome.reset_reason,
)
service_status.set_acknowledged(self.app, device)
elif msg.startswith(const.CBOX_ERR_PREFIX):
try:
LOGGER.error('Spark CBOX error: ' +
commands.Errorcode(int(msg[-2:], 16)).name)
except ValueError:
LOGGER.error('Unknown Spark CBOX error: ' + msg)
elif msg.startswith(const.SETUP_MODE_PREFIX):
LOGGER.error(
'Controller entered listening mode. Exiting service now.')
raise web.GracefulExit()
else:
LOGGER.info(f'Spark event: `{msg}`')
def _processSocket(self, sock):
try:
for data in blescan.parse_events(sock, 10):
self.messageHandler.handleData(data)
return self.messageHandler.popMessage()
except asyncio.CancelledError:
raise
except Exception as e:
LOGGER.error(
f"Error accessing bluetooth device whilst scanning: {strex(e)}"
)
raise web.GracefulExit(1)
async def prepare(self):
self.name = self.app["config"]["name"] # The unique service name
self.historyTopic = self.app["config"][
"history_topic"] + f"/{self.name}"
self.stateTopic = self.app["config"]["state_topic"] + f"/{self.name}"
LOGGER.info("Started TiltScanner")
try:
self.sock = bluez.hci_open_dev(0)
except asyncio.CancelledError:
raise
except Exception as e:
LOGGER.error(f"Error accessing bluetooth device: {strex(e)}")
await asyncio.sleep(10) # Avoid lockup caused by service reboots
raise web.GracefulExit(1)
blescan.hci_enable_le_scan(self.sock)
async def _on_event(self, msg: str):
if msg.startswith(WELCOME_PREFIX):
welcome = HandshakeMessage(*msg.split(','))
LOGGER.info(welcome)
device = DeviceInfo(
firmware_version=welcome.firmware_version,
proto_version=welcome.proto_version,
firmware_date=welcome.firmware_date,
proto_date=welcome.proto_date,
device_id=welcome.device_id,
system_version=welcome.system_version,
platform=welcome.platform,
reset_reason=welcome.reset_reason,
)
service_status.set_acknowledged(self.app, device)
elif msg.startswith(SETUP_MODE_PREFIX):
LOGGER.error('Controller entered listening mode. Exiting service now.')
raise web.GracefulExit()
else:
LOGGER.info(f'Spark event: `{msg}`')
async def run(self):
"""Implements RepeaterFeature.run"""
try:
if self._retry_count >= CONNECT_RETRY_COUNT:
raise ConnectionAbortedError()
if self._retry_count == 1:
LOGGER.info('Retrying connection...')
if self._retry_count > 0:
await asyncio.sleep(self.retry_interval)
await service_status.wait_autoconnecting(self.app)
result = await connect_funcs.connect(self.app)
self._proc = result.process
self._address = result.address
self._reader = result.reader
self._writer = result.writer
self._parser = cbox_parser.ControlboxParser()
service_status.set_connected(self.app, self._address)
self._retry_count = 0
self.reset_retry_interval()
LOGGER.info(f'{self} connected')
while self.connected:
# read() does not raise an exception when connection is closed
# connected status must be checked explicitly later
recv = await self._reader.read(100)
# read() returns empty if EOF received
if not recv: # pragma: no cover
raise ConnectionError('EOF received')
# Send to parser
self._parser.push(recv.decode())
# Drain parsed messages
for msg in self._parser.event_messages():
await self._on_event(msg)
for msg in self._parser.data_messages():
await self._on_data(msg)
raise ConnectionError('Connection closed')
except ConnectionAbortedError:
LOGGER.error('Connection aborted. Exiting now.')
self.increase_retry_interval()
raise web.GracefulExit()
except connect_funcs.DiscoveryAbortedError as ex:
LOGGER.error('Device discovery failed.')
if ex.reboot_required:
self._retry_count += 1
raise ex
except Exception:
self._retry_count += 1
raise
finally:
with suppress(Exception):
self._writer.close()
LOGGER.info(f'{self} closed stream writer')
with suppress(Exception):
self._proc.terminate()
LOGGER.info(f'{self} terminated subprocess')
service_status.set_disconnected(self.app)
self._proc = None
self._reader = None
self._writer = None
self._parser = None
async def shutdown():
spy()
raise web.GracefulExit()
async def delayed_shutdown():
await asyncio.sleep(wait)
raise web.GracefulExit()
def __exit():
raise web.GracefulExit()
def stop_handler2():
# This function must run synchronously
loop = asyncio.get_event_loop()
loop.remove_signal_handler(signal.SIGTERM)
raise web.GracefulExit()
