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
