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()