def analyze(self, collector_results):
results = []
cpu_sorted_process_results = sorted(
filter(
lambda r: r.source == "process" and '%cpu' in r.output['top'],
collector_results),
key=lambda d: d.output['top']['%cpu'],
reverse=True)
for process_result in cpu_sorted_process_results[:ProcessCpuAnalyzer.
max_records]:
result = AnalyzerResult(
severity=AnalyzerResultSeverityPass,
other_results={"{severity}": '{cmdline:<55} {percent}%'})
if 'cmdline' in process_result.output and process_result.output[
'cmdline'] != '':
cmdline = process_result.output['cmdline']
else:
cmdline = process_result.output['status']['name']
cmdline_len = len(cmdline)
format_fields = {
'cmdline':
'{process}{elide}'.format(
process=cmdline[:50],
elide='...' if cmdline_len > 50 else ''),
'percent':
process_result.output['top']['%cpu']
}
result.collector_result = process_result
result.analyzer = self
result.format(format_fields)
results.append(result)
return results
def analyze(self, collector_results):
results = []
result_fields = {}
format_fields = {}
severity = None
for collector_result in collector_results:
if collector_result.source == "entries":
for entry in collector_result.output:
result = AnalyzerResult(
severity=AnalyzerResultSeverityPass,
other_results={
"{severity}": '{type:<12}{entry:<20} {size}'
})
format_fields = {
'entry':
entry,
'size':
support_diagnostics.utilities.SizeConversion.to_human(
collector_result.output[entry])
}
if os.path.isfile(entry):
format_fields['type'] = "file"
else:
format_fields['type'] = "directory"
result.collector_result = collector_result
result.analyzer = self
result.format(format_fields)
results.append(result)
return results
def analyze(self, collector_results):
results = []
result_fields = {}
format_fields = {}
severity = None
for collector_result in collector_results:
if collector_result.source in [
"hostname", 'version', 'uid', 'serial', 'model'
]:
result_fields = {
collector_result.source:
'{{{source}}}'.format(source=collector_result.source)
}
format_fields[
collector_result.source] = collector_result.output[0]
result = AnalyzerResult(severity=severity,
other_results=result_fields)
result.collector_result = collector_result
result.analyzer = self
result.format(format_fields)
results.append(result)
elif collector_result.source == "arch":
arch_result_fields = {'architecture': '{arch}'}
system_arch = collector_result.output[0]
# system_arch = 'armv7l'
arch = None
result = None
if system_arch == "x86_64":
arch = "64 bit x86"
result = AnalyzerResult(other_results=arch_result_fields)
else:
result = self.results['unsupported_arch'].copy()
if "86" in system_arch:
arch = "32 bit x86"
elif "arm" in system_arch:
arch = "ARM"
format_fields['arch'] = arch
result.collector_result = collector_result
result.analyzer = self
result.format(format_fields)
results.append(result)
return results
def analyze(self, collector_results):
results = []
memory_total = None
for result in filter(lambda r: r.source == "memory",
collector_results):
if "memtotal" in result.output:
memory_total = result.output["memtotal"]
memory_sorted_process_results = sorted(filter(
lambda r: r.source == "process" and 'vmrss' in r.output['status'],
collector_results),
key=lambda d: d.output['status']
['vmrss'],
reverse=True)
for process_result in memory_sorted_process_results[:
ProcessMemoryAnalyzer
.max_records]:
result = AnalyzerResult(
severity=AnalyzerResultSeverityPass,
other_results={
"{severity}": '{cmdline:<55} {size:<11} {percent:<.2f}%'
})
cmdline_len = len(process_result.output['cmdline'])
format_fields = {
'cmdline':
'{process}{elide}'.format(
process=process_result.output['cmdline'][:50],
elide='...' if cmdline_len > 50 else ''),
'size':
support_diagnostics.utilities.SizeConversion.to_human(
process_result.output['status']['vmrss']),
'percent':
round(
process_result.output['status']['vmrss'] / memory_total *
100, 2)
}
result.collector_result = process_result
result.analyzer = self
result.format(format_fields)
results.append(result)
return results