def run_loaded_modules(self):
results = logger().Results
results.add_properties(self.properties())
if not self._list_tags: logger().log("[*] running loaded modules ..")
t = time.time()
for (modx, modx_argv) in self.Loaded_Modules:
test_result = TestCase(modx.get_name())
results.add_testcase(test_result)
logger().start_module(modx.get_name())
# Run the module
try:
result = self.run_module(modx, modx_argv)
except BaseException:
results.add_exception(modx)
result = module_common.ModuleResult.ERROR
if logger().DEBUG: logger().log_bad(traceback.format_exc())
if self.failfast: raise
# Module uses the old API display warning and try to run anyways
if result == module_common.ModuleResult.DEPRECATED:
logger().error(
'Module {} does not inherit BaseModule class'.format(
str(modx)))
# Populate results
test_result.add_result(module_common.getModuleResultName(result))
if modx_argv: test_result.add_arg(modx_argv)
logger().end_module(modx.get_name())
if self._json_out:
chipsec.file.write_file(self._json_out, results.json_full())
if self._xml_out:
chipsec.file.write_file(self._xml_out,
results.xml_full(self._xml_out))
if self._markdown_out:
chipsec.file.write_file(self._markdown_out,
results.markdown_full(self._markdown_out))
test_deltas = None
if self._deltas_file is not None:
prev_results = chipsec.result_deltas.get_json_results(
self._deltas_file)
if prev_results is None:
logger().error(
"Delta processing disabled. Displaying results summary.")
else:
test_deltas = chipsec.result_deltas.compute_result_deltas(
prev_results, results.get_results())
if test_deltas is not None:
chipsec.result_deltas.display_deltas(test_deltas, self.no_time, t)
elif not self._list_tags:
summary = results.order_summary()
logger().log(
"\n[CHIPSEC] *************************** SUMMARY ***************************"
)
if not self.no_time:
logger().log("[CHIPSEC] Time elapsed {:.3f}".format(
time.time() - t))
for k in summary.keys():
if k == 'total':
logger().log('[CHIPSEC] Modules {:16}{:d}'.format(
k, summary[k]))
elif k == 'warnings':
logger().log('[CHIPSEC] Modules with {:11}{:d}:'.format(
k, len(summary[k])))
for mod in summary[k]:
logger().log_warning(mod)
elif k == 'exceptions':
if len(summary[k]) > 0:
logger().log(
'[CHIPSEC] Modules with {:11}{:d}:'.format(
k, len(summary[k])))
for mod in summary[k]:
logger().error(mod)
else:
logger().log('[CHIPSEC] Modules {:16}{:d}:'.format(
k, len(summary[k])))
for mod in summary[k]:
if k == 'failed to run':
logger().error(mod)
elif k == 'passed':
logger().log_passed(mod)
elif k == 'information':
logger().log_information(mod)
elif k == 'failed':
logger().log_failed(mod)
elif k == 'not implemented':
logger().log_skipped(mod)
elif k == 'not applicable':
logger().log_not_applicable(mod)
logger().log(
'[CHIPSEC] *****************************************************************'
)
else:
logger().log("[*] Available tags are:")
for at in self.AVAILABLE_TAGS:
logger().log(" {}".format(at))
return results.get_return_code()
def run_loaded_modules(self):
results = logger().Results
results.add_properties(self.properties())
if not self._list_tags: logger().log( "[*] running loaded modules .." )
t = time.time()
for (modx,modx_argv) in self.Loaded_Modules:
test_result = TestCase(modx.get_name())
results.add_testcase(test_result)
logger().start_module( modx.get_name( ) )
# Run the module
try:
result = self.run_module( modx, modx_argv )
except BaseException:
results.add_exception(modx)
result = module_common.ModuleResult.ERROR
if logger().DEBUG: logger().log_bad(traceback.format_exc())
if self.failfast: raise
# Module uses the old API display warning and try to run anyways
if result == module_common.ModuleResult.DEPRECATED:
logger().error( 'Module %s does not inherit BaseModule class' % str(modx) )
# Populate results
test_result.add_result( module_common.getModuleResultName(result) )
if modx_argv: test_result.add_arg( modx_argv )
logger().end_module( modx.get_name() )
if self._json_out:
chipsec.file.write_file(self._json_out, results.json_full())
if self._xml_out:
chipsec.file.write_file(self._xml_out, results.xml_full(self._xml_out))
test_deltas = None
if self._deltas_file is not None:
prev_results = chipsec.result_deltas.get_json_results(self._deltas_file)
if prev_results is None:
logger().error("Delta processing disabled. Displaying results summary.")
else:
test_deltas = chipsec.result_deltas.compute_result_deltas(prev_results, results.get_results())
if test_deltas is not None:
chipsec.result_deltas.display_deltas(test_deltas, self.no_time, t)
elif not self._list_tags:
summary = results.order_summary()
logger().log( "\n[CHIPSEC] *************************** SUMMARY ***************************" )
if not self.no_time:
logger().log( "[CHIPSEC] Time elapsed {:.3f}".format(time.time()-t) )
for k in summary.keys():
if k == 'total':
logger().log( '[CHIPSEC] Modules {:16}{:d}'.format(k,summary[k]) )
elif k == 'warnings':
logger().log( '[CHIPSEC] Modules with {:11}{:d}:'.format(k,len(summary[k])) )
for mod in summary[k]:
logger().log_warning(mod)
elif k == 'exceptions':
if len(summary[k]) > 0:
logger().log( '[CHIPSEC] Modules with {:11}{:d}:'.format(k,len(summary[k])) )
for mod in summary[k]:
logger().error(mod)
else:
logger().log( '[CHIPSEC] Modules {:16}{:d}:'.format(k,len(summary[k])) )
for mod in summary[k]:
if k == 'failed to run':
logger().error(mod)
elif k == 'passed':
logger().log_passed(mod)
elif k == 'information':
logger().log_information(mod)
elif k == 'failed':
logger().log_failed(mod)
elif k == 'not implemented':
logger().log_skipped(mod)
elif k == 'not applicable':
logger().log_not_applicable(mod)
logger().log ('[CHIPSEC] *****************************************************************')
else:
logger().log( "[*] Available tags are:" )
for at in self.AVAILABLE_TAGS: logger().log(" {}".format(at))
return results.get_return_code()
def run_loaded_modules(self):
failed = []
errors = []
warnings = []
passed = []
skipped = []
exceptions = []
executed = 0
exit_code = ExitCode()
results = {}
if not self._list_tags: logger().log( "[*] running loaded modules .." )
t = time.time()
for (modx,modx_argv) in self.Loaded_Modules:
executed += 1
if not self._list_tags: logger().start_module( modx.get_name( ) )
# Run the module
try:
result = self.run_module( modx, modx_argv )
except BaseException:
exceptions.append( modx )
exit_code.exception()
result = module_common.ModuleResult.ERROR
if logger().DEBUG: logger().log_bad(traceback.format_exc())
if self.failfast: raise
# Module uses the old API display warning and try to run anyways
if result == module_common.ModuleResult.DEPRECATED:
exit_code.deprecated()
logger().error( 'Module %s does not inherit BaseModule class' % str(modx) )
# Populate results dictionary to export to JSON
r = {}
r['result'] = module_common.getModuleResultName(result)
if modx_argv: r['arg'] = modx_argv
results[modx.get_name()] = r
if not self._list_tags: logger().end_module( modx.get_name() )
if result is None or module_common.ModuleResult.ERROR == result:
errors.append( modx )
exit_code.error()
elif False == result or module_common.ModuleResult.FAILED == result:
failed.append( modx )
exit_code.fail()
elif True == result or module_common.ModuleResult.PASSED == result:
passed.append( modx )
elif module_common.ModuleResult.WARNING == result:
exit_code.warning()
warnings.append( modx )
elif module_common.ModuleResult.SKIPPED == result:
exit_code.skipped()
skipped.append( modx )
if self._json_out:
results_json = json.dumps(results, sort_keys=True, indent=2, separators=(',', ': '))
chipsec.file.write_file(self._json_out, results_json)
if not self._list_tags:
logger().log( "" )
logger().log( "[CHIPSEC] *************************** SUMMARY ***************************" )
if not self.no_time:
logger().log( "[CHIPSEC] Time elapsed %.3f" % (time.time()-t) )
logger().log( "[CHIPSEC] Modules total %d" % executed )
logger().log( "[CHIPSEC] Modules failed to run %d:" % len(errors) )
for mod in errors: logger().error( str(mod) )
logger().log( "[CHIPSEC] Modules passed %d:" % len(passed) )
for fmod in passed: logger().log_passed( str(fmod) )
logger().log( "[CHIPSEC] Modules failed %d:" % len(failed) )
for fmod in failed: logger().log_failed( str(fmod) )
logger().log( "[CHIPSEC] Modules with warnings %d:" % len(warnings) )
for fmod in warnings: logger().log_warning( str(fmod) )
logger().log( "[CHIPSEC] Modules skipped %d:" % len(skipped) )
for fmod in skipped: logger().log_skipped( str(fmod) )
if len(exceptions) > 0:
logger().log( "[CHIPSEC] Modules with Exceptions %d:" % len(exceptions) )
for fmod in exceptions: logger().error( str(fmod) )
logger().log( "[CHIPSEC] *****************************************************************" )
#logger().log( "[CHIPSEC] Version: %s"% self.version )
else:
logger().log( "[*] Available tags are:" )
for at in self.AVAILABLE_TAGS: logger().log(" %s"%at)
return exit_code.get_code()
def run_loaded_modules(self):
from chipsec.module_common import ModuleResult
failed = []
errors = []
warnings = []
passed = []
skipped = []
exceptions = []
executed = 0
exit_code = ExitCode()
results = {}
if not self._list_tags: logger().log("[*] running loaded modules ..")
t = time.time()
for (modx, modx_argv) in self.Loaded_Modules:
executed += 1
if not self._list_tags: logger().start_module(modx.get_name())
# Run the module
try:
result = self.run_module(modx, modx_argv)
except BaseException:
exceptions.append(modx)
exit_code.exception()
result = ModuleResult.ERROR
if logger().DEBUG: logger().log_bad(traceback.format_exc())
if self.failfast: raise
# Module uses the old API display warning and try to run anyways
if result == ModuleResult.DEPRECATED:
exit_code.deprecated()
logger().error('Module %s does not inherit BaseModule class' %
str(modx))
# Populate results dictionary to export to JSON
r = {}
r['result'] = module_common.getModuleResultName(result)
if modx_argv: r['arg'] = modx_argv
results[modx.get_name()] = r
if not self._list_tags: logger().end_module(modx.get_name())
if result is None or ModuleResult.ERROR == result:
errors.append(modx)
exit_code.error()
elif False == result or ModuleResult.FAILED == result:
failed.append(modx)
exit_code.fail()
elif True == result or ModuleResult.PASSED == result:
passed.append(modx)
elif ModuleResult.WARNING == result:
exit_code.warning()
warnings.append(modx)
elif ModuleResult.SKIPPED == result:
exit_code.skipped()
skipped.append(modx)
if self._json_out:
results_json = json.dumps(results,
sort_keys=True,
indent=2,
separators=(',', ': '))
chipsec.file.write_file(self._json_out, results_json)
if not self._list_tags:
logger().log("")
logger().log(
"[CHIPSEC] *************************** SUMMARY ***************************"
)
if not self.no_time:
logger().log("[CHIPSEC] Time elapsed %.3f" %
(time.time() - t))
logger().log("[CHIPSEC] Modules total %d" % executed)
logger().log("[CHIPSEC] Modules failed to run %d:" % len(errors))
for mod in errors:
logger().error(str(mod))
logger().log("[CHIPSEC] Modules passed %d:" % len(passed))
for fmod in passed:
logger().log_passed(str(fmod))
logger().log("[CHIPSEC] Modules failed %d:" % len(failed))
for fmod in failed:
logger().log_failed(str(fmod))
logger().log("[CHIPSEC] Modules with warnings %d:" % len(warnings))
for fmod in warnings:
logger().log_warning(str(fmod))
logger().log("[CHIPSEC] Modules skipped %d:" % len(skipped))
for fmod in skipped:
logger().log_skipped(str(fmod))
if len(exceptions) > 0:
logger().log("[CHIPSEC] Modules with Exceptions %d:" %
len(exceptions))
for fmod in exceptions:
logger().error(str(fmod))
logger().log(
"[CHIPSEC] *****************************************************************"
)
#logger().log( "[CHIPSEC] Version: %s"% self.get_chipsec_version() )
else:
logger().log("[*] Available tags are:")
for at in self.AVAILABLE_TAGS:
logger().log(" %s" % at)
return exit_code.get_code()
def run_loaded_modules(self):
failed = []
errors = []
warnings = []
passed = []
skipped = []
exceptions = []
information = []
notapplicable = []
executed = 0
exit_code = ExitCode()
results = {}
if not self._list_tags: logger().log("[*] running loaded modules ..")
t = time.time()
for (modx, modx_argv) in self.Loaded_Modules:
executed += 1
if not self._list_tags: logger().start_module(modx.get_name())
# Run the module
try:
result = self.run_module(modx, modx_argv)
except BaseException:
exceptions.append(modx)
exit_code.exception()
result = module_common.ModuleResult.ERROR
if logger().DEBUG: logger().log_bad(traceback.format_exc())
if self.failfast: raise
# Module uses the old API display warning and try to run anyways
if result == module_common.ModuleResult.DEPRECATED:
exit_code.deprecated()
logger().error('Module %s does not inherit BaseModule class' %
str(modx))
# Populate results dictionary to export to JSON
r = {}
r['result'] = module_common.getModuleResultName(result)
if modx_argv: r['arg'] = modx_argv
results[modx.get_name()] = r
if not self._list_tags: logger().end_module(modx.get_name())
if result is None or module_common.ModuleResult.ERROR == result:
errors.append(modx)
exit_code.error()
elif False == result or module_common.ModuleResult.FAILED == result:
failed.append(modx)
exit_code.fail()
elif True == result or module_common.ModuleResult.PASSED == result:
passed.append(modx)
elif module_common.ModuleResult.WARNING == result:
exit_code.warning()
warnings.append(modx)
elif module_common.ModuleResult.SKIPPED == result:
exit_code.skipped()
skipped.append(modx)
elif module_common.ModuleResult.INFORMATION == result:
information.append(modx)
elif module_common.ModuleResult.NOTAPPLICABLE == result:
exit_code.notapplicable()
notapplicable.append(modx)
if self._json_out:
results_json = json.dumps(results,
sort_keys=True,
indent=2,
separators=(',', ': '))
chipsec.file.write_file(self._json_out, results_json)
test_deltas = None
if self._deltas_file is not None:
prev_results = chipsec.result_deltas.get_json_results(
self._deltas_file)
if prev_results is None:
logger().error(
"Delta processing disabled. Displaying results summary.")
else:
test_deltas = chipsec.result_deltas.compute_result_deltas(
prev_results, results)
if test_deltas is not None:
chipsec.result_deltas.display_deltas(test_deltas, self.no_time, t)
elif not self._list_tags:
logger().log("")
logger().log(
"[CHIPSEC] *************************** SUMMARY ***************************"
)
if not self.no_time:
logger().log("[CHIPSEC] Time elapsed %.3f" %
(time.time() - t))
logger().log("[CHIPSEC] Modules total %d" % executed)
logger().log("[CHIPSEC] Modules failed to run %d:" % len(errors))
for mod in errors:
logger().error(str(mod))
logger().log("[CHIPSEC] Modules passed %d:" % len(passed))
for fmod in passed:
logger().log_passed(str(fmod))
logger().log("[CHIPSEC] Modules information %d:" %
len(information))
for fmod in information:
logger().log_information(str(fmod))
logger().log("[CHIPSEC] Modules failed %d:" % len(failed))
for fmod in failed:
logger().log_failed(str(fmod))
logger().log("[CHIPSEC] Modules with warnings %d:" % len(warnings))
for fmod in warnings:
logger().log_warning(str(fmod))
logger().log("[CHIPSEC] Modules not implemented %d:" %
len(skipped))
for fmod in skipped:
logger().log_skipped(str(fmod))
logger().log("[CHIPSEC] Modules not applicable %d:" %
len(notapplicable))
for fmod in notapplicable:
logger().log_not_applicable(str(fmod))
if len(exceptions) > 0:
logger().log("[CHIPSEC] Modules with Exceptions %d:" %
len(exceptions))
for fmod in exceptions:
logger().error(str(fmod))
logger().log(
"[CHIPSEC] *****************************************************************"
)
else:
logger().log("[*] Available tags are:")
for at in self.AVAILABLE_TAGS:
logger().log(" %s" % at)
return exit_code.get_code()
