openscap_report.cli.CommandLineAPI.__init__() - Code Metrics - Inspection of "Info about profile" - OpenSCAP/openscap-report - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#117)

by Jan

created 2022-11-14 09:23 UTC

openscap_report.cli.CommandLineAPI.init() A

↳ Parent: openscap_report.cli

Complexity

Conditions

Size

Total Lines	11
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	1

Importance

Changes

Metric	Value
eloc	11
dl	0
loc	11
ccs	11
cts	11
cp	1
rs	9.85
c	0
b	0
f	0
cc	1
nop	1
crap	1

# Copyright 2022, Red Hat, Inc.
# SPDX-License-Identifier: GPL-2.0-or-later

import argparse
import logging
from sys import exit as sys_exit
from sys import stdin, stdout

from lxml.etree import XMLSyntaxError

from . import __version__
from .debug_settings import DebugSetting
from .report_generators import (HTMLReportGenerator,
                                JSONEverythingReportGenerator,
                                JSONReportGenerator,
                                OldStyleHTMLReportGenerator)
from .scap_results_parser import SCAPResultsParser

DESCRIPTION = ("Generates an HTML report from an ARF (or XCCDF Result) file with results of "
               "a SCAP-compatible utility scan. Unless the --output option is specified "
               "the report will be written to the standard output.")
LOG_LEVELS_DESCRIPTION = """
LOG LEVELS:
    DEBUG - Detailed information, typically of interest only for diagnosing problems.

    INFO - A confirmation that things are working as expected.

    WARNING -  An indication that something unexpected happened, or a signal of a possible problem in the future. The software is still working as expected.

    ERROR - Due to a more serious problems, the software has not been able to perform its function to the full extent.

    CRITICAL - A serious error, indicating that the program itself may be unable to continue operating.
"""

DEBUG_FLAGS_DESCRIPTION = """
DEBUG FLAGS:
    NO-MINIFY - The HTML report will not be minified.

    BUTTON-SHOW-ALL-RULES - Adds a button to the HTML report for expanding all rules.

    ONLINE-CSS - Use the latest online version of Patternfly CSS/JS in the HTML report.

    BUTTON-SHOW-ALL-RULES-AND-OVAL-TEST-DETAILS - Adds a button to the HTML report for expanding all rules and all OVAL test details.
"""

MASSAGE_FORMAT = '%(levelname)s: %(message)s'
EXPECTED_ERRORS = (XMLSyntaxError, )
EXIT_FAILURE_CODE = 1
EXIT_SUCCESS_CODE = 0


class CustomHelpFormatter(argparse.RawTextHelpFormatter):
    def _format_action_invocation(self, action):
        if not action.option_strings:
            metavar, = self._metavar_formatter(action, action.dest)(1)
            return metavar

        parts = []
        if action.nargs == 0:
            parts.extend(action.option_strings)
        else:
            default = action.dest.upper()
            args_string = self._format_args(action, default)
            options_string = ", ".join(action.option_strings)
            parts.append(f'{options_string} {args_string}')
        return ',  '.join(parts)


def prepare_parser():
    parser = argparse.ArgumentParser(
        prog="oscap-report",
        formatter_class=CustomHelpFormatter,
        description=DESCRIPTION,
        add_help=False,
    )
    parser.add_argument(
        "--version",
        action="version",
        version="%(prog)s " + __version__,
        help="Show program's version number and exit.")
    parser.add_argument(
        '-h',
        '--help',
        action='help',
        default=argparse.SUPPRESS,
        help='Show this help message and exit.')
    parser.add_argument(
        'FILE',
        type=argparse.FileType("r"),
        nargs='?',
        default=stdin,
        help="ARF (XCCDF) file or stdin if not provided.")
    parser.add_argument(
        "-o",
        "--output",
        action="store",
        type=argparse.FileType("wb+", 0),
        default=stdout,
        help="write the report to a file instead of the standard output.")
    parser.add_argument(
        "--log-file",
        action="store",
        default=None,
        help="write the log to a file instead of stderr.")
    parser.add_argument(
        "--log-level",
        action="store",
        default="WARNING",
        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
        help=(
            "write debug information to the log up to the LOG_LEVEL."
            f"\n{LOG_LEVELS_DESCRIPTION}")
    )
    parser.add_argument(
        "-f",
        "--format",
        action="store",
        default="HTML",
        choices=["HTML", "OLD-STYLE-HTML", "JSON", "JSON-EVERYTHING"],
        help="FORMAT: %(choices)s"
    )
    parser.add_argument(
        "-d",
        "--debug",
        action="store",
        nargs='+',
        default=[""],
        choices=[
            "NO-MINIFY",
            "ONLINE-CSS",
            "BUTTON-SHOW-ALL-RULES",
            "BUTTON-SHOW-ALL-RULES-AND-OVAL-TEST-DETAILS"
        ],
        help=(
            "extra HTML generation options for debugging."
            f"\n{DEBUG_FLAGS_DESCRIPTION}")
    )
    return parser


