def check_command_accordance(self, command_model):
try:
id_command = command_model.id
# 1 check return type
'''
model_result_type = command_model.result_type
if model_result_type is bool and not(command_model.is_bool()):
raise Exception('Real and model result type are different')
elif model_result_type is int and not(command_model.is_long()):
raise Exception('Real and model result type are different')
elif model_result_type is float and not(command_model.is_double()):
raise Exception('Real and model result type are different')
elif model_result_type is datetime.datetime and not(command_model.is_datetime()):
raise Exception('Real and model result type are different')
elif model_result_type is unicode and not(command_model.is_string()):
raise Exception('Real and model result type are different')
'''
# 2 check argument list and check type in argument_list
for arg_name_model, _ in command_model.arguments:
arg_type_model = command_model.arguments_type[arg_name_model]
arg_name_real, arg_value = command_model.argument(
arg_name_model)
arg_type_real = type(value_from_rpc(arg_value))
if arg_name_model != arg_name_real or \
not(self.check_value_type_accordance(arg_type_model, arg_type_real)):
raise Exception('Real and model arguments are different')
except Exception, err:
t = traceback.format_exc()
log.error('Command discrepancy \'{0}\': {1}'.format(
command_model.name(), decode_string(t)))
raise Exit
def enums(self):
"""
Get the predefined enumeration of values from the 'choices' argument of the parameter
:rtype: List of values of long, float, datetime, bool or unicode type in a tuple as (value1, value2, value3 ….)
"""
answer = self._call('enums')
return [utils.value_from_rpc(key.value) for key in answer.enums]
def get(self):
"""
Get parameter value
:rtype: long, float, datetime, bool or unicode
"""
answer = self._call('get')
return utils.value_from_rpc(answer.value)
def configure_single_event(self, name, event, object_id):
list_name_events_already_exists = map(
lambda id: self.multi_stub.event_call('name', id=id).name,
self.events(object_id))
event.set_multi_stub(self.multi_stub)
if name not in list_name_events_already_exists or options.args.development_mode: # if event doesn't exist
event.id = self.create_event(id_object=object_id, name=name)
getattr(event, event.priority.create_func)()
event.clear()
for name_arg, value_type in event.arguments:
value_arg = utils.value_from_rpc(
utils.get_rpc_value(value_type))
event.update_or_create_argument(name_arg, value_arg)
elif name in list_name_events_already_exists and not options.args.development_mode:
id_event = self.event(object_id, name)
event.id = id_event
Manager.inspector.check_event_accordance(event)
Manager.components[event.id] = event
Manager.components_for_device[object_id].append(event.id)
def call_function(self):
"""
Call function when command executed
:rtype: The return type depends on the function code
"""
try:
arg_list = self.argument_list()
function_dict = {}
info = []
for name_arg in arg_list:
type_arg = self.arguments_type[name_arg]
function_dict[name_arg] = utils.value_from_rpc(self.argument(name_arg)[1])
info.append('{0}({1}): {2}'.format(name_arg, type_arg, function_dict[name_arg]))
log.info('Execute command \'{0}\' with arguments [{1}] from device \'{2}\''
.format(self.name(), '; '.join(info), self.device.id))
self.function(self.device, **function_dict)
except Exception as err:
t = traceback.format_exc()
log.error('Command \'{0}\' raise exception: {1}'.format(self.name(), decode_string(t)))
def check_event_accordance(self, event_model):
try:
id_event = event_model.id
# 1 check priority
if event_model.priority == Priority.blocker and not (
event_model.is_blocker()):
raise Exception('Real and model priority are different')
elif event_model.priority == Priority.critical and not (
event_model.is_critical()):
raise Exception('Real and model priority are different')
elif event_model.priority == Priority.major and not (
event_model.is_major()):
raise Exception('Real and model priority are different')
elif event_model.priority == Priority.minor and not (
event_model.is_minor()):
raise Exception('Real and model priority are different')
# 2 check argument list in code and configuration
code_arguments_list = set([x[0] for x in event_model.arguments])
conf_arguments_list = set(event_model.argument_list())
if code_arguments_list != conf_arguments_list:
raise Exception('Event arguments list mismathcing: {0}'.format(
conf_arguments_list ^ code_arguments_list))
# 3 check argument list and check type in argument_list
for arg_name_model, arg_type_model in event_model.arguments:
arg_name_real, arg_value = event_model.argument(arg_name_model)
arg_type_real = type(value_from_rpc(arg_value))
if arg_name_model != arg_name_real or \
not(self.check_value_type_accordance(arg_type_model, arg_type_real)):
raise Exception('Real and model arguments are different')
except Exception, err:
t = traceback.format_exc()
log.error('Event discrepancy \'{0}\'\n{1}'.format(
event_model.name(), decode_string(t)))
raise Exit
def grpc_thread(self):
"""
Infinity loop: get state from adapter
"""
try:
for r in self.multi_stub.stub_service.states(rpc_pb2.Empty()):
try:
if r.state == rpc_pb2.StateStream.AFTER_CREATING_OBJECT:
log.info('Create device {0}'.format(r.id))
id_name = self.parameter(r.id, 'type_when_create')
rpc_value = self.multi_stub.parameter_call(
'get', id=id_name).value
user_name_display = utils.value_from_rpc(rpc_value)
self.create_object(r.id, user_name_display)
elif r.state == rpc_pb2.StateStream.BEFORE_REMOVING_OBJECT:
log.info('Remove device {0}'.format(r.id))
if r.id in Manager.nodes:
self.delete_object(r.id)
else:
log.warn('Object {0} not found'.format(r.id))
elif r.state == rpc_pb2.StateStream.GETTING_AVAILABLE_CHILDREN:
log.info('Get available children of {0}'.format(r.id))
self.get_available_children(r.id)
elif r.state == rpc_pb2.StateStream.AFTER_SETTING_PARAMETER:
if r.id in Manager.components:
if Manager.components[r.id].callback:
try:
param = Manager.components[
r.id] # TODO check
device = Manager.nodes[
param.owner()] # TODO check
Manager.components[r.id].callback(
device, param)
except Exception as err:
t = traceback.format_exc()
log.error(
'After set parameter value callback error:\n{0}'
.format(decode_string(t)))
else:
log.warn('Parameter {0} not found'.format(r.id))
elif r.state == rpc_pb2.StateStream.EXECUTING_COMMAND:
if r.id in Manager.components:
Manager.components[
r.id].call_function() # try except inside
else:
log.warn('Command {0} not found'.format(r.id))
except Exception as err:
t = traceback.format_exc()
try:
log.error('grpc_thread error: {0}'.format(
decode_string(t)))
except Exception as ultimate_error: # can't fall here
pass
finally:
self.multi_stub.state_call('ack', id=r.id, state=r.state)
except Exception as err:
t = traceback.format_exc()
log.error('grpc_thread error2: {0}'.format(decode_string(t)))