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 __init__(self): self._logger: MsLogger = MsLogManager.get_logger("IdownClient") # 初始化sqlite, 最开始就初始化,因为需要存入数据和读取数据 DbManager() self._inputmanagement = InputManagement(inputconfig, self.on_data_in) # proxy代理池管理器 self._loaded_proxy_spiders = [] # self._init_proxy() # --------------------------------task相关 self._taskmanger = TaskManager() self._taskdownload = TaskDownload() self._cookie_keeper = TaskCookieAlive() self._clientcollect = CollectClientInfo() # 新增iscantask下载启动 self._iscandownload = ScanDownloadManager() # 新增iscouttask下载启动 self._iscoutdownload = ScoutDownloadManager() # 新增autotask下载启动 self._automateddownload = AutoTaskDownloadManager() # 新增删除程序产生无用文件 by judy 2020/08/20 self._dppf = DPPF() # 初始化输出器 OutputManagement.static_initial(outputconfig, stdconfig) # 任务启动开关 self.__switch = eval(basic_client_config.clientbusiness) self.all_business = EClientBusiness.ALL.value
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 _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 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 __init__(self): self._logger: MsLogger = MsLogManager.get_logger("idownserver") OutputManagement.static_initial(outputconfig, stdconfig) self._inputmanagement = InputManagement(inputconfig, self.on_data_in) self._servicemanager = ServiceManager() # 隔段时间就生成一次dicapp(dicapp后面可能会是动态的,因为采集端可能掉线,崩掉等) self._t_dicapp = threading.Thread(target=self._generate_dicapp, name='gen_dicapp', daemon=True)
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_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 _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 _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 _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 _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 _to_deliver(self, task: Task): """任务分类,分给各传输器""" try: succ: bool = False try: if not isinstance(task, Task): self._logger.error("Invalid task to_deliver") return if not isinstance(task._clientid, str) or task._clientid == "": self._logger.error( "Invalid clientid in task object while delivering task:\ntaskid:{}\nclientid:{}" .format(task.taskid, task._clientid)) return # 拿一下ip tmpclients = StatusMantainer.get_clientstatus_id_sorted() targetclient: Client = tmpclients.get(task._clientid, None) if not isinstance(targetclient, Client): self._logger.error( "Unknown client for task deliver:\nclientid:{}\ntaskid:{}\ntasktype:{}" .format(task._clientid, task.taskid, task.tasktype.name)) return # 传输给client ########## # 逻辑为: # 1. 事先并不知道分配给哪个采集端。 # 2. 从数据库读取一条子任务,task任务对象有其被分配到的采集端的clientid。 # 3. 根据task的clientid,和StatusMantainer的clients对象,找到目标client的clientip # 4. 根据clientip和当前TaskDeliver中配置的ip->目录配置,将任务task对象发送到 # 指定目录(走文件) # 5. 或根据配置若走直连传输,则通过clientid找到对应采集端的地址并发送。 ########## if not self._config._ipdir.__contains__( targetclient._statusbasic.ip): self._logger.error( "Client transfer folder not configured: clientip={}". format(targetclient._statusbasic.ip)) else: targetdir = self._config._ipdir[ targetclient._statusbasic.ip] succ = OutputManagement.output_to_file(task, targetdir) finally: with self._dbmanager.get_automic_locker( EDBAutomic.ReduplicateTask): self._update_to_db(task, targetclient, succ) self._merge_task_status(task) except Exception: self._logger.error("to_deliver error: taskid:{} error:{}".format( task.taskid, traceback.format_exc()))
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 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 _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 _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 _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 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 _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, 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 _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 _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))