def main_entrance(): # 1. 判断是否满足采集数据的条件 can_collect, tip_message = CollectData.can_collect_data(config.test_package_name) if not can_collect: print tip_message return # 2. 开启monkey monkey_thread = RunMonkeyThread(config.test_package_name, run_monkey_count) monkey_thread.start() # 3. 开始采集数据的逻辑 CollectData().auto_collect_data() # 4. 处理采集到的数据 CollectData().pre_process_data() # 5. 对处理之后的数据,写到db中 PublishData.publish_data() # # 4. 数据采集完成后,对采集到的数据处理并上报 # retry_count = 0 # while True: # task_finish = CollectData.task_all_finish() # if task_finish or retry_count > config.retry_count: # LogUtil.log_i('task finish') # LogUtil.log_i('begin record data') # # 5. 将数据记录下来 # CollectData.record_data() # break # time.sleep(config.collect_data_interval) # retry_count += 1 LogUtil.log_i('performance data collect success')
def auto_collect_data(self): try: # # 这里同时启动多个线程,会有问题,后面解决 # # 1. 开始采集kpi数据 # kpi_thread = GetKpiDataThread(self.KPI_THREAD_ID, config.test_package_name) # kpi_thread.start() # # # 2. 开始采集内存数据 # memory_thread = GetMemoryDataThread(self.MEMORY_THREAD_ID) # memory_thread.start() # # 3. 开始采集cpu数据 # cpu_thread = GetCpuDataThread(self.CPU_THREAD_ID) # cpu_thread.start() # 4. 开始采集帧率数据 fps_thread = GetFpsDataThread(self.FPS_THREAD_ID, config.test_package_name) fps_thread.start() fps_thread.join() # # # 5. 开始采集流量数据 # flow_thread = GetFlowDataThread(self.FLOW_THREAD_ID, config.test_package_name) # flow_thread.start() LogUtil.log_i('All thread worked!!') except Exception as e: LogUtil.log_e('collect data failure ' + e.message)
def get(self, *args, **kwargs): jsCode = self.get_argument('jsCode') nickName = self.get_argument('nickName') sign = self.get_argument('sign') time = self.get_argument('time') md5Util = MD5Util() if sign == md5Util.md5Signature(time): logging = LogUtil().getLogging() # logging.info('----> jsCode: ' + jsCode) # logging.info('----> nickName: ' + nickName) # logging.info('----> sign: ' + sign) # logging.info('----> time: ' + time) httpUrl = 'https://api.weixin.qq.com/sns/jscode2session' param = { "appid": WxToken.APP_ID, "secret": WxToken.APP_SECRET, "js_code": str(jsCode), "grant_type": 'authorization_code' } body = HttpUtil.http_get(httpUrl, params=param) jsonBody = json.loads(body, "utf8") if isinstance(jsonBody, dict): if jsonBody.has_key('openid'): jsonBody['result'] = True else: jsonBody['result'] = False # logging.info(type(jsonBody)) logging.info('--->session json: ' + str(jsonBody)) else: jsonBody = json.loads(u'校验失败', "utf8") self.write(jsonBody)
def get_fps_data(package_name, pic_name='fps'): # 处理可能有问题的场景 def handle_error_data(jank_count, fps): # 暂时当fps < 50 或者 jank_count > 10 我们认为是不达标的 if fps < 50 or jank_count > 10: # 截图 AdbUtil.screenshot(pic_name) # 保存日志 # 死循环,满足条件后跳出 exec_count = 0 while True: LogUtil.log_i('get fps data') # 判断执行了多少次 if exec_count > config.collect_data_count: break # 采集数据 frame_count, jank_count, fps = AndroidUtil.get_fps_data_by_gfxinfo(package_name) if frame_count is None and jank_count is None and fps is None: exec_count += 1 continue current_page = AndroidUtil.get_cur_activity() PerformanceControl.fps_datas.append([frame_count, jank_count, fps, current_page]) # 处理有问题的数据 handle_error_data(jank_count, fps) exec_count += 1 # 采集数据时间间隔 time.sleep(config.collect_data_interval)
def get(self, *args, **kwargs): page = int(self.get_argument('page')) size = int(self.get_argument('size')) sign = self.get_argument('sign') time = self.get_argument('time') logging = LogUtil().getLogging() baseResponse = BaseResponse() md5Util = MD5Util() if sign == md5Util.md5Signature(time): getCategory = GetCategory() homeDiscoverList = getCategory.getHomeDiscoverList(page_num=page, page_size=size) baseResponse.code = ResponseCode.op_success baseResponse.desc = ResponseCode.op_success_desc homeDiscoverCount = getCategory.getHomeDiscoverCount().get('count') logging.info('---> homeDiscoverCount: ' + str(homeDiscoverCount)) page_total = (homeDiscoverCount / size) + (1 if homeDiscoverCount % size > 0 else 0) baseResponse.pageNum = page baseResponse.pageSize = size baseResponse.page_total = page_total baseResponse.totalCount = homeDiscoverCount if homeDiscoverList: for homeDiscover in homeDiscoverList: baseResponse.append(homeDiscover) else: baseResponse.code = ResponseCode.fail_check_api_md5 baseResponse.desc = ResponseCode.fail_check_api_md5_desc json_str = json.dumps(baseResponse, cls=HomeDiscoverEncoder) self.write(json_str)
def run(self): # 处理有问题的流量数据,暂定有问题的流量是大于1M时 def handle_error_data(current_flow): if current_flow > 1 * 1024: current_page = AndroidUtil.get_cur_activity() AdbUtil.screenshot(self.pic_name) GetFlowDataThread.flow_error_datas.append( [current_flow, current_page, self.pic_name]) # 死循环,满足条件后跳出 exec_count = 0 while True: log.log_i('get flow data' + str(exec_count)) # 判断执行了多少次 if exec_count > config.collect_data_count: break # 采集数据 返回三个值,接收的流量、发送的流量、流量总数据,单位是KB flow_recv, flow_send, flow_total = AndroidUtil.get_flow_data( self.package_name) if exec_count > 0: self.current_flow_data = flow_total - self.last_flow_data GetFlowDataThread.flow_datas.append(self.current_flow_data) handle_error_data(self.current_flow_data) exec_count += 1 self.last_flow_data = flow_total # 时间间隔 time.sleep(config.collect_data_interval) GetFlowDataThread.task_finish = True
def get_flow_data(pic_name='flow'): # 处理有问题的流量数据,暂定有问题的流量是大于1M时 def handle_error_data(current_flow): if current_flow > 5 * 1024: # 异常处理 AdbUtil.screenshot(pic_name) # 死循环,满足条件后跳出 exec_count = 0 last_flow_data = 0 last_page_name = '' first_flow_data = 0 while True: LogUtil.log_i('get flow data' + str(exec_count)) # 判断执行了多少次 if exec_count > config.collect_data_count: __pre_flow_data() __publish_flow_data() break # if config.run_finish: # break # 采集数据 返回三个值,接收的流量、发送的流量、流量总数据,单位是KB flow_recv, flow_send, flow_total = AndroidUtil.get_flow_data( package_name) now_page_name = AndroidUtil.get_cur_activity() # print("flow_total" + str(flow_total)) # print ("last_flow_data" + str(last_flow_data)) # print ("first_flow_data" + str(first_flow_data)) # 这里计算每个页面的流量消耗情况 if exec_count <= 0: # 避免第一次少计算一次值造成误差 first_flow_data = flow_total elif exec_count < config.collect_data_count: if now_page_name == last_page_name: # last_flow_data = flow_total exec_count += 1 continue else: flow_increase = flow_total - first_flow_data handle_error_data(flow_increase) flow_datas.append([last_page_name, round(flow_increase, 2)]) first_flow_data = flow_total elif exec_count == config.collect_data_count: if last_page_name == now_page_name: flow_increase = flow_total - first_flow_data handle_error_data(flow_increase) flow_datas.append([now_page_name, round(flow_increase, 2)]) # 用于记录每次的流量增量 last_page_name = now_page_name exec_count += 1 # 时间间隔 time.sleep(config.collect_data_interval)
def decode(jsonData): """ 将 JSON 格式数据解析为 Python 数据 :param jsonData: JSON 格式数据 :return: Python 数据 """ try: return json.loads(jsonData) except Exception as err: LogUtil.e('JsonUtil decode 错误信息:', err) return None
def validate(apiKey: str): """ 验证用户的api key是否有效 :param apiKey: 用户的api key :return: True 有效用户 """ try: tinify.key = apiKey return tinify.validate() except tinify.Error as e: # Validation of API key failed. LogUtil.e('TinifyUtil Validation of API key failed. 错误信息:', e) return False
def start_test_task(): # 0. 先将全局结束开始标志重置 config.run_finish = False # 1. 判断是否满足采集数据的条件 can_collect, tip_message = Collecter.can_collect_data() if not can_collect: print(tip_message) return Collecter.clear_data() # 2. 开始采集数据的逻辑 Collecter.auto_collect_data_process() LogUtil.log_i('performance data collect success')
def randIntArray(num: int = 10, minValue: int = 1, maxValue: int = 100): """ 随机生成一组num数量的范围在【min,max】的int整数列表 :param num: 数量 :param minValue: 最小值 :param maxValue: 最大值 :return: 数字列表 """ data = [] while num > 0: num -= 1 data.append(random.randint(minValue, maxValue)) LogUtil.i("Random Int Array: ", data) return data
def get_cpu_data_silent(package_name, pic_name='cpu'): i = 0 while i < config.collect_data_count: LogUtil.log_i('Inspect cpu') current_page, cpu_data = AndroidUtil.get_cpu_data(package_name) # 当前采集到的数据 if cpu_data >= 50.00: AdbUtil.screenshot(pic_name) else: pass PerformanceControl.cpu_datas.append([current_page, cpu_data]) time.sleep(config.collect_data_interval) # 设定多久采集一次数据 i += 1 LogUtil.log_i('Inspect cpu finish')
def __init__(self): self.cateDao = CategoryDao() self.goodsDao = GoodsDao() self.brandDao = BrandDao() self.attrDao = AttributeDao() self.photoDao = GoodsPhotoDao() self.logging = LogUtil().getLogging()
def run(self): exec_count = 0 while True: LogUtil.log_i('Inspect cpu') if exec_count > config.collect_data_count: break current_page, cpu_datas = AndroidUtil.get_cpu_data(self.package_name)#当前采集到的数据 if cpu_datas >= 50.00: # 对错误进行处理 AdbUtil.screenshot(self.pic_name) else: pass GetCpuDataThread.cpu_datas.append([current_page, cpu_datas]) # 设定多久采集一次数据 time.sleep(config.collect_data_interval) exec_count += 1 LogUtil.log_i('Inspect cpu finish')
def start_silent_test(): # 1. 判断是否满足采集数据的条件 can_collect, tip_message = Collecter.can_collect_data() if not can_collect: print(tip_message) return # 2.将标志位设置为start config.run_silent_state = config.SlientState.START Collecter.clear_silent_data() # 3. 应用置于后台,灭屏 AndroidUtil.make_app_silent() Collecter.auto_silent_collect_process() LogUtil.log_i('silent performance data collect success')
def get(self, *args, **kwargs): sign = self.get_argument('sign') time = self.get_argument('time') logging = LogUtil().getLogging() baseResponse = BaseResponse() md5Util = MD5Util() if sign == md5Util.md5Signature(time): getAdverts = GetAdverts() netAdvertsList = getAdverts.getLastAdverts(6) logging.info("---> netAdvertsList: " + str(netAdvertsList)) baseResponse.code = ResponseCode.op_success baseResponse.desc = ResponseCode.op_success_desc baseResponse.data = netAdvertsList else: baseResponse.code = ResponseCode.fail_check_api_md5 baseResponse.desc = ResponseCode.fail_check_api_md5_desc json_str = json.dumps(baseResponse, cls=AdvertsEncoder) self.write(json_str)
def run(self): i = 0 pkgName = config.test_package_name while i < config.collect_data_count: LogUtil.log_i('Inspect cpu') cpudata = AndroidUtil.get_cpu_data(pkgName) #当前采集到的数据 if cpudata >= 50.00: cpuerror = cpudata self.CPUerror.append(cpuerror) AdbUtil.screenshot() else: pass self.CPUdata.append(cpudata) time.sleep(config.collect_data_interval) #设定多久采集一次数据 i += 1 print "CPUerror:", self.CPUerror, "CPUdata:", self.CPUdata GetCpuDataThread.task_finish = True LogUtil.log_i('Inspect cpu finish')
def get_silent_cpu_data(pic_name='silent_cpu'): exec_count = 0 while True: if exec_count > config.collect_data_count: __pre_silent_cpu_data() __publish_silent_cpu_data() break # if config.run_finish or config.run_silent_state == config.SlientState.FINISH: # break LogUtil.log_i('silent Inspect cpu') current_page, cpu_data = AndroidUtil.get_cpu_data( package_name) # 当前采集到的数据 if cpu_data >= 50.00: AdbUtil.screenshot(pic_name) else: pass cpu_datas_silent.append([current_page, cpu_data]) time.sleep(config.collect_data_interval) # 设定多久采集一次数据 exec_count += 1 LogUtil.log_i('silent Inspect cpu finish')
def get_memory_data(package_name, pic_name='memory'): i = 0 last_page_name = '' last_memory_data = 0 memory_increase = 0 while i < config.collect_data_count: LogUtil.log_i('Inspect memory') memory_data = int(AndroidUtil.get_memory_data(package_name)) # 当前采集到的数据 now_page_name = AndroidUtil.get_cur_activity() # 目前暂时粗略的计算增量,当页面不一样时,计算增量 if now_page_name != last_page_name: memory_increase = memory_data - last_memory_data if memory_increase < 0: # 对于发生GC的情况,内存增量可能是负值, 暂时先不做处理 pass PerformanceControl.memory_datas.append([now_page_name, last_page_name, memory_increase]) last_page_name = now_page_name else: last_memory_data = memory_data i += 1 continue # 内存增量大于某个值就认为是有问题 if memory_increase >= 10 * 1024: AdbUtil.screenshot(pic_name) LogUtil.log_i('Inspect memory 12') LogUtil.log_i('Inspect memory 13') # 设定多久采集一次数据 time.sleep(config.collect_data_interval) i += 1
def run(self): # 处理有问题的流量数据,暂定有问题的流量是大于1M时 def handle_error_data(current_flow): if current_flow > 1 * 1024: AdbUtil.screenshot(self.pic_name) # 死循环,满足条件后跳出 exec_count = 0 last_flow_data = 0 last_page_name = '' last_flow = 0 current_flow_data = 0 while True: log.log_i('get flow data' + str(exec_count)) # 判断执行了多少次 if exec_count > config.collect_data_count: break # 采集数据 返回三个值,接收的流量、发送的流量、流量总数据,单位是KB flow_recv, flow_send, flow_total = AndroidUtil.get_flow_data( self.package_name) now_page_name = AndroidUtil.get_cur_activity() if exec_count > 0: current_flow_data = flow_total - last_flow_data if now_page_name != last_page_name: flow_increase = current_flow_data - last_flow last_page_name = now_page_name GetFlowDataThread.flow_datas.append( [now_page_name, last_page_name, flow_increase]) handle_error_data(flow_increase) # 用于记录每次的流量增量 last_flow = current_flow_data exec_count += 1 last_flow_data = flow_total # 时间间隔 time.sleep(config.collect_data_interval)
def get_flow_data(package_name, pic_name='flow'): # 处理有问题的流量数据,暂定有问题的流量是大于1M时 def handle_error_data(current_flow): if current_flow > 5 * 1024: # 异常处理 AdbUtil.screenshot(pic_name) # 死循环,满足条件后跳出 exec_count = 0 last_flow_data = 0 last_page_name = '' last_flow = 0 current_flow_data = 0 while True: LogUtil.log_i('get flow data' + str(exec_count)) # 判断执行了多少次 if exec_count > config.collect_data_count: break # 采集数据 返回三个值,接收的流量、发送的流量、流量总数据,单位是KB flow_recv, flow_send, flow_total = AndroidUtil.get_flow_data(package_name) now_page_name = AndroidUtil.get_cur_activity() if exec_count > 0: current_flow_data = flow_total - last_flow_data if now_page_name != last_page_name: flow_increase = current_flow_data - last_flow last_page_name = now_page_name PerformanceControl.flow_datas.append([now_page_name, last_page_name, flow_increase]) handle_error_data(flow_increase) # 用于记录每次的流量增量 last_flow = current_flow_data exec_count += 1 # 用于计算每次采集流量增量 last_flow_data = flow_total # 时间间隔 time.sleep(config.collect_data_interval)
def get_memory_data(pic_name='memory'): exec_count = 0 while True: if exec_count > config.collect_data_count: __pre_memory_data() __publish_memory_data() break # if config.run_finish: # break LogUtil.log_i('Inspect memory' + str(exec_count)) memory_data = int( AndroidUtil.get_memory_data(package_name)) # 当前采集到的数据 now_page_name = AndroidUtil.get_cur_activity() memory_datas.append([now_page_name, memory_data]) # 内存增量大于某个值就认为是有问题 if memory_data >= 10 * 1024: AdbUtil.screenshot(pic_name) # 设定多久采集一次数据 time.sleep(config.collect_data_interval) exec_count += 1
def get_flow_silent(pic_name='silentflow'): # 处理有问题的流量数据,暂定有问题的流量是大于1M时 def handle_error_data(current_flow): if current_flow > 5 * 1024: # 异常处理 AdbUtil.screenshot(pic_name) # 死循环,满足条件后跳出 exec_count = 0 last_flow_data = 0 while True: LogUtil.log_i('get flow data' + str(exec_count)) # 判断执行了多少次 if exec_count > config.collect_data_count: __pre_silent_flow_data() __publish_silent_flow_data() break # if config.run_silent_state == config.SlientState.FINISH: # break # 采集数据 返回三个值,接收的流量、发送的流量、流量总数据,单位是KB flow_recv, flow_send, flow_total = AndroidUtil.get_flow_data( package_name) if exec_count > 0: now_page_name = AndroidUtil.get_cur_activity() current_flow_data = flow_total - last_flow_data flow_datas_silent.append([now_page_name, current_flow_data]) handle_error_data(current_flow_data) exec_count += 1 # 用于计算每次采集流量增量 last_flow_data = flow_total # 时间间隔 time.sleep(config.collect_data_interval)
def run(self): # 处理可能有问题的场景 def handle_error_data(frame_count, jank_count, fps, current_page): # 暂时当fps < 50 或者 jank_count > 10 我们认为是不达标的 if fps < 50 or jank_count > 10: # 截图 AdbUtil.screenshot(self.pic_name) # 保存日志 GetFpsDataThread.fps_error_datas.append([ frame_count, jank_count, fps, current_page, self.pic_name ]) # 死循环,满足条件后跳出 exec_count = 0 while True: log.log_i('get fps data') # 判断执行了多少次 if exec_count > config.collect_data_count: break # 采集数据 frame_count, jank_count, fps = AndroidUtil.get_fps_data_by_gfxinfo( self.package_name) if frame_count is None and jank_count is None and fps is None: exec_count += 1 continue current_page = AndroidUtil.get_cur_activity() GetFpsDataThread.fps_datas.append( [frame_count, jank_count, fps, current_page]) # 处理有问题的数据 handle_error_data(frame_count, jank_count, fps, current_page) exec_count += 1 # 采集数据时间间隔 time.sleep(config.collect_data_interval) GetFpsDataThread.task_finish = True
class WxBotUtil: def __init__(self, qr_code_path=def_qr_path): self.logging = LogUtil().getLogging() self.qr_code_path = def_qr_path self.call_times = 0 def __call__(self, *args, **kwargs): self.login() def login_callback(self): pass def qr_callback(self, **kwargs): uuid = kwargs['uuid'] status = kwargs['status'] qrcode = kwargs['qrcode'] # self.logging.info("---> uuid: " + uuid) # self.logging.info("---> status: " + status) # self.logging.info("---> qrcode: " + qrcode) # print "---> uuid: ", uuid # print "---> status: ", status # print "---> qrcode: ", qrcode if self.call_times < 3: with open(self.qr_code_path, 'wb') as qr_file: qr_file.write(qrcode) qr_file.close() NotifyAdmin().sendMsg(u'请网页扫码登陆运维微信', subject=SMS_SUBJECT_WX_LOGIN) self.call_times = self.call_times + 1 def login_by_thread(self): thr = threading.Thread(target=self.login) thr.start() thr.join() def login(self): # remove the qr_code.png first if os.path.exists(self.qr_code_path): self.logging.info("---> remove qr code: " + str(self.qr_code_path)) os.remove(self.qr_code_path) try: weichatListen = WeiChatListen(console_qr=True, qr_path=self.qr_code_path, qr_callback=self.qr_callback, login_callback=self.login_callback) # 启用puid weichatListen.bot.enable_puid('wxpy_puid.pkl') # my = weichatListen.bot.friends().search('asher')[0] # print weichatListen.bot.friends() my = weichatListen.bot.friends()[0] weichatListen.bot.self.add() weichatListen.bot.self.accept() weichatListen.listen(receivers=my) weichatListen.bot.join() except Exception as ex: self.logging.warn(ex) self.logging.warn("---> qr code exception: " + str(sys.exc_info()[0]))
def post(self, *args, **kwargs): logging = LogUtil().getLogging() param = self.request.body.decode('utf-8') param = json.loads(param) sign = param['sign'] time = param['time'] admin_tel = param['tel'] sms_pwd = param['sms'] permissionMgr = PermissionManager() baseResponse = permissionMgr.checkAdminPermissionWithLoginStatus(sign=sign, time=time, admin_tel=admin_tel, sms_pwd=sms_pwd) logging.info('baseResponse code: ', baseResponse.code) # 登录还在有效期内。 if baseResponse.code == ResponseCode.success_check_admin_permission: # 登录成功 baseResponse.code = ResponseCode.op_success baseResponse.desc = ResponseCode.op_success_desc baseResponse.data = u'恭喜! 系统登陆成功.' # 通知超管(我) admin_sms_msg = '用户 {tel} 已成功登陆后台系统.'.format(tel=admin_tel) notifyAdmin = NotifyAdmin() notifyAdmin.sendMsg(sms_msg=admin_sms_msg, subject=SMS_SUBJECT_LOGIN) notifyAdmin.sendWxMsg(msg=admin_sms_msg) elif baseResponse.code == ResponseCode.fail_admin_out_of_date \ or baseResponse.code == ResponseCode.fail_admin_login: adminMgr = AdminManager() loginResult = adminMgr.login(admin_tel=admin_tel, sms_pwd=sms_pwd) if loginResult: baseResponse.data = u'您已成功登录!' baseResponse.code = ResponseCode.op_success baseResponse.desc = ResponseCode.op_success_desc else: baseResponse.data = u'新密码已发送至手机, 请按新密码重新登录。' json_str = json.dumps(baseResponse, cls=StrEncoder) self.write(json_str)
def run(self): exec_count = 0 last_page_name = '' last_memory_data = 0 try: while True: LogUtil.log_i('Inspect memory') if exec_count > config.collect_data_count: break memory_data = int( AndroidUtil.get_memory_data(self.package_name)) #当前采集到的数据 now_page_name = AndroidUtil.get_cur_activity() # 目前暂时粗略的计算增量,当页面不一样时,计算增量 if now_page_name != last_page_name: memory_increase = memory_data - last_memory_data if memory_increase < 0: # 对于发生GC的情况,内存增量可能是负值, 暂时先不做处理 pass GetMemoryDataThread.memory_datas.append( [now_page_name, last_page_name, memory_increase]) last_page_name = now_page_name else: last_memory_data = memory_data exec_count += 1 continue # 内存增量大于某个值就认为是有问题 if memory_increase >= 10 * 1024: AdbUtil.screenshot(self.pic_name) LogUtil.log_i('Inspect memory 12') LogUtil.log_i('Inspect memory 13') # 设定多久采集一次数据 time.sleep(config.collect_data_interval) exec_count += 1 except Exception as e: LogUtil.log_e('get cpu error' + e.message)
def auto_silent_collect_process(): try: # 创建进程池来执行进程 common_data_list.append([package_name, version_code, '']) __save_package_version() # result = None pool = multiprocessing.Pool(processes=2) # result = pool.apply_async(run_monkey, (config.test_package_name(), RUN_MONKEY_COUNT,)) result = None for i in range(len(SILENT_ARRAY)): result = pool.apply_async(get_silent_data, (SILENT_ARRAY[i], )) pool.close() pool.join() if result.successful(): LogUtil.log_i('excute silent success') LogUtil.log_i('All silent process worked!!') except Exception as e: LogUtil.log_e('collect data failure ' + e.message)
def auto_collect_data_process(): try: # 获取测试应用的包名和版本号,存到数据库中 version_code = AdbUtil.get_verson(package_name) common_data_list.append([package_name, version_code, '']) __save_package_version() # 创建进程池来执行进程 # result = None pool = multiprocessing.Pool(processes=6) # result = pool.apply_async(run_monkey, (config.test_package_name(), RUN_MONKEY_COUNT,)) result = None for i in range(len(METHOD_ARRAY)): result = pool.apply_async(get_data, (METHOD_ARRAY[i], )) pool.close() pool.join() if result.successful(): LogUtil.log_i('excute success') LogUtil.log_i('All process worked!!') except Exception as e: LogUtil.log_e('collect data failure ' + e.message)
def __init__(self): self.brandDao = BrandDao() self.logging = LogUtil().getLogging() pass