JSON output [5]

.gitignore

@@ -21,3 +21,4 @@ stats
 
 *.log
 report*.html
+report*.json

openscap_report/cli.py

@@ -10,8 +10,10 @@
 
 from . import __version__
 from .debug_settings import DebugSetting
-from .html_report import ReportGenerator
-from .old_html_report_style import OldOSCAPReportGenerator
+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 "
@@ -114,7 +116,7 @@ def prepare_parser():
         "--format",
         action="store",
         default="HTML",
-        choices=["HTML", "OLD-STYLE-HTML"],
+        choices=["HTML", "OLD-STYLE-HTML", "JSON", "JSON-EVERYTHING"],
         help="FORMAT: %(choices)s"
     )
     parser.add_argument(
@@ -157,16 +159,22 @@ def _setup_logging(self):
             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")
-        if self.output_format == "OLD-STYLE-HTML":
-            report_generator = OldOSCAPReportGenerator(report_parser)
-            return report_generator.generate_html_report()
-        report_generator = ReportGenerator(report_parser)
+        report_generator = self.get_report_generator(report_parser)
 
         self.debug_setting.update_settings_with_debug_flags(self.debug_flags)
 
-        return report_generator.generate_html_report(self.debug_setting)
+        return report_generator.generate_report(self.debug_setting)
 
     def load_file(self):
         logging.info("Loading file: %s", self.report_file)

openscap_report/html_report/__init__.py → openscap_report/report_generators/__init__.py

@@ -2,4 +2,7 @@
 # SPDX-License-Identifier: LGPL-2.1-or-later
 
 from .exceptions import FilterNotSupportDataStructureException
+from .html import HTMLReportGenerator
+from .json import JSONEverythingReportGenerator, JSONReportGenerator
+from .old_style_html import OldStyleHTMLReportGenerator
 from .report_generator import ReportGenerator

openscap_report/html_report/report_generator.py → openscap_report/report_generators/html.py

@@ -18,20 +18,21 @@
 
 from ..scap_results_parser.data_structures import Rule
 from .exceptions import FilterNotSupportDataStructureException
+from .report_generator import ReportGenerator
 
 
-class ReportGenerator():
-    def __init__(self, parser):
+class HTMLReportGenerator(ReportGenerator):
+    def __init__(self, parser):  # pylint: disable=W0231
         self.report = parser.parse_report()
-        self.file_loader = FileSystemLoader(str(Path(__file__).parent / "templates"))
+        self.file_loader = FileSystemLoader(str(Path(__file__).parent / "html_templates"))
         self.env = Environment(loader=self.file_loader)
         self.env.globals['include_file_in_base64'] = self.include_file_in_base64
         self.env.filters['set_css_for_list'] = self.set_css_for_list
         self.env.filters['get_selected_rules'] = self.get_selected_rules
         self.env.trim_blocks = True
         self.env.lstrip_blocks = True
 
-    def generate_html_report(self, debug_setting):
+    def generate_report(self, debug_setting):
         template = self.env.get_template("template_report.html")
         html_report = template.render(report=self.report, debug_setting=debug_setting)
         if debug_setting.no_minify:

openscap_report/report_generators/json.py

@@ -0,0 +1,25 @@
+# Copyright 2022, Red Hat, Inc.
+# SPDX-License-Identifier: LGPL-2.1-or-later
+import json
+import logging
+from io import BytesIO
+
+from .report_generator import ReportGenerator
+
+
+class JSONReportGenerator(ReportGenerator):
+    def __init__(self, parser):
+        super().__init__(parser)
+        self.get_report_dict = self.report.as_dict_for_default_json
+
+    def generate_report(self, debug_setting):
+        logging.warning("JSON Format is experimental output!")
+        indent = "\t" if debug_setting.no_minify else None
+        json_data = json.dumps(self.get_report_dict(), indent=indent)
+        return BytesIO(json_data.encode())
+
+
+class JSONEverythingReportGenerator(JSONReportGenerator):
+    def __init__(self, parser):
+        super().__init__(parser)
+        self.get_report_dict = self.report.as_dict

openscap_report/old_html_report_style/report_generator.py → openscap_report/report_generators/old_style_html.py

@@ -6,16 +6,18 @@
 
 from lxml import etree
 
+from .report_generator import ReportGenerator
+
 XSL_DIR = Path(__file__).parent / "xsl"
 
 
-class ReportGenerator():
-    def __init__(self, parser):
+class OldStyleHTMLReportGenerator(ReportGenerator):
+    def __init__(self, parser):  # pylint: disable=W0231
         self.xml_report = parser.root
         self.xslt_doc = etree.parse(str(XSL_DIR / "xccdf-report.xsl"))
         self.xslt_transformer = etree.XSLT(self.xslt_doc)
 
-    def generate_html_report(self):
+    def generate_report(self, debug_setting):
         html_report = self.xslt_transformer(self.xml_report)
         result_html = etree.tostring(
             html_report,
@@ -25,5 +27,5 @@ def generate_html_report(self):
             standalone=False,
             with_tail=False,
             method="html",
-            pretty_print=False)
+            pretty_print=debug_setting.no_minify)
         return BytesIO(result_html)

openscap_report/report_generators/report_generator.py

