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_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 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 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 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 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 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 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 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 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
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 run_monkey(time, package_name): LogUtil.log_i('begin exec monkey') Monkey.run_monkey(time, package_name) LogUtil.log_i('monkey exec success')
def get_kpi_data(package_name, pic_name='kpi'): # 处理异常的kpi数据,当跳转时间大于3s(暂定) def handle_error_data(cost_time): if cost_time != '' and cost_time is not None: cost_time_value = handle_cost_time(cost_time) if cost_time_value > 3000: AdbUtil.screenshot(pic_name) # 因为从日志中得到的值都是 +345ms 或者 +1s234ms def handle_cost_time(cost_time): s_data = 0 ms_data = 0 s_result = re.findall(r'\ds', cost_time) if len(s_result) > 0: s_data = int(s_result[0].split('s')[0]) * 1000 ms_result = re.findall(r'\d\d\dms', cost_time) if len(ms_result) > 0: ms_data = int(ms_result[0].split('ms')[0]) return s_data + ms_data # 记录起始时间 global results start_time = time.mktime(time.localtime()) cmd = 'adb logcat -c && adb logcat -v time -s ActivityManager | findStr %s' % package_name try: results = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, shell=True) except Exception as e: LogUtil.log_e('get kpi failure ' + e.message) # 这里的逻辑是采集一定时间的数据之后,结束进程 jump_page = '' cost_time = '' now_page_name = '' # 采集数据的次数 get_count = 0 while True: LogUtil.log_i('get kpi data') if get_count > config.collect_data_count: if results.poll() is None: print 'results.terminate()' results.stdout.close() break # 2.读取内容,并分析 data = results.stdout.readline() print data # 处理读取到的String if data is not None: if 'Displayed' in data: # 1. 获取跳转页面的名称及时间,过滤 Displayed result = data.split('Displayed') result = result[1].strip().split(':') if len(result) < 1: jump_page = 'unknow' cost_time = 0 else: jump_page = result[0].split('/')[1] cost_time = result[1] # 2. 获取从哪个页面跳转 if 'Moving to STOPPED:' in data: now_page = data.split('Moving to STOPPED:') now_page = now_page[1].strip().split(' ') if len(now_page) > 3: now_page_name = now_page[2].split('/')[1] else: now_page_name = 'unknow' # 将结果保存到数组中 if now_page_name is not None and jump_page is not None and cost_time is not None: PerformanceControl.kpi_datas.append([now_page_name, jump_page, handle_cost_time(cost_time)]) handle_error_data(cost_time) get_count += 1
def run(self): log.log_i('begin exec monkey') Monkey.run_monkey(self.time, self.package_name) log.log_i('monkey exec success')
uid = battery_strs[0].strip() # 处理uid,查找出packagename if uid is not None and 'Uid' in uid: uid_uid = uid.split(' ')[1] if 'u0' in uid_uid: uid_uid = 'u0_' + uid_uid[2:] pkg_name = AdbUtil.get_package_name_by_uid(uid_uid) battery_str_data = battery_strs[1] battery_excel_data.append([uid, pkg_name, battery_str_data]) pkg_name = '' i += 1 return compute_drain, actual_drain, battery_excel_data def publish_battery_data(): if len(battery_excel_data) < 1: return version_code = AdbUtil.get_verson(package_name) BatteryData().save_db_data(battery_excel_data, package_name, version_code) if __name__ == '__main__': LogUtil.log_i('begin collect battery data.....') get_battery_data() LogUtil.log_i('begin save battery data.....') publish_battery_data() LogUtil.log_i('upload battery data.....') # # loadFile.upload_file(data_folder+'\\batterystats.txt', package_name, AdbUtil.get_verson(package_name)) # LogUtil.log_i('finish collect battery data.....')
def run(self): # 处理异常的kpi数据,当跳转时间大于3s(暂定) def handle_error_data(): if self.cost_time != '' and self.cost_time is not None: cost_time_value = handle_cost_time(self.cost_time) if cost_time_value > 3000: AdbUtil.screenshot(self.pic_name) GetKpiDataThread.kpi_error_datas.append([self.now_page_name, self.jump_page, self.cost_time, self.pic_name]) # 因为从日志中得到的值都是 +345ms 或者 +1s234ms def handle_cost_time(cost_time): s_data = 0 ms_data = 0 s_result = re.findall(r'\ds', cost_time) if len(s_result) > 0: s_data = int(s_result[0].split('s')[0]) * 1000 ms_result = re.findall(r'\d\d\dms', cost_time) if len(ms_result) > 0: ms_data = int(ms_result[0].split('ms')[0]) return s_data + ms_data # 记录起始时间 global results start_time = time.mktime(time.localtime()) cmd = 'adb logcat -c && adb logcat -v time -s ActivityManager | findStr %s' % self.package_name try: results = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, shell=True) except Exception as e: log.log_e('get kpi failure ' + e.message) # 这里的逻辑是采集一定时间的数据之后,结束进程 while True: log.log_i('get kpi data') # 1. 根据时间判断是否结束 now_time = time.mktime(time.localtime()) if now_time - start_time > config.collect_data_time: if results.poll() is None: print 'results.terminate()' results.stdout.close() break # 2.读取内容,并分析 data = results.stdout.readline() print data # 处理读取到的String if data is not None: if 'Displayed' in data: # 1. 获取跳转页面的名称及时间,过滤 Displayed result = data.split('Displayed') result = result[1].strip().split(':') if len(result) < 1: self.jump_page = 'unknow' self.cost_time = 0 else: self.jump_page = result[0].split('/')[1] self.cost_time = result[1] # 2. 获取从哪个页面跳转 if 'Moving to STOPPED:' in data: now_page = data.split('Moving to STOPPED:') now_page = now_page[1].strip().split(' ') if len(now_page) > 3: self.now_page_name = now_page[2].split('/')[1] else: self.now_page_name = 'unknow' # 将结果保存到数组中 if self.now_page_name is not None and self.jump_page is not None and self.cost_time is not None: GetKpiDataThread.kpi_datas.append([self.now_page_name, self.jump_page, self.cost_time]) handle_error_data() GetKpiDataThread.task_finish = True