class CommandLineAPI():  # pylint: disable=R0902
    def __init__(self):
        self.arguments = prepare_parser().parse_args()
        self.log_file = self.arguments.log_file
        self.log_level = self.arguments.log_level
        self.debug_flags = self.arguments.debug
        self._setup_logging()
        logging.debug("Args: %s", self.arguments)
        self.report_file = self.arguments.FILE
        self.output_file = self.arguments.output
        self.output_format = self.arguments.format.upper()
        self.debug_setting = DebugSetting()

    def _setup_logging(self):
        logging.basicConfig(
            format=MASSAGE_FORMAT,
            filename=self.log_file,
            filemode='w',
            level=self.log_level.upper()
        )

    def get_report_generator(self, report_parser):
        dict_of_report_generators = {
            "HTML": HTMLReportGenerator,
            "OLD-STYLE-HTML": OldStyleHTMLReportGenerator,
            "JSON": JSONReportGenerator,
            "JSON-EVERYTHING": JSONEverythingReportGenerator,
        }
        return dict_of_report_generators[self.output_format](report_parser)

    def generate_report(self, report_parser):
        logging.info("Generate report")
        report_generator = self.get_report_generator(report_parser)

        self.debug_setting.update_settings_with_debug_flags(self.debug_flags)

        return report_generator.generate_report(self.debug_setting)

    def load_file(self):
        logging.info("Loading file: %s", self.report_file)
        return self.report_file.read().encode()

    def store_file(self, data):
        logging.info("Store report")
        if self.output_file.name == "<stdout>":
            logging.info("Output is stdout, converting bytes output to str")
            data = data.read().decode("utf-8")
        self.output_file.writelines(data)

    def close_files(self):
        logging.info("Close files")
        self.report_file.close()
        self.output_file.close()


def main():
    exit_code = EXIT_SUCCESS_CODE
    api = CommandLineAPI()
    arf_report = api.load_file()

    logging.info("Parse file")
    try:
        parser = SCAPResultsParser(arf_report)

        report = api.generate_report(parser)

        api.store_file(report)
    except EXPECTED_ERRORS as error:
        logging.fatal("%s", error)
        exit_code = EXIT_FAILURE_CODE
    api.close_files()
    sys_exit(exit_code)


if __name__ == '__main__':
    main()


