def query_srv_name_by_dev_id(dev_id):
try:
if dev_id in g_dev_id_to_srv_name_map_dict.keys():
dev_srv_name = g_dev_id_to_srv_name_map_dict[dev_id]
msg = MyLog.color_green('从内存获取到设备(%s)的服务名为%s' %
(dev_id, dev_srv_name))
MyLog.logger.info(msg)
return dev_srv_name
else:
MyLog.logger.info(f'RPC查询设备({dev_id})服务名称')
with ClusterRpcProxy(url) as rpc:
dev_srv_name = rpc.mng_srv.get_srv_name_from_sn(dev_id)
if dev_srv_name:
msg = MyLog.color_green('RPC查询得到设备(%s)的服务名为%s' %
(dev_id, dev_srv_name))
MyLog.logger.info(msg)
g_dev_id_to_srv_name_map_dict[dev_id] = dev_srv_name
else:
msg = MyLog.color_green('RPC查询得到设备(%s)的服务名为空' % (dev_id))
MyLog.logger.info(msg)
return dev_srv_name
except Exception as e:
msg = MyLog.color_red("query_srv_name_by_dev_id has except: " +
str(e))
MyLog.logger.error(msg)
return None
def get_attributes(dev_id, attr_name):
try:
MyLog.logger.info('查询服务名称')
dev_svr_name = DevCall.query_srv_name_by_dev_id(dev_id)
msg = MyLog.color_green('设备(%s)的服务名为%s' % (dev_id, dev_svr_name))
MyLog.logger.info(msg)
if dev_svr_name:
msg = MyLog.color_green('RPC调用设备(%s)获取属性值(%s)' %
(dev_id, attr_name))
MyLog.logger.info(msg)
function_name = 'rpc.' + dev_svr_name + '.property_read'
with ClusterRpcProxy(url) as rpc:
result, value = eval(function_name)(dev_id, attr_name)
if result == g_retValue.qjBoxOpcodeSucess.value:
msg = MyLog.color_green(
f'RPC调用设备({dev_id})获取属性值({attr_name}:{value})')
MyLog.logger.info(msg)
return value
else:
msg = MyLog.color_red(
'获取设备(%s)属性值(%s)返回错误(%s)' %
(dev_id, attr_name, g_retValue(result).name))
MyLog.logger.error(msg)
return None
except Exception as e:
msg = MyLog.color_red("get_attributes has except: " + str(e))
MyLog.logger.error(msg)
return None
def delete_rule_by_uuid(self, uuids) -> int:
if not service_ready():
return g_retValue.qjBoxOpcodeNoReady.value
payload = json.dumps(uuids)
msg = MyLog.color_green('rpc call delete_rule_by_uuid: %s' % (payload))
MyLog.logger.info(msg)
return RuleMng.delete_rule_by_uuid(uuids)
def get_rule_by_uuid(self, uuids) -> (int, dict):
if not service_ready():
return g_retValue.qjBoxOpcodeNoReady.value, {}
payload = json.dumps(uuids)
msg = MyLog.color_green('rpc call get_rule_by_uuid: %s' % (payload))
MyLog.logger.info(msg)
return RuleMng.get_rule_by_uuid(uuids)
def manual_control(self, services) -> int:
if not service_ready():
return g_retValue.qjBoxOpcodeNoReady.value
payload = json.dumps(services)
msg = MyLog.color_green('rpc call manual_control: %s' % (payload))
MyLog.logger.info(msg)
return RuleMng.manual_control(services)
def add_rule(self, rules) -> int:
if not service_ready():
return g_retValue.qjBoxOpcodeNoReady.value
payload = json.dumps(rules)
msg = MyLog.color_green('rpc call add_rule: %s' % (payload))
MyLog.logger.info(msg)
return RuleMng.add_rule(rules)
def outside_linkage(self, services) -> int:
if not service_ready():
return g_retValue.qjBoxOpcodeNoReady.value
payload = json.dumps(services)
msg = MyLog.color_green('rpc call outside_linkage: %s' % (payload))
MyLog.logger.info(msg)
# 添加联动指令到指令列表
return RuleMng.outside_linkage(services)
def stop_linkage_rule_running(self, uuids) -> int:
if not service_ready():
return g_retValue.qjBoxOpcodeNoReady.value
payload = json.dumps(uuids)
msg = MyLog.color_green('rpc call stop_linkage_rule_running: %s' % (payload))
MyLog.logger.info(msg)
# 删除指令列表中指定uuid的指令
return RuleMng.stop_linkage_rule_running(uuids)
def attribute_notice(self, product_id, dev_id, attrs) -> None:
if not service_ready():
return None
msg = MyLog.color_green('rpc call attribute_notice, dev_id:%s' % dev_id)
MyLog.logger.debug(msg)
DevAttributeMng.update_dev_now_attributes(dev_id=dev_id, attr_dict=attrs)
timer = Timer(0, RuleMng.run_linkage_rule_by_devid, args=(dev_id, attrs,))
timer.start()
def main():
msg = MyLog.color_green('+++++++++规则引擎启动+++++++++')
MyLog.logger.info(msg)
RuleNameko.open()
time.sleep(6)
MyLog.logger.info("query has mng srv ready")
while not DevCall.mng_srv_ready():
time.sleep(1)
msg = MyLog.color_green('管理服务已就就绪')
set_service_ready()
MyLog.logger.info(msg)
# 恢复设备之前联动过程中没有恢复的指令
DevAttributeMng.restore_devices_when_start_up()
RuleMng.timer_rule_decision()
while True:
time.sleep(3600)
def event_notice(self, product_id, dev_id, event, payload) -> None:
if not service_ready():
return None
msg = MyLog.color_green('rpc call event_notice, dev_id:%s, event:%s, payload:%s' % (dev_id, event, payload))
MyLog.logger.info(msg)
if EventHandle.update_event(product_id, dev_id, event, payload):
# 根据dev_id，触发与其相关的联动脚本执行
timer = Timer(0, RuleMng.run_linkage_rule_by_devid, args=(dev_id, None,))
timer.start()
def report_rule_end_event(uuid):
try:
msg = MyLog.color_green('上报规则结束事件 uuid=%s' % (uuid))
MyLog.logger.info(msg)
with ClusterRpcProxy(url) as rpc:
resp = rpc.GW.raiseEvent.call_async('ruleEnd', uuid=uuid)
except Exception as e:
msg = MyLog.color_red("report_rule_end_event has except: " +
str(e))
MyLog.logger.error(msg)
return None
def service_ready():
global service_is_ready
global start_ts
if service_is_ready:
return True
elif time.time() - start_ts > 5:
service_is_ready = True
msg = MyLog.color_green('rule engine rpc service ready')
MyLog.logger.info(msg)
return True
else:
return False
def report_linkage_custom_event(eventId, srcList):
try:
msg = MyLog.color_green(
f'上报用户自定义事件 eventid={eventId} srcList={srcList}')
MyLog.logger.info(msg)
with ClusterRpcProxy(url) as rpc:
resp = rpc.GW.raiseEvent.call_async('customEvent',
eventId=eventId,
srcList=srcList)
except Exception as e:
msg = MyLog.color_red("report_linkage_custom_event has except: " +
str(e))
MyLog.logger.error(msg)
return None
def report_rule_command_cover_event(dev_id, command, be_cover_rule_uuid,
cover_rule_uuid):
try:
msg = MyLog.color_green('上报指令被高优先级抢占事件 dev_id=%s, command=%s, be_cover_rule_uuid=%s, cover_rule_uuid=%s'\
%(dev_id, command, be_cover_rule_uuid, cover_rule_uuid))
MyLog.logger.info(msg)
with ClusterRpcProxy(url) as rpc:
resp = rpc.GW.raiseEvent.call_async('ruleCommandCover',\
devId=dev_id, command=command, beCoverRuleUuid=be_cover_rule_uuid, coverRuleUuid=cover_rule_uuid)
except Exception as e:
msg = MyLog.color_red(
"report_rule_command_cover_event has except: " + str(e))
MyLog.logger.error(msg)
return None
def call_service(dev_id, service_name, type, params=None, default=False):
try:
dev_svr_name = DevCall.query_srv_name_by_dev_id(dev_id)
if dev_svr_name:
command_save = True
if type == 'linkage':
command_save = False
if not default:
msg = MyLog.color_green(
'RPC调用设备(%s)服务(%s)类型(%s),参数:%s' %
(dev_id, service_name, type, params))
MyLog.logger.info(msg)
function_name = 'rpc.' + dev_svr_name + '.ioctl'
with ClusterRpcProxy(url) as rpc:
ret, data = eval(function_name)(dev_id, service_name,
command_save, params)
return False, True, ret, data
else:
msg = MyLog.color_green('RPC调用设备(%s)服务(%s)类型(%s),默认参数' %
(dev_id, service_name, type))
MyLog.logger.info(msg)
function_name = 'rpc.' + dev_svr_name + '.set_default'
with ClusterRpcProxy(url) as rpc:
ret, data = eval(function_name)(dev_id, service_name,
command_save)
return False, True, ret, data
else:
return False, False, g_retValue.qjBoxOpcodeSrvNoRunning.value, {}
except UnknownService as e:
msg = MyLog.color_red(
"DevCall call_service has UnknownService except: " + str(e))
MyLog.logger.error(msg)
return True, False, g_retValue.qjBoxOpcodeSrvNoRunning.value, {}
except Exception as e:
msg = MyLog.color_red("DevCall call_service has except: " + str(e))
MyLog.logger.error(msg)
return True, False, g_retValue.qjBoxOpcodeExcept.value, {}
def report_default_command_status_event(dev_id, command, result_code):
try:
msg = MyLog.color_green(
'上报指令执行默认参数结果事件 dev_id=%s, command=%s, result_code=%d' %
(dev_id, command, result_code))
MyLog.logger.info(msg)
with ClusterRpcProxy(url) as rpc:
resp = rpc.GW.raiseEvent.call_async('ruleDefaultCommandStatus',
devId=dev_id,
command=command,
resultCode=result_code)
except Exception as e:
msg = MyLog.color_red(
"report_default_command_status_event has except: " + str(e))
MyLog.logger.error(msg)
return None
def full_attribute_notice(self, product_id, dev_id, attrs):
"""
接收设备的全量上报
Args:
product_id:
dev_id:
attrs:
Returns:
"""
if not service_ready():
return None
msg = MyLog.color_green(f'rpc call full_attribute_notice{product_id, dev_id, attrs}')
MyLog.logger.debug(msg)
DevAttributeMng.update_dev_now_attributes(dev_id=dev_id, attr_dict=attrs)
def report_rule_command_ignore_event(dev_id, command, uuid,
higher_priority_uuid):
try:
msg = MyLog.color_green(
'上报指令忽略执行事件 dev_id=%s, command=%s, uuid=%s, higher_priority_uuid=%s'
% (dev_id, command, uuid, higher_priority_uuid))
MyLog.logger.info(msg)
with ClusterRpcProxy(url) as rpc:
resp = rpc.GW.raiseEvent.call_async(
'ruleCommandIgnore',
devId=dev_id,
command=command,
uuid=uuid,
higherPriorityUuid=higher_priority_uuid)
except Exception as e:
msg = MyLog.color_red(
"report_rule_command_ignore_event has except: " + str(e))
MyLog.logger.error(msg)
return None
def get_all_rules(self) -> (int, dict):
if not service_ready():
return g_retValue.qjBoxOpcodeNoReady.value, {}
msg = MyLog.color_green('rpc call get_all_rules')
MyLog.logger.info(msg)
return RuleMng.get_all_rules()
def command_exe(dev_id, command: CommandInfo, force=False):
try:
MyLog.logger.info(
f'指令执行 设备id:{dev_id}, 指令名称:{command.command}, 规则:{command.uuid}, force:{force}'
)
# 先获取指令名称
command_name = command.command
# 从该设备的指令队列中查询该指令名称正在执行的指令
dev_command_queue = DevCommandQueueMng.get_dev_command_queue(
dev_id)
running_command = dev_command_queue.get_current_running_command(
command_name)
need_exe = False
need_report_rule_command_cover_event = False
if force:
need_exe = True
if running_command.priority < command.priority:
need_report_rule_command_cover_event = True
elif running_command:
# 判断是否为同一个规则指令，如果不是才允许执行
MyLog.logger.info('running_command: %s, command:%s' %
(running_command.uuid, command.uuid))
MyLog.logger.info(
f'running_command_effective:{running_command.effective}')
if not running_command.effective or running_command.uuid != command.uuid:
need_exe = True
else:
msg = MyLog.color_green(
'指令执行 设备id:%s, 指令名称:%s, 规则:%s 已经在执行中，不需要重新下发' %
(dev_id, command.command, command.uuid))
MyLog.logger.info(msg)
if running_command.priority < command.priority:
need_report_rule_command_cover_event = True
else:
need_exe = True
result = g_retValue.qjBoxOpcodeSucess.value
need_retry = False
service_has_recv = False
if need_exe:
if command.default_param:
# 执行默认参数
msg = MyLog.color_green(
'下发默认参数指令(%s)给设备(%s)服务, 指令优先级:%d' %
(command.command, dev_id, command.priority))
MyLog.logger.info(msg)
need_retry, service_has_recv, result, data = DevCall.call_service(
dev_id, command.command, command.type, default=True)
msg = MyLog.color_green('下发默认参数指令(%s)给设备(%s)服务, 返回:%d' %
(command.command, dev_id, result))
MyLog.logger.info(msg)
EventReport.report_default_command_status_event(
dev_id, command.command, result)
else:
# 执行规则配置参数
msg = MyLog.color_green(
'下发规则(%s)指令(%s)给设备(%s)服务, 指令优先级:%d' %
(command.uuid, command.command, dev_id,
command.priority))
MyLog.logger.info(msg)
need_retry, service_has_recv, result, data = DevCall.call_service(
dev_id, command.command, command.type, command.params)
msg = MyLog.color_green(
'下发规则(%s)指令(%s)给设备(%s)服务, 返回:%d' %
(command.uuid, command.command, dev_id, result))
MyLog.logger.info(msg)
# 上报ruleCommandStatus event
EventReport.report_rule_command_status_event(
command.uuid, dev_id, command.command, result)
if service_has_recv:
dev_command_queue.set_current_running_command(
command_name, command)
# 更新规则指令状态
CmdRecorder.update_cmd(dev_id, command)
if need_report_rule_command_cover_event:
EventReport.report_rule_command_cover_event(
dev_id, command.command, running_command.uuid,
command.uuid)
return need_retry, service_has_recv, result
except BaseException as e:
msg = MyLog.color_red('command_exe has except: ' + str(e))
MyLog.logger.error(msg)
return False, False, g_retValue.qjBoxOpcodeExcept.value
def clear_all_rule(self) -> int:
if not service_ready():
return g_retValue.qjBoxOpcodeNoReady.value
msg = MyLog.color_green('rpc call clear_all_rule')
MyLog.logger.info(msg)
return RuleMng.clear_all_rule()
