def write_iscouttaskback(
self,
iscouttask: IscoutTask,
cmdstatus: ECommandStatus,
scoutrecvmsg: str,
currtime: str = None,
elapsed: float = None,
):
"""
通用方法编写iscantask的回馈
update by judy 20201110
编写这个任务的回馈因为需要登陆的插件需要这个回馈
:param iscouttask:
:param cmdstatus:
:param scanrecvmsg:
:param currtime:
:param elapsed:
:return:
"""
if iscouttask is None:
raise Exception("Write iscantaskback iscantask cannot be None")
scanback = IscoutBtaskBack.create_from_task(iscouttask, cmdstatus,
scoutrecvmsg, currtime,
elapsed)
OutputManagement.output(scanback)
return
def _update_to_db(self, task: Task, targetclient: Client, succ: bool):
"""同步任务下发状态到数据库。这里来的永远是子任务"""
try:
if not succ:
# 失败，返回回馈数据
task.cmdstatus = ECommandStatus.Failed
task.cmdrcvmsg = "发送任务到采集端失败"
tb: TaskBatchBack = TaskBatchBack.create_from_task(
task, cmdrcvmsg=task.cmdrcvmsg)
if not OutputManagement.output(tb):
self._logger.error(
"Write idown_task_back failed:\ntaskid:{}".format(
task.taskid))
if isinstance(task.cmd, IdownCmd):
task.cmd.cmdstatus = ECommandStatus.Failed
task.cmd.cmdrcvmsg = task.cmdrcvmsg
cmdback: CmdFeedBack = CmdFeedBack.create_from_cmd(
task.cmd, task.cmd.cmdstatus, task.cmd.cmdrcvmsg)
if not OutputManagement.output(cmdback):
self._logger.error(
"Write IDownCmdBack failed:\nplatform:{}\ncmdid:{}"
.format(task._platform, task.cmd_id))
else:
# 成功
task.cmdstatus = ECommandStatus.Dealing
if isinstance(task.cmd, IdownCmd):
task.cmd.cmdstatus = ECommandStatus.Dealing
self._logger.info(
"Send task succeed\t{}:\ntaskid:{}\nbatchid:{}\nclient:{}\t{}"
.format(task.tasktype.name, task.taskid, task.batchid,
task._clientid, targetclient._statusbasic.ip))
# 更新数据库当前子任务状态
if not self._dbmanager.update_batchtask_status(
task._platform, task.taskid, task.batchid, task.cmdstatus):
# 这里如果更新数据库状态失败了，那发送线程可能会重新发送当前子任务。
# 此时需要采集端支持 冥等性（任务去重，保证多次收到同一条任务只会处理一条）
self._logger.error(
"Update task cmdstatus failed:\ntaskid:{}\ncmdstatus:{}".
format(task.taskid, task.cmdstatus.name))
# 如果带cmd，更新cmd状态
elif isinstance(
task.cmd,
IdownCmd) and not self._dbmanager.update_cmd_status(
task.cmd.platform, task.cmd.cmd_id,
targetclient._statusbasic._clientid,
task.cmd.cmdstatus):
self._logger.error(
"Update cmd cmdstatus failed:\ntaskid:{}\ncmdstatus:{}".
format(task.taskid, task.cmdstatus.name))
except Exception:
self._logger.error("Update task cmdstatus to db error: {}".format(
traceback.format_exc()))
self._dbmanager.update_idown_task_status(task,
ECommandStatus.Failed)
if isinstance(task.cmd, IdownCmd):
self._dbmanager.update_cmd_status(task._platform, task.cmd_id,
task.cmd._clientid,
ECommandStatus.Failed)
def _feedback_userinfo(self, cookie_res, tsk: Task):
"""
每次进行cookie更新后需要回馈cookie的信息
modify by judy 2020/11/18
"""
if cookie_res:
cookie_status = 1
else:
cookie_status = 2
userdict = self._sqlfunc.query_idown_userinfo(tsk.taskid, tsk.batchid)
if not isinstance(userdict, dict):
self._logger.error(
f"Query idown userinfo error\ntaskid:{tsk.taskid}\nbatchid:{tsk.batchid}"
)
return
userid = userdict.get("userid")
clientid = userdict.get("clientid")
if userid is None or clientid is None:
self._logger.error(
f"Idown userinfo is None, check the database whether or not exist"
)
return
uinfo = UserStatus(tsk, clientid, userid, tsk.apptype)
uinfo.cookiestatus = cookie_status
OutputManagement.output(uinfo)
return
def write_cmd_back(cls, icmd, state, recvmsg: str):
"""
idown cmd 的回馈
:return:
"""
cmd_back = CmdFeedBack.create_from_cmd(icmd, state, recvmsg)
OutputManagement.output(cmd_back)
return
def __output_resources(self, resource: NetworkResource):
"""
资源文件是直接输出，
因为resource继承的output，所以调用输出器输出，到时候问下配不配
:param resource:
:return:
"""
OutputManagement.output(resource)
return
def start(self):
while True:
try:
self.get_basic_status_info()
lines = StatusBasic(self._clientinfo)
OutputManagement.output(lines)
except:
print(
f"Write clientbasicstatus info error, err:{traceback.format_exc()}"
)
finally:
time.sleep(clienttaskconfig.collect_client_times)
def _output_data_and_log_output_data(self, data):
"""
输出日志然后输出文件
:param data:
:return:
"""
# 统一日志输出
self._log_for_data(data)
# 这里会出现一个bug就是先输出日志然后输出数据会导致数据可能会混淆到一个文件里面去了目前还是会存在这样的，
# 或者是生成的字符串导致hash一样传输程序将两个文件之间的东西混淆了, by judy 2020/01/7
# time.sleep(0.5)
OutputManagement.output(data)
return
def _get_google_searchengine(self,
root: NetworkId,
task: IscoutTask,
level,
networkid,
reason=None):
"""
google 搜索
:param root:
:param task:
:param level:
:param networkid:
:param reason:
:return:
"""
if not task.cmd.stratagyscout.cmdnetworkid.enabled_searchgoogle:
return
log = f"开始探测目标{networkid} {self.dtools.google}信息"
self._outprglog(log)
self._logger.debug("NETWORKID:Start getting google search.")
count = 0
try:
keywords = (task.cmd.stratagyscout.cmdnetworkid.searchengine.
search_google.keywords)
filetypes = (task.cmd.stratagyscout.cmdnetworkid.searchengine.
search_google.filetypes)
sapi = SearchApi(task)
for data in sapi.text_google_search_engine(keywords, filetypes,
networkid, level,
self.dtools.google):
# 输出截图数据/这里scouternetworkid里只可能是搜索引擎截图数据
if isinstance(data, ScreenshotSE):
OutputManagement.output(data)
elif isinstance(data, SearchFile):
OutputManagement.output(data)
else:
self.__set_value(root, data)
count += 1
root = self.__segment_output(root, level, networkid)
yield data
except:
self._logger.error(
f"Get google search error, err:{traceback.format_exc()}")
finally:
log = f"获取到目标{networkid}未经处理的{count}条{self.dtools.google}数据"
self._outprglog(log)
def _get_bing_searchengine(self,
root: Email,
task: IscoutTask,
level,
email,
reason=None):
"""
bing search engine
:param root:
:param task:
:param level:
:param email:
:param reason:
:return:
"""
if not task.cmd.stratagyscout.cmdemail.enabled_searchbing:
return
log = f"开始收集目标{email} {self.dtools.bing}信息"
self._outprglog(log)
self._logger.debug("EMIAL:Start getting bing search result")
keywords: list = (
task.cmd.stratagyscout.cmdemail.searchengine.search_bing.keywords)
filetypes: list = (
task.cmd.stratagyscout.cmdemail.searchengine.search_bing.filetypes)
count = 0
try:
sapi = SearchApi(task)
for data in sapi.text_bing_search_engine(keywords, filetypes,
email, level,
self.dtools.bing):
# 输出截图数据
if isinstance(data, ScreenshotSE):
OutputManagement.output(data)
elif isinstance(data, SearchFile):
OutputManagement.output(data)
else:
self.__set_value(root, data)
count += 1
root = self.__segment_output(root, level, email)
yield data
except:
self._logger.error(
f"Get bing search error, err:{traceback.format_exc()}")
finally:
log = f"获取到目标{email}未经处理的{count}条{self.dtools.bing}数据"
self._outprglog(log)
def _get_baidu_searchengine(self,
root: Phone,
task: IscoutTask,
level,
phone,
reason=None):
"""
google search
:param root:
:param task:
:param level:
:param phone:
:param reason:
:return:
"""
if not task.cmd.stratagyscout.cmdphone.enabled_searchbaidu:
return
log = f"开始收集目标{phone} {self.dtools.baidu}信息"
self._outprglog(log)
self._logger.debug("PHONE:Start baidu search.")
count = 0
try:
keywords = (task.cmd.stratagyscout.cmdphone.searchengine.
search_baidu.keywords)
filetypes = (task.cmd.stratagyscout.cmdphone.searchengine.
search_baidu.filetypes)
sapi = SearchApi(task)
for data in sapi.text_baidu_search_engine(keywords, filetypes,
phone, level,
self.dtools.baidu):
# 输出截图数据
if isinstance(data, ScreenshotSE):
OutputManagement.output(data)
elif isinstance(data, SearchFile):
OutputManagement.output(data)
else:
self.__set_value(root, data)
root = self.__segment_output(root, level, phone)
count += 1
yield data
except:
self._logger.error(
f"Get baidu search error, err:{traceback.format_exc()}")
finally:
log = f"获取到目标{phone}未经处理的{count}条{self.dtools.baidu}数据"
self._outprglog(log)
def _write_log_back(self, log):
"""
log 的回馈
:param log:
:return:
"""
if log == "" or log is None:
raise Exception("Log can not be None")
linfo = ClientLog(self.task, self._clientid, self.task.apptype, log)
# 添加这个的原因是因为不知道为什么明明log都没有调用数据流这个字段，但是日志里却出现了文件体，这里相当于上了一个保险
# if linfo.io_stream is not None:
# self._logger.error('Now get a clientlog data stream is not None')
# linfo.io_stream = None
OutputManagement.output(linfo)
return
def _write_tgback(self, task: Task, taskstatus: ECommandStatus, taskres):
"""
返回回馈文件
:param task:
:param taskstatus:
:param taskres:
:return:
"""
if not isinstance(task, Task):
raise Exception("Invalid task object for taskback")
tginfo = TaskBatchBack.create_from_task(task,
cmdstatus=taskstatus,
cmdrcvmsg=taskres)
OutputManagement.output(tginfo)
return
def _update_to_db(self, cmd: IdownCmd, targetclient: Client, succ: bool):
try:
if not succ:
cmd.cmdstatus = ECommandStatus.Failed
cmd.cmdrcvmsg = "发送任务到采集端失败"
# 失败，返回回馈数据
cmdback: CmdFeedBack = CmdFeedBack.create_from_cmd(
cmd, cmd.cmdstatus, cmd.cmdrcvmsg)
if not OutputManagement.output(cmdback):
self._logger.error(
"Write idown_cmd_back failed:\ncmdid:{}".format(
cmd.cmd_id))
else:
# 成功，状态置为 处理中
cmd.cmdstatus = ECommandStatus.Dealing
self._logger.info(
"Send idown_cmd_back succeed\t{}:\ncmdid:{}\nclient:{}\t{}"
.format(cmd.target, cmd.cmd_id, cmd._clientid,
targetclient._statusbasic.ip))
if not self._dbmanager.update_cmd_status(
cmd._platform, cmd.cmd_id,
targetclient._statusbasic._clientid, cmd.cmdstatus):
self._logger.error(
"Update cmd cmdstatus failed:\ncmdid:{}\ncmdstatus:{}".
format(cmd.cmd_id, cmd.cmdstatus.name))
return
except Exception:
self._logger.error(
"Update IDownCmd cmdstatus to db error: {}".format(
traceback.format_exc()))
def _generate_task_back_percent(self, task: AutomatedTask) -> bool:
"""返回总任务百分比"""
res: bool = False
try:
currpercent = math.floor(task.batchcompletecount /
task.batchtotalcount * 100)
lastprogress = task.progress * 100
if task.batchtotalcount > 100:
# 子任务数大于100个的，每1%返回一次
if currpercent - lastprogress < 1:
res = True
elif 50 < task.batchtotalcount <= 100:
# 50<x<=100个子任务的，总共返回25个百分比文件，每%4返回一次
if currpercent - lastprogress < 4:
res = True
else:
# 0<x<=50个子任务的，每%10左右返回一次
if currpercent - lastprogress < 10:
res = True
if res:
return res
# 最新总任务Progress更新到数据库并发送回馈数据
task.progress = currpercent / 100
task.cmdstatus = ECommandStatus.Progress
if not self._dbmanager.update_automated_task2(task):
self._logger.error(
"Update AutomatedTask with progress failed: taskid={} objecttype={} progress={}"
.format(task.taskid, task._objecttype.name, task.progress))
return res
taskback: AutotaskBack = AutotaskBack.create_from_task(
task,
ECommandStatus.Progress,
recvmsg='{}%'.format(currpercent),
batchcompletecount=task.batchtotalcount)
if not OutputManagement.output(taskback):
res = False
self._logger.error(
"Output AutotaskBack progress failed:\ntaskid:{}\ncmdstatus:{}\nprogress:{}"
.format(task.taskid, task.cmdstatus.name, currpercent))
return res
res = True
self._logger.info(
"AutotaskBack generated [Progress {}]:\ntaskid={}".format(
task.progress, task.taskid))
except Exception:
res = False
self._logger.error(
"Generate AutomatedTaskBack for batch complete percent error:\ntaskid:{}\nerror:{}"
.format(task.taskid, traceback.format_exc()))
finally:
pass
return res
def _write_userstatus_back(self, userid):
"""
userstatus的回馈
modify by judy 20201118
输出每个userstatus的时候将user信息和task信息保存，后面cookie失活后需要更新这个表
:param userid:
:return:
"""
if userid is None:
raise Exception("Userid cant be None")
uinfo = UserStatus(self.task, self._clientid, userid,
self.task.apptype)
OutputManagement.output(uinfo)
# 保存userinfo
self._sqlfunc.save_idown_userinfo(self.task.taskid, self.task.batchid,
userid, self._clientid)
return
def write_autotaskback(autotask: AutomatedTask,
cmdstatus: ECommandStatus,
recvmsg: str,
currtime: str = None):
"""
通用方法编写iscantask的回馈
:param autotask:
:param cmdstatus:
:param recvmsg:
:param currtime:
:return:
"""
if autotask is None:
raise Exception('Write iscantaskback iscantask cannot be None')
autoback = AutotaskBatchBack.create_from_task(autotask, cmdstatus,
recvmsg, currtime)
OutputManagement.output(autoback)
return
def _get_baidu_searchengine(
self, root: Domain, task: IscoutTask, level, domain, reason=None
):
"""
baidu 搜索引擎
:param root:
:param task:
:param level:
:param domain:
:param reason:
:return:
"""
# 目前只有google搜索
if not task.cmd.stratagyscout.cmddomain.enabled_searchbaidu:
return
log = f"开始探测目标{domain} {self.dtools.baidu}信息"
self._outprglog(log)
count = 0
try:
self._logger.debug("DOMIAN:Start getting baidu search.")
sapi = SearchApi(task)
for data in sapi.domain_baidu_search_engine(
domain, level, self.dtools.baidu
):
# 输出截图数据
if isinstance(data, ScreenshotSE):
OutputManagement.output(data)
elif isinstance(data, SearchFile):
OutputManagement.output(data)
else:
self.__set_value(root, data)
root = self.__segment_output(root, level, domain)
count += 1
yield data
except:
self._logger.error(
f"Get baidu search engine result error, err:{traceback.format_exc()}"
)
finally:
log = f"获取到目标{domain}未经处理的{count}条{self.dtools.baidu}数据"
self._outprglog(log)
def check_registration(self):
"""
tasktype为账号应用注册查询必须实现此方法
:return:返回bool值指示账号是否注册当前app
"""
# 像个办法统一==，想什么办法呢
try:
res = self._check_registration()
if res is not None:
for data in res:
# 统一日志输出
self._log_for_data(data)
# 每一个data获取到在输出之前需要做的事
# 输出
OutputManagement.output(data)
except Exception:
self._logger.error("Check registration failed: {}".format(
traceback.format_exc()))
return
def write_iscanback(iscantask: IscanTask,
cmdstatus: ECommandStatus,
scanrecvmsg: str,
currtime: str = None,
elapsed: float = None):
"""
通用方法编写iscantask的回馈
:param elapsed:
:param iscantask:
:param cmdstatus:
:param scanrecvmsg:
:param currtime:
:return:
"""
if iscantask is None:
raise Exception('Write iscantaskback iscantask cannot be None')
scanback = IscanTaskBack.create_from_task(iscantask, cmdstatus, scanrecvmsg, currtime, elapsed)
OutputManagement.output(scanback)
return
def _merge_task_status(self, task: Task):
"""合并处理子任务状态"""
try:
# 当前模块为 任务发送管理器，只负责 等待发送的任务及其状态管理。
# 合并子任务状态，并将总任务状态从 等待发送更新为正在执行。
# 只要有一个子任务发送成功，则总任务更新为发送成功
# 若全部子任务发送失败，整个任务才算发送失败，
# 貌似这样才能在非实时性的任务状态中没什么错
## 先看是否还有尚未发送的子任务，有的话先不要乱动。。
waitforsendcount: int = self._dbmanager.get_batch_task_count_by_cmdstatus(
task, ECommandStatus.WaitForSend)
if waitforsendcount > 0:
return
## 再看有没有发送成功的，有的话直接总任务发送成功，正在执行
sendsucccount: int = self._dbmanager.get_batch_task_count_by_cmdstatus(
task, ECommandStatus.Dealing)
if sendsucccount > 0:
task.cmdstatus = ECommandStatus.Dealing
self._logger.info(
"Task all sent, taskid={} tasktype={}".format(
task.taskid, task.tasktype))
# 只要有一个子任务发送成功，则更新总任务为正在执行（不需要返回回馈数据）
if not self._dbmanager.update_idown_task_status(
task, ECommandStatus.Dealing):
self._logger.error(
"Update task cmdstatus to {} faled: taskid:{}".format(
ECommandStatus.Dealing.name, task.taskid))
else:
task.cmdstatus = ECommandStatus.Failed
self._logger.error(
"Task all sent failed, taskid={} tasktype={}".format(
task.taskid, task.tasktype))
# 若全部子任务都已发送（不管发成功还是失败），且子任务没有发送成功的，
# 则更新总任务为失败，并返回回馈数据
if not self._dbmanager.update_idown_task_status(
task, ECommandStatus.Failed):
self._logger.error(
"Update task cmdstatus to {} faled: taskid:{}".format(
ECommandStatus.Failed.name, task.taskid))
# 失败，返回回馈数据
tb: TaskBack = TaskBack(task, ECommandStatus.Failed,
"任务执行失败，发送到采集端失败")
if not OutputManagement.output(tb):
self._logger.error(
"Write idown_task_back failed:\ntaskid:{}".format(
task.taskid))
except Exception as ex:
self._logger.error(
"Merge IDownTask status error:\nplatform:{}\ntaskid:{}\nerror:{}"
.format(task._platformm, task.taskid, ex.args))
self._dbmanager.update_idown_task_status(task,
ECommandStatus.Failed)
def write_iscoutback(
iscouttask: IscoutTask,
cmdstatus: ECommandStatus,
scoutrecvmsg: str,
currtime: str = None,
):
"""
通用方法编写iscantask的回馈
:param iscouttask:
:param cmdstatus:
:param scanrecvmsg:
:param currtime:
:return:
"""
if iscouttask is None:
raise Exception("Write iscantaskback iscantask cannot be None")
scanback = IscoutBtaskBack.create_from_task(iscouttask, cmdstatus,
scoutrecvmsg)
OutputManagement.output(scanback)
return
def _deal_data_back(self, tb: AutotaskBatchBack) -> bool:
"""处理TaskBatchBack数据"""
# ==================
# 更新指定的子任务的cmdstatus命令状态等字段
# 综合判断总任务是否完成或结束，
# 返回总任务完成进度或总任务最终结果
# 当总任务下的所有子任务的命令状态均为以下枚举值时
# Failed/Succeed/Cancelled/Timeout
# 判定为总任务已结束
# 子任务状态为 NeedSmsCode 时，需要在数据库添加
# 标记，以确认中心是否收到消息并下发了验证码，若长时间
# 未收到中心的验证码，且也未收到来自采集端的任务超时错误，
# 需要控制端进行超时处理（此时认为采集端的此条任务挂了？）
# ==================
res: bool = False
# 更新数据库子任务状态
currperiodnum = tb.periodnum
with self._dbmanager.get_automic_locker(
EDBAutomic.ReduplicateAutoTask):
task: AutomatedTask = self._dbmanager.get_auto_batch_task(
tb._platform, tb.taskid, tb.batchid)
if tb.periodnum < task.periodnum:
self._logger.error(
"AutotaskBatchBack periodnum({}) < task.periodnum({}) in db:\ntaskid:{}\nbatchid:{}"
.format(tb.periodnum, task.periodnum, task.taskid,
task.batchid))
return res
# if tb._sequence > task._sequence:
# 自循环任务不需要
if not self._deal_equal_period(tb, task):
return res
# 回传子任务回馈文件
if not OutputManagement.output(tb):
tb._cmdrcvmsg = "输出AutomatedTask子任务回馈数据失败"
self._logger.error(
"Output AutotaskBatchBackBack file to center failed:\ndata:{}\ntaskid:{}\nbatchid:{}"
.format(tb.inputdata.name, tb.taskid, tb.batchid))
return res
# 顺利跑到这里，子任务处理就是成功的了
tb.ok = True
self._logger.info(
"AutotaskBatchBackBack dealt [{} {}]:\ndata:{}\ntaskid:{}\nbatchid:{}\nperiodnum:{}"
.format(tb.cmdstatus.name, tb.progress, tb.inputdata.name,
tb.taskid, tb.batchid, currperiodnum))
self._tbqueue.put(task)
res = True
return res
def _deal_data_back(self, tb) -> bool:
"""处理IDownCmd命令回馈"""
res: bool = False
try:
if not isinstance(tb, IscanTaskBack):
self._logger.error(
"Invalid IscanTaskBack for cmdbackdeal: {}".format(
type(tb)))
return res
tb: IscanTaskBack = tb
# 判断周期数是否正确
task: IscanTask = self._dbmanager.get_iscantask(
tb._platform, tb._taskid)
if not isinstance(task, IscanTask):
self._logger.error(
"IscanTask not found in db:\ntaskid={}".format(tb._taskid))
return res
if tb.periodnum < task.periodnum:
self._logger.error(
"IScanTaskBack periodnum({}) < task.periodnum({}) in db:\ntaskid:{}"
.format(
tb.periodnum,
task.periodnum,
task.taskid,
))
return res
currperiodnum = tb.periodnum
# 更新数据库
# 只有当前序列号比数据库里面的大才去更新数据库，否则不需要更新，modify by judy 20201019
if tb._sequence > task._sequence:
if not self._deal_equal_period(tb, task):
return res
tb.periodnum = currperiodnum
# 发送回中心
if not OutputManagement.output(tb):
self._logger.error("Output IscanTaskBack to center failed.")
res = False
return res
self._logger.info(
"IScanTaskBack dealt [{} {}]:\ndata:{}\ntaskid:{}\nperiodnum:{}"
.format(tb.cmdstatus.name, tb.progress, tb.inputdata.name,
tb._taskid, currperiodnum))
res = True
except Exception:
self._logger.error("Deal IDownCmdBack error:\n{}\n {}".format(
tb, traceback.format_exc()))
return res
def _output_taskback(self, cmdback, status: ECommandStatus, msg: str):
if not isinstance(cmdback, CmdFeedBack):
self._logger.error(
"Invalid CmdFeedBack object for output CmdFeedBack: {}".format(
type(cmdback)))
return
cmdback: CmdFeedBack = cmdback
cmdback.cmdstatus = status
cmdback.cmdrcvmsg = msg
if not OutputManagement.output(cmdback):
self._logger.error("Output CmdFeedBack failed:\ncmdid={}".format(
cmdback.cmd_id))
def _write_task_back(self,
taskstatus: ECommandStatus,
description,
currenttime=None,
result=None):
"""
子类使用这个方法写回馈文件
:param taskstatus: EcommandStatus
:param description: 本次任务描述，必要
:return:
"""
if not isinstance(taskstatus, ECommandStatus):
raise Exception("Unknown taskstatus type!")
tginfo = TaskBatchBack.create_from_task(
self.task,
cmdstatus=taskstatus,
cmdrcvmsg=description,
result=result,
currenttime=currenttime,
)
OutputManagement.output(tginfo)
return
def _output_taskback(self, task: AutomatedTask, status: ECommandStatus,
msg: str):
if not isinstance(task, AutomatedTask):
self._logger.error(
"Invalid AutomatedTask object for output AutoTaskBack: {}".
format(type(task)))
return
task: AutomatedTask = task
taskback: AutotaskBack = AutotaskBack.create_from_task(
task, status, msg, helper_time.ts_since_1970_tz())
if not OutputManagement.output(taskback):
self._logger.error("Output AutoTaskBack failed: taskid={}".format(
task.taskid))
def _output_taskback(self, tb, status: ECommandStatus, msg: str):
"""返回总任务回馈"""
if not isinstance(tb, TaskBatchBack):
self._logger.error(
"Invalid task object for output taskback: {}".format(type(tb)))
return
tb: TaskBack = tb
tb.cmdstatus = status
tb.cmdrcvmsg = msg
if not OutputManagement.output(tb):
self._logger.error(
"Output TaskBack failed:\ntaskid={}\ndata={}".format(
tb._task.taskid, tb._task.inputdata._source))
def _output_taskback(self, task, status: ECommandStatus, msg: str):
"""返回总任务回馈"""
if not isinstance(task, Task):
self._logger.error(
"Invalid task object for output taskback: {}".format(
type(task)))
return
task: Task = task
taskback: TaskBack = TaskBack(task, status, msg)
if not OutputManagement.output(taskback):
self._logger.error(
"Output TaskBack failed:\ntaskid={}\ndata={}".format(
task.taskid, task.inputdata._source))
def _output_taskback(self, cmd: IdownCmd, status: ECommandStatus,
msg: str):
if not isinstance(cmd, IdownCmd):
self._logger.error(
"Invalid IDownCmd object for output CmdFeedBack: {}".format(
type(cmd)))
return
cmd: IdownCmd = cmd
cmdback: CmdFeedBack = CmdFeedBack.create_from_cmd(cmd, status, msg)
if not OutputManagement.output(cmdback):
self._logger.error(
"Output CmdFeedBack failed:\ncmdid={}\ndata={}".format(
cmd.cmd_id, cmd.inputdata._source))
def _deal_data_back(self, tb) -> bool:
"""处理IDownCmd命令回馈"""
res: bool = False
try:
if not isinstance(tb, CmdFeedBack):
self._logger.error(
"Invalid CmdFeedBack for cmdbackdeal: {}".format(type(tb)))
return res
tb: CmdFeedBack = tb
# 更新到数据库
# if tb._sequence > task._sequence:只有一个cmdback,不需要查询了
if not self._dbmanager.update_cmdback(tb):
self._logger.error(
"Update CmdFeedBack failed:\ncmdid:{}\nstatus:{}\nmsg:{}".
format(tb.cmd_id, tb.cmdstatus.name, tb.cmdrcvmsg))
tb.cmdrcvmsg = "合并更新命令状态失败"
return res
self._logger.info("CmdFeedBack ok, cmdid:{}, cmdstatus:{}".format(
tb.cmd_id, tb._cmdstatus.name))
# 检查，如果是分发到所有采集端的cmd任务，需要统计所有采集端的执行状态后
# 才能发回中心
status: ECommandStatus = self._dbmanager.get_cmd_merge_status(
tb.cmd_id, tb._platform)
if status == ECommandStatus.Dealing or status == ECommandStatus.Progress:
res = True
return res
tb.cmdstatus = status
tb.cmdrcvmsg = "命令执行成功"
# 发送回中心
if not OutputManagement.output(tb):
self._logger.error("Output CmdFeedBack to center failed.")
res = False
return res
self._logger.info(
"CmdFeedBack generated, cmdid:{}, cmdstatus:{}".format(
tb.cmd_id, tb._cmdstatus.name))
res = True
except Exception:
self._logger.error("Deal IDownCmdBack error:\n{}\n {}".format(
tb, traceback.format_exc()))
return res