1		# Copyright 2022, Red Hat, Inc.
2		# SPDX-License-Identifier: GPL-2.0-or-later
3
4	1	import argparse
5	1	import logging
6	1	from sys import exit as sys_exit
7	1	from sys import stdin, stdout
8
9	1	from lxml.etree import XMLSyntaxError
10
11	1	from . import __version__
12	1	from .debug_settings import DebugSetting
13	1	from .report_generators import (HTMLReportGenerator,
14		JSONEverythingReportGenerator,
15		JSONReportGenerator,
16		OldStyleHTMLReportGenerator)
17	1	from .scap_results_parser import SCAPResultsParser
18
19	1	DESCRIPTION = ("Generates an HTML report from an ARF (or XCCDF Result) file with results of "
20		"a SCAP-compatible utility scan. Unless the --output option is specified "
21		"the report will be written to the standard output.")
22	1	LOG_LEVELS_DESCRIPTION = """
23		LOG LEVELS:
24		DEBUG - Detailed information, typically of interest only for diagnosing problems.
25
26		INFO - A confirmation that things are working as expected.
27
28		WARNING - An indication that something unexpected happened, or a signal of a possible problem in the future. The software is still working as expected.
29
30		ERROR - Due to a more serious problems, the software has not been able to perform its function to the full extent.
31
32		CRITICAL - A serious error, indicating that the program itself may be unable to continue operating.
33		"""
34
35	1	DEBUG_FLAGS_DESCRIPTION = """
36		DEBUG FLAGS:
37		NO-MINIFY - The HTML report will not be minified.
38
39		BUTTON-SHOW-ALL-RULES - Adds a button to the HTML report for expanding all rules.
40
41		ONLINE-CSS - Use the latest online version of Patternfly CSS/JS in the HTML report.
42
43		BUTTON-SHOW-ALL-RULES-AND-OVAL-TEST-DETAILS - Adds a button to the HTML report for expanding all rules and all OVAL test details.
44		"""
45
46	1	MASSAGE_FORMAT = '%(levelname)s: %(message)s'
47	1	EXPECTED_ERRORS = (XMLSyntaxError, )
48	1	EXIT_FAILURE_CODE = 1
49	1	EXIT_SUCCESS_CODE = 0
50
51
52	1	class CustomHelpFormatter(argparse.RawTextHelpFormatter):
53	1	def _format_action_invocation(self, action):
54		if not action.option_strings:
55		metavar, = self._metavar_formatter(action, action.dest)(1)
56		return metavar
57
58		parts = []
59		if action.nargs == 0:
60		parts.extend(action.option_strings)
61		else:
62		default = action.dest.upper()
63		args_string = self._format_args(action, default)
64		options_string = ", ".join(action.option_strings)
65		parts.append(f'{options_string} {args_string}')
66		return ', '.join(parts)
67
68
69	1	def prepare_parser():
70	1	parser = argparse.ArgumentParser(
71		prog="oscap-report",
72		formatter_class=CustomHelpFormatter,
73		description=DESCRIPTION,
74		add_help=False,
75		)
76	1	parser.add_argument(
77		"--version",
78		action="version",
79		version="%(prog)s " + __version__,
80		help="Show program's version number and exit.")
81	1	parser.add_argument(
82		'-h',
83		'--help',
84		action='help',
85		default=argparse.SUPPRESS,
86		help='Show this help message and exit.')
87	1	parser.add_argument(
88		'FILE',
89		type=argparse.FileType("r"),
90		nargs='?',
91		default=stdin,
92		help="ARF (XCCDF) file or stdin if not provided.")
93	1	parser.add_argument(
94		"-o",
95		"--output",
96		action="store",
97		type=argparse.FileType("wb+", 0),
98		default=stdout,
99		help="write the report to a file instead of the standard output.")
100	1	parser.add_argument(
101		"--log-file",
102		action="store",
103		default=None,
104		help="write the log to a file instead of stderr.")
105	1	parser.add_argument(
106		"--log-level",
107		action="store",
108		default="WARNING",
109		choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
110		help=(
111		"write debug information to the log up to the LOG_LEVEL."
112		f"\n{LOG_LEVELS_DESCRIPTION}")
113		)
114	1	parser.add_argument(
115		"-f",
116		"--format",
117		action="store",
118		default="HTML",
119		choices=["HTML", "OLD-STYLE-HTML", "JSON", "JSON-EVERYTHING"],
120		help="FORMAT: %(choices)s"
121		)
122	1	parser.add_argument(
123		"-d",
124		"--debug",
125		action="store",
126		nargs='+',
127		default=[""],
128		choices=[
129		"NO-MINIFY",
130		"ONLINE-CSS",
131		"BUTTON-SHOW-ALL-RULES",
132		"BUTTON-SHOW-ALL-RULES-AND-OVAL-TEST-DETAILS"
133		],
134		help=(
135		"extra HTML generation options for debugging."
136		f"\n{DEBUG_FLAGS_DESCRIPTION}")
137		)
138	1	return parser
139
140
141	1	class CommandLineAPI(): # pylint: disable=R0902
142	1	def __init__(self):
143	1	self.arguments = prepare_parser().parse_args()
144	1	self.log_file = self.arguments.log_file
145	1	self.log_level = self.arguments.log_level
146	1	self.debug_flags = self.arguments.debug
147	1	self._setup_logging()
148	1	logging.debug("Args: %s", self.arguments)
149	1	self.report_file = self.arguments.FILE
150	1	self.output_file = self.arguments.output
151	1	self.output_format = self.arguments.format.upper()
152	1	self.debug_setting = DebugSetting()
153
154	1	def _setup_logging(self):
155	1	logging.basicConfig(
156		format=MASSAGE_FORMAT,
157		filename=self.log_file,
158		filemode='w',
159		level=self.log_level.upper()
160		)
161
162	1	def get_report_generator(self, report_parser):
163		dict_of_report_generators = {
164		"HTML": HTMLReportGenerator,
165		"OLD-STYLE-HTML": OldStyleHTMLReportGenerator,
166		"JSON": JSONReportGenerator,
167		"JSON-EVERYTHING": JSONEverythingReportGenerator,
168		}
169		return dict_of_report_generators[self.output_format](report_parser)
170
171	1	def generate_report(self, report_parser):
172		logging.info("Generate report")
173		report_generator = self.get_report_generator(report_parser)
174
175		self.debug_setting.update_settings_with_debug_flags(self.debug_flags)
176
177		return report_generator.generate_report(self.debug_setting)
178
179	1	def load_file(self):
180	1	logging.info("Loading file: %s", self.report_file)
181	1	return self.report_file.read().encode()
182
183	1	def store_file(self, data):
184	1	logging.info("Store report")
185	1	if self.output_file.name == "<stdout>":
186		logging.info("Output is stdout, converting bytes output to str")
187		data = data.read().decode("utf-8")
188	1	self.output_file.writelines(data)
189
190	1	def close_files(self):
191	1	logging.info("Close files")
192	1	self.report_file.close()
193	1	self.output_file.close()
194
195
196	1	def main():
197		exit_code = EXIT_SUCCESS_CODE
198		api = CommandLineAPI()
199		arf_report = api.load_file()
200
201		logging.info("Parse file")
202		try:
203		parser = SCAPResultsParser(arf_report)
204
205		report = api.generate_report(parser)
206
207		api.store_file(report)
208		except EXPECTED_ERRORS as error:
209		logging.fatal("%s", error)
210		exit_code = EXIT_FAILURE_CODE
211		api.close_files()
212		sys_exit(exit_code)
213
214
215	1	if __name__ == '__main__':
216		main()
217

OpenSCAP / openscap-report

Pull Request — master (#117)

openscap_report.cli.CommandLineAPI.__init__() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

openscap_report.cli.CommandLineAPI.init() A