def wrapped_callback(): try: cb(*args, **kwargs) except Exception as e: if self._statemachine is not None: self.logger.log_message(LogLevel.Error(), e) self.logger.log_message(LogLevel.Error(), 'exception in mqtt callback') self._statemachine.fail(str(e)) else: raise
def dispatch_command(self, json_data): cmd = json_data.get('command') try: { 'load': lambda param_data: self.load_command(param_data), 'next': lambda param_data: self.next(param_data), 'unload': lambda param_data: self.unload(param_data), 'reset': lambda param_data: self.reset(param_data), 'usersettings': lambda param_data: self.usersettings_command(param_data), 'getresults': lambda param_data: self._handle_command_with_response( param_data), 'getlogs': lambda param_data: self._handle_command_with_response( param_data), 'getlogfile': lambda param_data: self._handle_command_with_response( param_data), 'setloglevel': lambda param_data: self.setloglevel(param_data), }[cmd](json_data) except Exception as e: self.log.log_message(LogLevel.Error(), f'Failed to execute command {cmd}: {e}')
def __get_config_parameters(self, config: dict, parameters: List[str]) -> Optional[str]: for param in parameters: if config.get(param) is None: self.log.log_message(LogLevel.Error(), f"failed to get '{param}' parameter") return None return config
def on_message(self, client, userdata, message): try: result = self.on_request(message.payload) result_json = json.dumps(result) self.mqtt_client.publish(f"ate/{self.device_id}/{self.actuator_type}/io-control/response", result_json) except json.JSONDecodeError as error: self._log.log_message(LogLevel.Error(), f'{error}')
def on_handler_command_message(self, msg: dict): cmd = msg.get('type') payload = msg.get('payload') try: { 'load': lambda param_data: self.load_command(param_data), 'next': lambda param_data: self.next(param_data), 'unload': lambda param_data: self.unload(param_data), 'reset': lambda param_data: self.reset(param_data), 'identify': lambda param_data: self._send_tester_identification(param_data ), 'get-state': lambda param_data: self._send_tester_state(param_data), }[cmd](payload) except KeyError: self.log.log_message(LogLevel.Error(), f'Failed to execute command: {cmd}') except MachineError: self.on_error( f'cannot trigger command "{cmd}" from state "{self.fsm.model.state}"' )
async def receive(self, request): ws = web.WebSocketResponse(heartbeat=1.0) await ws.prepare(request) connection_id = str(uuid.uuid1()) ws_connection = WebSocketConnection(ws, connection_id) self._websockets.add(ws_connection) await self._send_connection_id_to_ws(ws, connection_id) # master should propagate the available settings each time a page reloaded # or new websocket connection is required self.handle_new_connection(connection_id) await self.send_configuration(self._app['master_app'].configuration, ws_connection) self._log.log_message(LogLevel.Debug(), 'websocket connection opened.') try: async for msg in ws: if msg.type == WSMsgType.TEXT: self.handle_client_message(msg.data) elif msg.type == WSMsgType.ERROR: self._log.log_message(LogLevel.Error(), f'ws connection closed with exception: {ws.exception()}') finally: pass self._discard_ws_connection_if_needed()
def does_file_exist(self): if not os.path.exists(self.fullpath): self.log.log_message(LogLevel.Error(), f'file not found: {self.fullpath}') return False return True
def decode_payload(self, payload_bytes): try: payload = json.loads(payload_bytes) return payload except json.JSONDecodeError as error: self.log.log_message(LogLevel.Error(), f'{error}') return None
def on_reset(self, _): try: if self.process: self._terminate() except Exception as e: self.log.log_message(LogLevel.Error(), f"could not terminate testapp properly: {e}") self.to_idle(_)
def _send_set_log_level(self): level = { LogLevel.Debug(): 'Debug', LogLevel.Info(): 'Info', LogLevel.Warning(): 'Warning', LogLevel.Error(): 'Error', }[self.loglevel] self.log.log_message(LogLevel.Info(), f'set loglevel to {level}') self.connectionHandler.send_set_log_level(self.loglevel)
def apply_configuration(self, configuration: dict): try: self.configuredSites = configuration['sites'] # Sanity check for bad configurations: if len(self.configuredSites) == 0: self.log.log_message(LogLevel.Error(), 'Master got no sites assigned') sys.exit() self.device_id = configuration['device_id'] self.broker_host = configuration['broker_host'] self.broker_port = configuration['broker_port'] self.enableTimeouts = configuration['enable_timeouts'] self.handler_id = configuration['Handler'] self.env = configuration['environment'] except KeyError as e: self.log.log_message(LogLevel.Error(), f'Master got invalid configuration: {e}') sys.exit()
def _get_configuration(self, configuration): try: self.handler_type = configuration['handler_type'] self.handler_id = configuration['handler_id'] self.device_ids = configuration['device_ids'] self.broker = configuration['broker_host'] self.broker_port = configuration['broker_port'] except KeyError as e: self._log.log_message(LogLevel.Error(), f'Handler got invalid configuration: {e}') raise
def handle_uncaught_exceptions_from_executor(f): try: f.result() except Exception: self.logger.log_message(LogLevel.Error(), "executor exception") # TODO: we probably don't want to keep running if any # exception escaped. using os._exit may not be # the best way to do this (because no cleanup/io # flushing at all) os._exit(1)
def do_connect(self, target_ip, target_port): num_retries = 0 MAX_NUM_RETRIES = 5 self.connected = False while True: try: self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.settimeout(3) self.sock.connect((target_ip, target_port)) # Connection succeeded, return. self.connected = True self._log.log_message(LogLevel.Debug(), "Connected to DSC6k") return except Exception as ex: self._log.log_message( LogLevel.Error(), f"Failed to connect to DCS6k@{self.target_ip}:{self.target_port}. Retrying." ) self._log.log_message(LogLevel.Error(), f"exception: {ex}") time.sleep(2) num_retries = num_retries + 1 if num_retries > MAX_NUM_RETRIES: raise ex
def on_handler_response_message(self, msg): res = msg.get('type') payload = msg.get('payload') try: { 'temperature': lambda: self._handle_handler_temperature(payload), }[res]() except KeyError: self.log.log_message(LogLevel.Error(), f'Failed to execute response: {res}') except MachineError: self.on_error( f'cannot trigger command "{res}" from state "{self.fsm.model.state}"' )
def _extract_sites_information(self, parameters): try: sites_info = parameters['sites'] self.sites_to_test = [site['siteid'] for site in sites_info] self.sites_to_test.sort() self.sites.sort() if not (self.sites_to_test == self.sites): self.log.log_message( LogLevel.Error(), f'Master do not support site(s): {set(self.sites_to_test) - set(self.sites)}' ) self.on_error( '"next command", handler requiers not configured site(s)') return self._generate_sites_message(self.sites_to_test, sites_info) except Exception: return self._generate_default_sites_configuration()
def retrieve_data(self): if not self.does_file_exist(): return None if self.configuration is None: return None if self.parser is None: return None param_data = self.parser.parse(self.fullpath) for key, value in param_data.items(): if value is None: self.log.log_message(LogLevel.Error(), f'{key} section missing') return None return param_data
def on_control_status_changed(self, siteid: str, status_msg: dict): if self.external_state == 'softerror': return newstatus = status_msg['payload']['state'] if (status_msg['interface_version'] != INTERFACE_VERSION): self.log.log_message(LogLevel.Error(), f'Bad interface version on site {siteid}') self.bad_interface_version() try: if (self.siteStates[siteid] != newstatus): self.log.log_message(LogLevel.Info(), f'Control {siteid} state is {newstatus}') self.siteStates[siteid] = newstatus self.pendingTransitionsControl.trigger_transition( siteid, newstatus) except KeyError: self.on_error(f"Site id received: {siteid} is not configured")
def on_error(self, message): self._machine.model.on_error(message + ' ' + self.prev_master_state) self._log.log_message(LogLevel.Error(), message) self.pending_transistion_master = SequenceContainer([MasterStates.initialized()], self._device_ids, lambda: self._all_testers_detected(), lambda master, state: self._on_unexpected_master_state(master, state)) self.arm_timeout(STARTUP_TIMEOUT, lambda: self.on_error('master(s) could not be recognized'))
def on_error(self, message): self.log.log_message(LogLevel.Error(), f'{message}')
def before_error(self, info): self.log.log_message(LogLevel.Error(), f'{info}') if self._task is not None: self._task.cancel()
def on_timeout(self, message): self.error_message = message self.log.log_message(LogLevel.Error(), message)
def on_disconnect_error(self, site_id, data): self.log.log_message( LogLevel.Error(), f'Master entered state error due to disconnect of site {site_id}')
def on_error_occurred(self, message): self.log.log_message(LogLevel.Error(), f'Master entered state error, reason: {message}') self.error_message = message