@@ -0,0 +1,13 @@
+# Copyright 2022, Red Hat, Inc.
+# SPDX-License-Identifier: LGPL-2.1-or-later
+
+from abc import ABC, abstractmethod
+
+
+class ReportGenerator(ABC):
+    def __init__(self, parser):
+        self.report = parser.parse_report()
+
+    @abstractmethod
+    def generate_report(self, debug_setting):
+        raise NotImplementedError

openscap_report/scap_results_parser/data_structures/__init__.py

@@ -2,11 +2,13 @@
 # SPDX-License-Identifier: LGPL-2.1-or-later
 
 from .group import Group
+from .identifier import Identifier
 from .oval_node import OvalNode
 from .oval_object import OvalObject
 from .oval_result_eval import (EMPTY_RESULT, FULL_RESULT_TO_SHORT_RESULT,
                                SHORT_RESULT_TO_FULL_RESULT, OvalResult)
 from .oval_test import OvalTest
+from .reference import Reference
 from .remediation import Remediation
 from .report import Report
 from .rule import Rule

openscap_report/scap_results_parser/data_structures/group.py

@@ -1,33 +1,17 @@
 # Copyright 2022, Red Hat, Inc.
 # SPDX-License-Identifier: LGPL-2.1-or-later
 
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass, field
 
 
 @dataclass
 class Group:
-    group_id: str = ""
+    group_id: str
     title: str = ""
     description: str = ""
-    platforms: list = None
-    rules_ids: list = None
-    sub_groups: list = None
+    platforms: list[str] = field(default_factory=list)
+    rules_ids: list[str] = field(default_factory=list)
+    sub_groups: list['Group'] = field(default_factory=list)
 
     def as_dict(self):
-        if not self.sub_groups:
-            return {
-                "group_id": self.group_id,
-                "title": self.title,
-                "description": self.description,
-                "platforms": self.platforms,
-                "rules_ids": self.rules_ids,
-                "sub_groups": None,
-            }
-        return {
-            "group_id": self.group_id,
-            "title": self.title,
-            "description": self.description,
-            "platforms": self.platforms,
-            "rules_ids": self.rules_ids,
-            "sub_groups": [sub_group.as_dict() for sub_group in self.sub_groups],
-        }
+        return asdict(self)

openscap_report/scap_results_parser/data_structures/identifier.py

@@ -0,0 +1,13 @@
+# Copyright 2022, Red Hat, Inc.
+# SPDX-License-Identifier: LGPL-2.1-or-later
+
+from dataclasses import asdict, dataclass
+
+
+@dataclass
+class Identifier:
+    system: str
+    text: str
+
+    def as_dict(self):
+        return asdict(self)

openscap_report/scap_results_parser/data_structures/oval_node.py

@@ -4,7 +4,7 @@
 import json
 import logging
 from collections import Counter
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass, field
 
 from .oval_result_eval import (EMPTY_RESULT, FULL_RESULT_TO_SHORT_RESULT,
                                SHORT_RESULT_TO_FULL_RESULT, OvalResult)
@@ -19,31 +19,11 @@ class OvalNode:  # pylint: disable=R0902
     negation: bool = False
     comment: str = ""
     tag: str = ""
-    children: list = None
+    children: list['OvalNode'] = field(default_factory=list)
     test_info: OvalTest = None
 
     def as_dict(self):
-        if not self.children:
-            return {
-                'node_id': self.node_id,
-                'node_type': self.node_type,
-                'value': self.value,
-                'negation': self.negation,
-                'comment': self.comment,
-                'tag': self.tag,
-                'test_info': self.test_info.as_dict(),
-                'children': None
-            }
-        return {
-            'node_id': self.node_id,
-            'node_type': self.node_type,
-            'value': self.value,
-            'negation': self.negation,
-            'comment': self.comment,
-            'tag': self.tag,
-            'test_info': None,
-            'children': [child.as_dict() for child in self.children]
-        }
+        return asdict(self)
 
     def as_json(self):
         return json.dumps(self.as_dict())

openscap_report/scap_results_parser/data_structures/oval_object.py

@@ -1,20 +1,15 @@
 # Copyright 2022, Red Hat, Inc.
 # SPDX-License-Identifier: LGPL-2.1-or-later
 
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass, field
 
 
 @dataclass
-class OvalObject():
-    object_id: str = ""
+class OvalObject:
+    object_id: str
     flag: str = ""
     object_type: str = ""
-    object_data: dict = None
+    object_data: list[dict[str, str]] = field(default_factory=list)
 
     def as_dict(self):
-        return {
-            "object_id": self.object_id,
-            "flag": self.flag,
-            "object_type": self.object_type,
-            "object_data": self.object_data,
-        }
+        return asdict(self)

openscap_report/scap_results_parser/data_structures/oval_test.py

@@ -1,22 +1,17 @@
 # Copyright 2022, Red Hat, Inc.
 # SPDX-License-Identifier: LGPL-2.1-or-later
 
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass
 
 from .oval_object import OvalObject
 
 
 @dataclass
-class OvalTest():
-    test_id: str = ""
+class OvalTest:
+    test_id: str
     test_type: str = ""
     comment: str = ""
     oval_object: OvalObject = None
 
     def as_dict(self):
-        return {
-            "test_id": self.test_id,
-            "test_type": self.test_type,
-            "comment": self.comment,
-            "oval_object": self.oval_object.as_dict(),
-        }
+        return asdict(self)