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
