def DumpScreenOnOffLogs(WS): """ Dump screen on and off logs i.e display on off :param WS: Workspace object :return: True on sccess and False on failure """ try: f_power_logs_buf = open(WS.file_power_logs, 'w+') except IOError as err: error = 'failed to create power log file : ' + str(err) util.PLOGE(TAG, error) try: f_event_logs_buf = open(WS.file_event_logs, 'r') except IOError as err: error = 'failed to read event log file : ' + str(err) util.PLOGE(TAG, error) util.PrintLogFileTitle(f_power_logs_buf, 'Power logs') f_power_logs_buf.write('--- Screen ON and OFF ---') f_power_logs_buf.write(util.get_empty_line()) f_power_logs_buf.write(util.get_empty_line()) for line in f_event_logs_buf: if pattr.screen_on.search(line) or \ pattr.screen_off.search(line) : f_power_logs_buf.write(line) f_power_logs_buf.write(util.get_empty_line()) f_power_logs_buf.close() f_event_logs_buf.close()
def ExtractLogs(WS): """Extract data files """ try: f_bug_rpt = open(WS.file_bugreport, 'rU') except IOError as err: err_str = 'failed to open file : ' + \ WS.file_bugreport + '\n' + str(err) util.PLOGE(TAG, err_str) return False if not DumpBuildDetails(WS, f_bug_rpt): util.PLOGE(TAG, 'Failed to get build details') if not DumpUptime(WS, f_bug_rpt): util.PLOGE(TAG, 'Failed to get uptime logs') if not DumpKernelLogs(WS, f_bug_rpt): util.PLOGE(TAG, 'Failed to get kernel logs') if not DumpSystemLogs(WS, f_bug_rpt): util.PLOGE(TAG, 'Failed to get system logs') if not DumpEventLogs(WS, f_bug_rpt): util.PLOGE(TAG, 'Failed to get events logs') if not DumpRadioLogs(WS, f_bug_rpt): util.PLOGE(TAG, 'Failed to get radio logs') if not DumpVMtracesForNow(WS, f_bug_rpt): util.PLOGE(TAG, 'Failed to get VM traces for anr logs') if not DumpSysProp(WS, f_bug_rpt): util.PLOGE(TAG, 'Failed to get sys prop') if not DumpAccounts(WS, f_bug_rpt): util.PLOGE(TAG, 'failed to get account details') return True
def PrepareBugreportRawData(): """Extract bugreport.zip if bugreport is in zip format """ if not SetupWs(): util.PLOGE(TAG, 'failed to setup ws', exit=False) return False is_unzip_required, error = util.IsUnzipRequired(OPT.zip_file) if error: util.PLOGE( TAG, 'bugreport file type wrong, expected TEXT or ZIP ', exit=False) return False if is_unzip_required: util.PLOGV(TAG, 'Extracting ... : ' + OPT.file_name) with zipfile.ZipFile(OPT.zip_file, 'r') as bug_zip: try: bug_zip.extractall(WS.dir_ws) except zipfile.BadZipfile: util.PLOGE(TAG, 'Badzipfile', exit=False) return False except zipfile.LargeZipFile: util.PLOGE(TAG, 'LargeZipFile', exit=False) return False return True
def DumpPowerLogs(WS): """Dump power logs :param WS: WorkSpace object :return: True on Success and False on Failure """ try: f_power_logs_buf = open(WS.file_power_logs, 'a+') except IOError as err: error = 'failed to create power log file : ' + str(err) util.PLOGE(TAG, error) return False try: f_sys_logs_buf = open(WS.file_system_logs, 'r') except IOError as err: error = 'failed to read event log file : ' + str(err) util.PLOGE(TAG, error) return False try: f_kernel_logs_buf = open(WS.file_kernel_logs, 'r') except IOError as err: error = 'failed to read event log file : ' + str(err) util.PLOGE(TAG, error) return False f_power_logs_buf.write('--- PowerManager ---') f_power_logs_buf.write(util.get_empty_line()) f_power_logs_buf.write(util.get_empty_line()) for line in f_sys_logs_buf: if pattr.device_sys_sleep_power_button.search(line) or \ pattr.device_sys_sleep_screen_timeout.search(line) or \ pattr.device_sys_wake_up.search(line): f_power_logs_buf.write(line) f_power_logs_buf.write(util.get_empty_line()) f_power_logs_buf.write('--- Kernel ---') f_power_logs_buf.write(util.get_empty_line()) f_power_logs_buf.write(util.get_empty_line()) for line in f_kernel_logs_buf: if pattr.device_kernel_sleep.search(line) or \ pattr.device_sys_sleep_screen_timeout.search(line) or \ pattr.device_kernel_wakeup.search(line): f_power_logs_buf.write(line) f_power_logs_buf.write(util.get_empty_line()) f_power_logs_buf.close() f_sys_logs_buf.close() f_kernel_logs_buf.close() return True
def StartAnalysis(): """Check prerequisites, extract required logs and start analysis""" # check cmd line args if not CheckPrerequisite(): Usage() util.PLOGE(TAG, 'check prerequitsite failed', exit=True) if not PrepareBugreportRawData(): util.PLOGE(TAG, 'Prepare bugreport data failed', exit=True) if not SetFilesPath(): util.PLOGE(TAG, 'failed to set file path', exit=True) if not AnalyzeBugreport(): util.PLOGE(TAG, 'Failed to analyze bugreport', exit=True)
def DumpAccounts(WS, file_buf): """Dump Account information """ bool_start_dump = False try: f_accounts = open(WS.file_accounts, 'w+') except IOError as err: err_str = 'failed to create file : ' + WS.file_accounts + \ '\n' + str(err) util.PLOGE(TAG, err_str) return False f_accounts.write(util.get_line()) f_accounts.write('--- Accounts ---\n') f_accounts.write(util.get_line()) for line in file_buf: if bool_start_dump: f_accounts.write(line) if patt.start_accounts.search(line): bool_start_dump = True if patt.end_accounts.search(line): bool_start_dump = False break f_accounts.write(util.get_empty_line()) f_accounts.close() return True
def DumpUptime(WS, file_buf): """Dump uptime """ bool_start_dump = False try: f_other = open(WS.file_other, 'w+') except IOError as err: err_str = 'failed to create file : ' + WS.file_accounts + \ '\n' + str(err) util.PLOGE(TAG, err_str) return False f_other.write(util.get_line()) f_other.write('--- Other ---\n') f_other.write(util.get_line()) f_other.write(util.get_empty_line()) for line in file_buf: if bool_start_dump: f_other.write(line) if patt.start_uptime.search(line): f_other.write(line) bool_start_dump = True if patt.end_uptime.search(line): bool_start_dump = False break f_other.write(util.get_empty_line()) f_other.close() return True
def DumpKernelLogs(WS, file_buf): """Dump kernel logs """ bool_start_dump = False try: f_kernel_logs = open(WS.file_kernel_logs, 'w+') except IOError as err: err_str = 'failed to create file : ' + WS.file_kernel_logs + \ '\n' + str(err) util.PLOGE(TAG, err_str) return False f_kernel_logs.write(util.get_line()) f_kernel_logs.write('--- Kernel logs (dmesg) ---\n') f_kernel_logs.write(util.get_line()) for line in file_buf: # print line, if bool_start_dump: f_kernel_logs.write(line) if patt.start_kernel_log.search(line): bool_start_dump = True if patt.end_kernel_log.search(line): bool_start_dump = False break f_kernel_logs.write(util.get_empty_line()) f_kernel_logs.close() return True
def DumpVMtracesForNow(WS, file_buf): """Dump VM TRACES FOR NOW for anr """ bool_start_dump = False try: f_other = open(WS.file_anr_logs, 'w+') except IOError as err: err_str = 'failed to create file : ' + WS.file_anr_logs + \ '\n' + str(err) util.PLOGE(TAG, err_str) return False f_other.write(util.get_line()) f_other.write('--- VM TRACES FOR NOW for anr ---\n') f_other.write(util.get_line()) f_other.write(util.get_empty_line()) for line in file_buf: if bool_start_dump: f_other.write(line) if patt.start_anr_all.search(line): f_other.write(line) bool_start_dump = True if patt.end_anr_all.search(line): bool_start_dump = False break f_other.write(util.get_empty_line()) f_other.close() return True
def DumpSystemLogs(WS, file_buf): """ Dump system logs """ bool_start_dump = False try: f_sys_log_buf = open(WS.file_system_logs, 'w+') except IOError as err: err_str = 'failed to create file : ' \ + WS.file_system_logs + '\n' + str(err) util.PLOGE(TAG, err_str) return False f_sys_log_buf.write(util.get_line()) f_sys_log_buf.write('--- System logs ---\n') f_sys_log_buf.write(util.get_line()) for line in file_buf: if bool_start_dump: f_sys_log_buf.write(line) if patt.start_system_log.search(line): bool_start_dump = True if patt.end_system_log.search(line): bool_start_dump = False break # if bool_start_dump: # f_sys_log_buf.write(line) f_sys_log_buf.write(util.get_line()) f_sys_log_buf.close() return True
def DumpBuildDetails(WS, file_buf): """Dump build details """ try: f_build_details = open(WS.file_build_details, 'w+') except IOError as err: err_str = 'failed to create file : ' + \ WS.file_build_details + '\n' + str(err) util.PLOGE(TAG, err_str) return False f_build_details.write(util.get_line()) f_build_details.write('--- Build details ---\n') f_build_details.write(util.get_line()) for line in file_buf: if patt.start_of_file.match(line): continue if patt.start_dumpsys_meminfo.search(line): break f_build_details.write(line) f_build_details.write(util.get_empty_line()) f_build_details.close() return True
def DumpRadioLogs(WS, file_buf): """ Dump radio logs """ bool_start_dump = False try: f_radio_logs = open(WS.file_radio_logs, 'w+') except IOError as err: err_str = 'failed to create file : ' + WS.file_radio_logs + \ '\n' + str(err) util.PLOGE(TAG, err_str) return False f_radio_logs.write(util.get_line()) f_radio_logs.write('--- Radio logs ---\n') f_radio_logs.write(util.get_line()) for line in file_buf: if bool_start_dump: f_radio_logs.write(line) if patt.start_radio_log.search(line): bool_start_dump = True if patt.end_radio_log.search(line): bool_start_dump = False break f_radio_logs.write(util.get_empty_line()) f_radio_logs.close() return True
def AvcLogs(WS): """FilterAvcLogs : filter avc denied """ try: sys_log_buf = open(WS.file_event_logs, 'rU') except IOError as err: err_string = 'failed to read : ' + WS.file_system_logs + \ 'error : ' + err util.PLOGE(TAG, err_string) return False try: f_tmp_avc = open(temp_avc_file, 'w+') except IOError: util.PLOGE(TAG, 'failed to create : ' + temp_avc_file) return False for line in sys_log_buf: if not AVC_PATTERN in line: continue if not DENIED_PATTERN in line: continue if COMM_PATTERN in line or NAME_PATTERN in line: f_tmp_avc.write(line) split_list = line.split() for word in split_list: data = [] if 'comm=' in word or 'name=' in word: data = word.split('=') data[1] = data[1].strip('"') if data[0] == 'comm': if data[1] not in comm_list: comm_list.append(data[1]) elif data[0] == 'name': if data[1] not in name_list: name_list.append(data[1]) if 'scontext=' in word: data = word.split(':') if data[2] not in scontext_list: scontext_list.append(data[2]) sys_log_buf.close() f_tmp_avc.close() return comm_list, scontext_list
def GetAppCrashes(WS): """Dump application crash logs :param WS: WorkSpace object :return: True on Success and False on Failure """ try: f_system_log_buf = open(WS.file_system_logs, 'r') except IOError as err: errorString = "failed to read system logs " + \ str(err) util.PLOGE(errorString) return False try: f_app_crash_buf = open(WS.file_ws_system_app_crash, 'w+') except IOError as err: errorString = 'failed to create application crash log file ' + \ str(err) util.PLOGE(errorString) return False f_app_crash_buf.write(util.get_line()) f_app_crash_buf.write("--- Application crash ---") f_app_crash_buf.write(util.get_empty_line()) f_app_crash_buf.write(util.get_line()) f_app_crash_buf.write(util.get_empty_line()) found_crash = False for line in f_system_log_buf: if pattr.start_crash_application.search(line): found_crash = True f_app_crash_buf.write(util.get_empty_line()) f_app_crash_buf.write(util.get_line()) if pattr.end_crash_application.search(line): f_app_crash_buf.write(line) f_system_log_buf.close() f_app_crash_buf.close() if not found_crash: os.remove(WS.file_ws_system_app_crash) util.PLOGV(TAG, "Opps, No application crash") return True
def GetTempFile(): """Create temp file and open it and return fd. """ try: file_tmp = tmp.NamedTemporaryFile(delete=False) except IOError as err: util.PLOGE(TAG, "failed to create tmp file : " + err) return False util.PLOGV(TAG, str(file_tmp.name)) return file_tmp.name
def SetupWs(): """Setup workspace class object """ WS.dir_out = OPT.out WS.dir_ws = OPT.out + '/' + util.dir_ws WS.dir_ws_analysis = OPT.out + '/' + util.dir_ws_analysis WS.file_build_details = OPT.out + '/' + util.file_ws_analysis_build_details WS.file_kernel_logs = OPT.out + '/' + util.file_ws_analysis_kernel_logs WS.file_system_logs = OPT.out + '/' + util.file_ws_analysis_sys_logs WS.file_event_logs = OPT.out + '/' + util.file_ws_analysis_event_logs WS.file_radio_logs = OPT.out + '/' + util.file_ws_analysis_radio_logs WS.file_sys_prop = OPT.out + '/' + util.file_ws_analysis_sys_prop WS.file_devinfo = OPT.out + '/' + util.file_ws_analysis_devinfo WS.file_avc_logs = OPT.out + '/' + util.file_ws_analysis_avc_logs WS.file_power_logs = OPT.out + '/' + util.file_ws_analysis_power_logs WS.file_accounts = OPT.out + '/' + util.file_ws_analysis_accounts_logs WS.file_other = OPT.out + '/' + util.file_ws_analysis_other_logs # anr logs WS.dir_FS_data_anr = OPT.out + '/' + util.dir_ws_FS_data_anr WS.dir_analysis_anr = OPT.out + '/' + util.dir_ws_analysis_anr WS.file_anr_logs = OPT.out + '/' + util.file_ws_analysis_anr_logs # events logs WS.dir_ws_analysis_events = OPT.out + '/' + util.dir_ws_analysis_events WS.file_ws_events_JP_data = OPT.out + '/' + util.file_ws_events_JP_data WS.file_ws_events_am_proc_start = OPT.out + '/' + util.file_ws_events_am_proc_start WS.file_ws_events_am_proc_bound = OPT.out + '/' + util.file_ws_events_am_proc_bound WS.file_ws_events_am_proc_died = OPT.out + '/' + util.file_ws_events_am_proc_died WS.dir_ws_analysis_bypid = OPT.out + '/' + util.dir_ws_analysis_bypid # system logs WS.file_ws_system_native_crash = OPT.out + '/' + util.file_ws_system_native_crash WS.file_ws_system_app_crash = OPT.out + '/' + util.file_ws_system_app_crash WS.file_ws_system_anr = OPT.out + '/' + util.file_ws_system_anr # report WS.file_analysis_rpt = OPT.out + '/' + util.file_ws_analysis_rpt try: if os.path.exists(WS.dir_out): shutil.rmtree(WS.dir_out) os.makedirs(WS.dir_out) os.makedirs(WS.dir_ws) os.makedirs(WS.dir_ws_analysis) os.makedirs(WS.dir_ws_analysis_events) os.makedirs(WS.dir_ws_analysis_bypid) os.makedirs(WS.dir_analysis_anr) except os.error as err: util.PLOGE(TAG, str(err), exit=False) return False return True
def GetFileWithFilterData(src_file, pattr): """ Filter file data with given pattern :param src_file: file to be filter :param pattr: filter pattern :return: filtered content in file format """ temp_file = GetTempFile() if not temp_file: util.PLOGE(TAG, 'failed to get tmp file ') return False try: f_outfile = open(temp_file, 'w+') except Exception as err: util.PLOGE(TAG, "failed to create file : " + str(err)) return False with open(src_file, 'rU') as f_event_log: for line in f_event_log: if not pattr.search(line): continue f_outfile.write(line) f_event_log.close() f_outfile.close() return temp_file
def WriteToFile(file, buf): """Write given buffer to given file :param file: File name :param buf: data to be write :return: True on Success and False on Failure """ try: f_buf = open(file, 'a+') except IOError as err: util.PLOGE(TAG, 'failed write file : ' + str(err)) return False f_buf.write(buf) f_buf.close() return True
def main(): # Parse args if not ParseArgument(sys.argv): util.PLOGE(TAG, 'parse argument failed', exit=True) # start analysis StartAnalysis() # Generate report GenReport() # Dump file links to terminal DumpAnalysisPaths() time_str = "--- %s seconds ---" % (time.time() - start_time) util.PLOGD(TAG,time_str)
def DumpAnrForPid(WS, pid, pid_name): """Dump VM TRACES for given pid and pid_name :param WS: Workspace object :param pid: pid number :param pid_name: process name :return: True on Success and False on Failure """ filename = WS.dir_analysis_anr + '/' + pid + '_' + pid_name try: f_pid_anr = open(filename, 'w+') except IOError as err: errorString = 'failed to create anr log file ' + \ filename + ' ' + str(err) util.PLOGE(errorString) return False patt_start = re.compile("----- pid " + pid) patt_end = re.compile("----- end " + pid) isTraceFound = False with open(WS.file_anr_logs, 'r') as anr_logs: bool_start_dump = None for line in anr_logs: if bool_start_dump: f_pid_anr.write(line) if patt_start.search(line): f_pid_anr.write(line) isTraceFound = True bool_start_dump = True if patt_end.search(line): bool_start_dump = False break anr_logs.close() f_pid_anr.close() if not isTraceFound: os.remove(filename) return False return True
def DumpDevinfo(WS, dict_devinfo): """Dump device information """ try: f_devinfo = open(WS.file_devinfo, 'w+') except IOError as err: err_str = 'failed to create file : ' + WS.file_devinfo + \ str(err) util.PLOGE(TAG, err_str) return False f_devinfo.write(util.get_line()) f_devinfo.write('--- devinfo ---\n') f_devinfo.write(util.get_line()) for item in dict_devinfo: f_devinfo.write(util.get_empty_line()) f_devinfo.write(dict_devinfo[item]) f_devinfo.write(util.get_empty_line()) f_devinfo.close() return True
def CheckPrerequisite(): """Validate commandline args and check prerequisite """ if not OPT.file_name: util.PLOGE(TAG,'bug report file not given in termial command line ') return False if not OPT.out: util.PLOGE(TAG,'out dir not givent in terminal command line') return False patt_out = re.compile(r'^[.]') if patt_out.search(OPT.out): util.PLOGE(TAG,'out dir is a current or previous dir. please give name for dir') return False file_path = os.path.dirname(os.path.realpath(OPT.file_name)) util.PLOGV(TAG,'file : ' + file_path ) util.PLOGV(TAG,'out : ' + os.path.realpath(OPT.out)) if file_path == os.path.realpath(OPT.out): util.PLOGE(TAG,'out dir and file is in same dir. please give different dir') return False OPT.zip_file = os.path.abspath(OPT.file_name) if not os.path.isfile(OPT.zip_file): util.PLOGE(TAG, 'File not found or is not a file : ', OPT.zip_file, exit=False) return False is_unzip_required, error = util.IsUnzipRequired(OPT.zip_file) if error: util.PLOGE( TAG, 'bugreport file type wrong, expected TEXT or ZIP ', exit=False) return False else: util.PLOGV(TAG,'bugreport zip file found : ' + str(is_unzip_required)) return True
def GetAppAnr(WS): """Dump application ANR logs :param WS: WorkSpace object :return: True on Success and False on Failure """ anr_pid_dict = {} try: f_system_log_buf = open(WS.file_system_logs, 'r') except IOError as err: errorString = "failed to read system logs " + \ str(err) util.PLOGE(errorString) return False try: f_app_anr_buf = open(WS.file_ws_system_anr, 'w+') except IOError as err: errorString = 'failed to create application anr log file ' + \ str(err) util.PLOGE(errorString) return False f_app_anr_buf.write(util.get_line()) f_app_anr_buf.write("--- Application ANR ---") f_app_anr_buf.write(util.get_empty_line()) f_app_anr_buf.write(util.get_line()) f_app_anr_buf.write(util.get_empty_line()) found_crash = False pid_number = None process_name = None for line in f_system_log_buf: if pattr.start_anr_application.search(line): process_words = line.split(' E ') process_name = process_words[1].split().pop(3) found_crash = True f_app_anr_buf.write(util.get_empty_line()) f_app_anr_buf.write(util.get_line()) if found_crash and pattr.end_anr_application.search(line): if re.compile(r'ActivityManager: PID:').search(line): word_list = line.split() pid_number = word_list[len(word_list) - 1] anr_pid_dict[pid_number] = process_name pid_number = None process_name = None f_app_anr_buf.write(line) f_system_log_buf.close() f_app_anr_buf.close() if not found_crash: os.remove(WS.file_ws_system_anr) util.PLOGV(TAG, "Opps, No application ANR") for pid, pid_name in anr_pid_dict.iteritems(): if (pid and pid_name) is None: continue if not DumpAnrForPid(WS, pid, pid_name): util.PLOGE(TAG,"Failed to get or not found ANR traces for : " + \ str(pid) + ' - ' + str(pid_name)) return True
def GenReport(WS): """Create text report :param WS: WorkSpace object :return: True on Success and False on Failure """ try: mFile_rpt_buf = open(WS.file_analysis_rpt, 'w+') except IOError as err: errstring = 'failed to create file ' + WS.file_analysis_rpt \ + ' Err: ' + str(err) util.PLOGE(errstring) return False def WriteReportTitle(): mFile_rpt_buf.write(util.get_line()) mFile_rpt_buf.write('BUGREPORT ANALYSIS') mFile_rpt_buf.write(util.get_empty_line()) mFile_rpt_buf.write(util.get_line()) mFile_rpt_buf.write(util.get_empty_line()) mFile_rpt_buf.write(util.get_empty_line()) def PreapreTitle(title): return title + ' ' * (30 - len(title)) + ': ' def WriteTitleAndValue(title, value): mFile_rpt_buf.write(str(PreapreTitle(title))) mFile_rpt_buf.write(str(value)) mFile_rpt_buf.write(util.get_empty_line()) def WriteBugID(): WriteTitleAndValue('Bug ID', util.OPT.bug_num) def WriteBugTitle(): WriteTitleAndValue('Bug title', util.OPT.bug_title) def WriteDevEngineer(): WriteTitleAndValue('Dev Enginner', util.OPT.dev_name) def WriteTestEngineer(): WriteTitleAndValue('Test Enginner', util.OPT.tester_name) def WriteBuildDetails(): build_id = None with open(WS.file_build_details, 'r') as build: for line in build: if re.compile(r'Build:').search(line): build_id = line.split(':').pop(1) break build.close() WriteTitleAndValue('Build ID', build_id[1:]) def WriteDeviceDetails(): WriteTitleAndValue('Device info', '--->>>') with open(WS.file_devinfo, 'r') as device: for line in device: if re.compile(r'Device ').search(line): keyValue = line.split(': ') mFile_rpt_buf.write(keyValue[0].strip()) mFile_rpt_buf.write( str(' ' * (30 - len(keyValue[0].strip())))) mFile_rpt_buf.write(': ') mFile_rpt_buf.write(keyValue[1]) device.close() def WriteDeviceOwnerAndAccount(): user = None acc_list = [] with open(WS.file_accounts, 'r') as system: for line in system: email_match = re.search(r'([\w.-]+)@([\w.-]+)', line) if email_match: if email_match.group() not in acc_list: acc_list.append(email_match.group()) if re.compile(r'UserInfo').search(line): user = line.split(':')[1] WriteTitleAndValue('Device owner', user) WriteTitleAndValue('Device Accounts', '--->>>') for account in acc_list: mFile_rpt_buf.write((' ' * 32) + account) mFile_rpt_buf.write(util.get_empty_line()) system.close() def WriteUptime(): uptime = None uptime_found = False with open(WS.file_other, 'r') as other: for line in other: if uptime_found: uptime = line.split(',').pop(0).strip() break if pattr.start_uptime.search(line): uptime_found = True WriteTitleAndValue('Up time', uptime) other.close() def WriteNetwork(): network = None with open(WS.file_build_details, 'r') as build: for line in build: if re.compile(r'Network:').search(line): network = line.split(':').pop(1) break build.close() WriteTitleAndValue('Network', network[1:]) def WriteNativeCrash(): native_crash = False native_crash_list = [] cont = False if os.path.exists(WS.file_ws_system_native_crash): with open(WS.file_ws_system_native_crash) as native_crash_buf: for line in native_crash_buf: if cont or re.compile('F DEBUG : pid:').search(line): native_crash = True cont = True native_crash_list.append(line) if re.compile('F DEBUG : Abort message:').search(line): native_crash_list.append('#') cont = False WriteTitleAndValue('Native crash', '--->>>') mFile_rpt_buf.write(util.get_line()) for item in native_crash_list: if item == '#': mFile_rpt_buf.write(util.get_empty_line()) continue mFile_rpt_buf.write(item) native_crash_buf.close() if not native_crash: WriteTitleAndValue('Native crash', 'None') mFile_rpt_buf.write(util.get_line()) return def WriteApplicationCrash(): app_crash = None app_crash_list = [] cont = False if os.path.exists(WS.file_ws_system_app_crash): with open(WS.file_ws_system_app_crash) as app_crash_buf: for line in app_crash_buf: if cont or re.compile( 'E AndroidRuntime: FATAL EXCEPTION:').search(line): app_crash = True cont = True app_crash_list.append(line) if re.compile('E AndroidRuntime: android.os.').search(line) or \ re.compile('E AndroidRuntime: java.lang.').search(line): app_crash_list.append('#') cont = False WriteTitleAndValue('Application crash', '--->>>') mFile_rpt_buf.write(util.get_line()) if app_crash is not None: for item in app_crash_list: if item == '#': mFile_rpt_buf.write(util.get_empty_line()) continue mFile_rpt_buf.write(item) app_crash_buf.close() if app_crash is None: WriteTitleAndValue('Application crash', app_crash) mFile_rpt_buf.write(util.get_line()) return def WriteApplicationAnr(): app_anr = None app_anr_list = [] cont = False if os.path.exists(WS.file_ws_system_anr): with open(WS.file_ws_system_anr) as app_anr_buf: for line in app_anr_buf: if cont or re.compile('E ActivityManager: ANR in ').search( line): app_anr = True cont = True app_anr_list.append(line) if re.compile('E ActivityManager: Reason: ').search(line): app_anr_list.append('#') cont = False WriteTitleAndValue('Application ANR', '--->>>') mFile_rpt_buf.write(util.get_line()) if app_anr is not None: for item in app_anr_list: if item == '#': mFile_rpt_buf.write(util.get_empty_line()) continue mFile_rpt_buf.write(item) app_anr_buf.close() if app_anr is None: WriteTitleAndValue('Application ANR', app_anr) mFile_rpt_buf.write(util.get_line()) return # Create report WriteReportTitle() # WriteBugID() WriteBugTitle() WriteDevEngineer() WriteTestEngineer() WriteBuildDetails() WriteDeviceDetails() WriteDeviceOwnerAndAccount() WriteUptime() WriteNetwork() WriteNativeCrash() WriteApplicationCrash() WriteApplicationAnr() return True
def FilterByTagInFilesList(WS): """Extract the event log tags and create file of each tag with filtered data by that tag :param WS: workspace object :return: List of tags in event log """ def GetTag(tag, line): """ Fill tag object from line content :param tag: Tag class object :param line: event log line :return: None """ if not line: return False list_raw_words = str(line).split(': ') list_words = list_raw_words[0].split() tag.date = list_words[0] tag.time = list_words[1] tag.log_uid = list_words[2] tag.log_pid = list_words[3] tag.log_tid = list_words[4] tag.log_level = list_words[5] tag.tag_name = list_words[6] return True def WriteToFile(file, buf): """Write given buffer to given file :param file: File name :param buf: data to be write :return: True on Success and False on Failure """ try: f_buf = open(file, 'a+') except IOError as err: util.PLOGE(TAG, 'failed write file : ' + str(err)) return False f_buf.write(buf) f_buf.close() return True # Get list tag from event log list_tag = [] list_tag_files = [] try: f_buf = open(WS.file_event_logs, 'rU') except IOError as err: util.PLOGE(TAG, 'failed read file : ' + str(err)) return False # skip title lines for each in [1, 2, 3]: f_buf.readline() for line in f_buf: if pattr.end_event_log.search(line): break mTag = bugClasses.Tag() # get the tag if not GetTag(mTag, line): util.PLOGE(TAG, 'failed to get tag', exit=False) return False if not mTag.tag_name in list_tag: list_tag.append(str(mTag.tag_name)) if not mTag.tag_name in list_tag: continue # Create file with tag name file_name = os.path.abspath(WS.dir_ws_analysis_events + '/' + str(mTag.tag_name)) if not file_name in list_tag_files: list_tag_files.append(file_name) if not WriteToFile(file_name, line): continue f_buf.close() return list_tag_files
def FilterByPid(WS): """ Filter event logs by PID from am_start_proc filter :param WS: WorkSpace object :return:True on success and False on Failure """ tmpfile = filter.GetFileWithFilterData(WS.file_event_logs, pattr.am_proc_start) if (not tmpfile) or not (os.path.isfile(tmpfile)): util.PLOGE(TAG, 'failed to set filter') return False try: f_buf = open(tmpfile, 'r') except IOError as err: util.PLOGE(TAG, 'failed to read file : ' + str(err)) return False try: f_event_aps_buf = open(WS.file_ws_events_am_proc_start, 'w+') except IOError as err: util.PLOGE(TAG, 'failed to read file : ' + str(err)) return False process_data_aps_title = '##log_timestamp user pid uid name p_typ component data_aps' f_event_aps_buf.write(process_data_aps_title) f_event_aps_buf.write(util.get_empty_line()) # get all pid list from am_proc_start unwanted = re.compile(r'^[[]+') unwanted_1 = re.compile(r'[]\n]+$') list_jp_pid = [] for line_am_proc_start in f_buf: JP = util.JavaProcess() list_am_proc_start = str(line_am_proc_start).split(': ') list_aps_process_data = str(list_am_proc_start[1]).split(',') list_aps_time_data = str(list_am_proc_start[0]).split() for idx, item in enumerate(list_aps_process_data): if unwanted.search(item): list_aps_process_data[idx] = str(item).strip('[') if unwanted_1.search(item): list_aps_process_data[idx] = str(item).strip(']\n') JP.log_timestamp = str(list_aps_time_data[0]) + '_' + str( list_aps_time_data[1]) JP.user = list_aps_process_data[0] JP.pid = list_aps_process_data[1] JP.uid = list_aps_process_data[2] JP.name = list_aps_process_data[3] JP.p_type = list_aps_process_data[4] JP.component = list_aps_process_data[5] process_data_aps = str(JP.log_timestamp) + ' ' + \ str(JP.user) + ' ' + \ str(JP.pid) + ' ' + \ str(JP.uid) + ' ' + \ ' '* (6 - len(JP.uid)) + \ str(JP.name) + ' ' + \ ' '* (50 - len(JP.name)) + \ str(JP.p_type) + ' ' + \ ' '* (20 - len(JP.p_type)) + \ str(JP.component) # print process_data_aps f_event_aps_buf.write(process_data_aps) f_event_aps_buf.write(util.get_empty_line()) set_warning = None if not JP.pid in list_jp_pid: list_jp_pid.append(JP.pid) else: util.PLOGV(TAG, "The duplicate pid found : " + str(JP.pid)) set_warning = True list_jp_pid.append(JP.pid) pid_dir_name = WS.dir_ws_analysis_bypid + '/' + JP.pid file_jp_pid_events = pid_dir_name + '/' + 'events_' + JP.pid + '.txt' if not os.path.exists(pid_dir_name): os.makedirs(pid_dir_name) #Open main events file and check for current JP.pid util.PLOGV(TAG, " dump event data for : " + pid_dir_name) try: f_event_buf = open(WS.file_event_logs, 'rU') except IOError as err: error_str = 'failed to read event file for pid : ' + \ JP.pid + '\n' + str(err) util.PLOGE(TAG, error_str) return False try: f_jp_pid_events = open(file_jp_pid_events, 'a+') except IOError as err: error_str = 'failed to create file_jp_pid_events file for pid : ' + \ JP.pid + '\n' + str(err) util.PLOGE(TAG, error_str) return False if set_warning: msg_warn_L1 = "Warning *********************************************************** \n" msg_warn_L2 = "Warning ** The " + JP.pid + " might be dumplicate please check *** \n" msg_warn_L3 = "Warning *********************************************************** \n" util.PLOGV(TAG, msg_warn_L1) util.PLOGV(TAG, msg_warn_L2) util.PLOGV(TAG, msg_warn_L3) f_jp_pid_events.write(msg_warn_L1 + msg_warn_L2 + msg_warn_L3) set_warning = None msg_warn_L1 = None msg_warn_L2 = None msg_warn_L3 = None #skip title lines for each in [1, 2, 3]: f_event_buf.readline() for event_line in f_event_buf: if pattr.end_event_log.search(event_line): break mTag = evntClasses.Tag() if not GetEventTag(mTag, event_line): continue if not IsLineContainPid(JP.pid, event_line): continue f_jp_pid_events.write(event_line) f_event_buf.close() f_buf.close() f_event_aps_buf.close() util.clean_me(tmpfile)
def DumpSysProp(WS, file_buf): """Dump system properties """ def get_prop_val(prop): list_prop_val = str(prop).split(': [') # print list_prop_val return list_prop_val[1].strip('\n').strip(']') bool_start_dump = False try: f_sys_prop = open(WS.file_sys_prop, 'w+') except IOError as err: err_str = 'failed to create file : ' + WS.file_sys_prop + \ str(err) util.PLOGE(TAG, err_str) return False f_sys_prop.write(util.get_line()) f_sys_prop.write('--- system properties ---\n') f_sys_prop.write(util.get_line()) for line in file_buf: if bool_start_dump: f_sys_prop.write(line) if patt.start_sys_properties.search(line): bool_start_dump = True if patt.end_sys_properties.search(line): bool_start_dump = False break f_sys_prop.write(util.get_empty_line()) f_sys_prop.close() # dump device info at runtime try: f_sys_prop = open(WS.file_sys_prop, 'r') except IOError as err: err_str = 'failed to read file : ' + WS.file_sys_prop + str(err) util.PLOGE(TAG, err_str) return False dict_devinfo = { 'device_product_name': '', 'device_factory_serial_num': '', 'device_hw_serial_num': '', 'device_build_id': '', 'device_build_fingerprint': '', 'device_build_date': '', 'device_kernel_build_date': '', 'device_kernel_build_user': '', 'device_mpss_baseband1_build': '', 'device_mpss_baseband_build': '', 'device_gms_build': '', 'device_kernel_build_user': '', 'device_security_patch_level': '', 'device_slot_suffix': '' } for line in f_sys_prop: if patt.device_product_name.search(line): dict_devinfo[ 'device_product_name'] = 'Device product name : ' + get_prop_val( line) elif patt.device_factory_serial_num.search(line): dict_devinfo[ 'device_factory_serial_num'] = 'Device factory serial number : ' + get_prop_val( line) elif patt.device_hw_serial_num.search(line): dict_devinfo[ 'device_hw_serial_num'] = 'Device hardware serial number name : ' + get_prop_val( line) elif patt.device_build_id.search(line): dict_devinfo[ 'device_build_id'] = 'Device build id : ' + get_prop_val( line) elif patt.device_build_fingerprint.search(line): dict_devinfo[ 'device_build_fingerprint'] = 'Device build fingerprint : ' + get_prop_val( line) elif patt.device_build_date.search(line): dict_devinfo[ 'device_build_date'] = 'Device build date : ' + get_prop_val( line) elif patt.device_kernel_build_date.search(line): dict_devinfo[ 'device_kernel_build_date'] = 'Device kernel build date : ' + get_prop_val( line) elif patt.device_kernel_build_user.search(line): dict_devinfo[ 'device_kernel_build_user'] = '******' + get_prop_val( line) elif patt.device_mpss_baseband1_build.search(line): dict_devinfo[ 'device_mpss_baseband1_build'] = 'Device mpss baseband1 build : ' + get_prop_val( line) elif patt.device_mpss_baseband_build.search(line): dict_devinfo[ 'device_mpss_baseband_build'] = 'Device mpss baseband build : ' + get_prop_val( line) elif patt.device_gms_build.search(line): dict_devinfo[ 'device_gms_build'] = 'Device gms build : ' + get_prop_val( line) elif patt.device_kernel_build_user.search(line): dict_devinfo[ 'device_kernel_build_user'] = '******' + get_prop_val( line) elif patt.device_security_patch_level.search(line): dict_devinfo[ 'device_security_patch_level'] = 'Device product name : ' + get_prop_val( line) elif patt.device_slot_suffix.search(line): dict_devinfo[ 'device_slot_suffix'] = 'Device product name : ' + get_prop_val( line) else: continue f_sys_prop.close() util.PLOGV(TAG, dict_devinfo['device_product_name']) util.PLOGV(TAG, dict_devinfo['device_factory_serial_num']) util.PLOGV(TAG, dict_devinfo['device_hw_serial_num']) util.PLOGV(TAG, dict_devinfo['device_build_id']) util.PLOGV(TAG, dict_devinfo['device_build_fingerprint']) util.PLOGV(TAG, dict_devinfo['device_build_date']) util.PLOGV(TAG, dict_devinfo['device_kernel_build_date']) util.PLOGV(TAG, dict_devinfo['device_kernel_build_user']) util.PLOGV(TAG, dict_devinfo['device_mpss_baseband1_build']) util.PLOGV(TAG, dict_devinfo['device_mpss_baseband_build']) util.PLOGV(TAG, dict_devinfo['device_gms_build']) util.PLOGV(TAG, dict_devinfo['device_kernel_build_user']) util.PLOGV(TAG, dict_devinfo['device_security_patch_level']) util.PLOGV(TAG, dict_devinfo['device_slot_suffix']) if not DumpDevinfo(WS, dict_devinfo): util.PLOGE(TAG, 'Failed to dump devinfo') return True
def GenReport(): """Generate tiny text analysis report """ if not rpt.GenReport(WS): util.PLOGE(TAG,'failed to get report', exit=True)