refactor: Fix CodeQL errors and warnings

src/powerapi/cli/config_parser.py

@@ -496,9 +496,9 @@ def parse_config_dict(self, file_name: str) -> dict:
         Return a configuration dict that has all the arguments' names in the long form.
         If an argument does not exist, a UnknownArgException is raised
         """
-        config_file = open(file_name, 'r')
-        conf = json.load(config_file)
-        return self.normalize_configuration(conf=conf)
+        with open(file_name, 'r') as config_file:
+            conf = json.load(config_file)
+            return self.normalize_configuration(conf=conf)
 
     def normalize_configuration(self, conf: dict) -> dict:
         """
@@ -768,4 +768,3 @@ def cast_argument_value(arg_name: str, val: Any, argument: ConfigurationArgument
         return argument.type(val)
     except ValueError as exn:
         raise BadTypeException(arg_name, argument.type) from exn
-    return val

src/powerapi/cli/generator.py

@@ -41,6 +41,7 @@
 from powerapi.processor.pre.k8s.k8s_pre_processor_actor import K8sPreProcessorActor, TIME_INTERVAL_DEFAULT_VALUE, \
     TIMEOUT_QUERY_DEFAULT_VALUE
 from powerapi.processor.pre.libvirt.libvirt_pre_processor_actor import LibvirtPreProcessorActor
+from powerapi.processor.processor_actor import ProcessorActor
 from powerapi.report import HWPCReport, PowerReport, ControlReport, ProcfsReport, Report, FormulaReport
 from powerapi.database import MongoDB, CsvDB, OpenTSDB, SocketDB, PrometheusDB, \
     VirtioFSDB, FileDB
@@ -335,16 +336,10 @@
     Generator that initialises the processor from config
     """
 
-    def __init__(self, component_group_name: str):
-        Generator.__init__(self, component_group_name=component_group_name)
-
-        self.processor_factory = self._get_default_processor_factories()
+    def __init__(self, component_group_name: str, processor_factory: Dict[str, Callable[[Dict], ProcessorActor]] = None):
+        Generator.__init__(self, component_group_name)
 
-    def _get_default_processor_factories(self) -> dict:
-        """
-        Init the factories for this processor generator
-        """
-        raise NotImplementedError
+        self.processor_factory = processor_factory
 
     def remove_processor_factory(self, processor_type: str):
         """
@@ -382,9 +377,10 @@
     """
 
     def __init__(self):
-        ProcessorGenerator.__init__(self, component_group_name='pre-processor')
+        ProcessorGenerator.__init__(self, 'pre-processor', self._get_default_processor_factories())
 
-    def _get_default_processor_factories(self) -> dict:
+    @staticmethod
+    def _get_default_processor_factories() -> Dict[str, Callable[[Dict], ProcessorActor]]:
         return {
             'libvirt': lambda processor_config: LibvirtPreProcessorActor(name=processor_config[ACTOR_NAME_KEY],
                                                                          uri=processor_config[COMPONENT_URI_KEY],
@@ -419,9 +415,10 @@
     """
 
     def __init__(self):
-        ProcessorGenerator.__init__(self, component_group_name='post-processor')
+        ProcessorGenerator.__init__(self, 'post-processor', self._get_default_processor_factories())
 
-    def _get_default_processor_factories(self) -> dict:
+    @staticmethod
+    def _get_default_processor_factories() -> Dict[str, Callable[[Dict], ProcessorActor]]:
         return {}
 
 

src/powerapi/cli/parsing_manager.py

@@ -26,53 +26,60 @@
 # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-import sys
 import json
 import logging
-
+import sys
 from typing import Callable, Any
+
 from powerapi.cli.config_parser import RootConfigParser, SubgroupConfigParser, store_val
-from powerapi.exception import MissingArgumentException, BadTypeException, \
-    AlreadyAddedSubparserException, UnknownArgException, MissingValueException, BadContextException, \
-    RepeatedArgumentException, AlreadyAddedSubgroupException
+from powerapi.exception import MissingArgumentException, BadTypeException, AlreadyAddedSubparserException, \
+    UnknownArgException, MissingValueException, BadContextException, RepeatedArgumentException, \
+    AlreadyAddedSubgroupException
 from powerapi.utils.cli import merge_dictionaries
 
 
-class BaseConfigParsingManager:
-    """ Abstract class for dealing with parsing of configurations. """
-
-    def __init__(self):
-        self.cli_parser = None
+class BaseConfigParsingManagerInterface:
+    """
+    Abstract class for dealing with parsing of configurations.
+    """
 
-    def add_argument(self, *names, is_flag: bool = False, action: Callable = store_val,
-                     default_value: Any = None, help_text: str = '', argument_type: type = str,
-                     is_mandatory: bool = False):
+    def add_argument(self, *names, is_flag: bool = False, action: Callable = store_val, default_value: Any = None,
+                     help_text: str = '', argument_type: type = str, is_mandatory: bool = False) -> None:
         """
-        Add an argument to the parser and its specification
-
+        Add an argument to the parser.
         """
-        self.cli_parser.add_argument(*names, is_flag=is_flag, action=action, default_value=default_value,
-                                     help_text=help_text, argument_type=bool if is_flag else argument_type,
-                                     is_mandatory=is_mandatory)
+        raise NotImplementedError
 
     def validate(self, conf: dict) -> dict:
-        """ Check the parsed configuration"""
+        """
+        Validate the parsed configuration.
+        """
         raise NotImplementedError
 
 
-class SubgroupConfigParsingManager(BaseConfigParsingManager):
+class SubgroupConfigParsingManager(BaseConfigParsingManagerInterface):
     """
     Sub Parser for MainConfigParser
     """
 
     def __init__(self, name: str):
-        BaseConfigParsingManager.__init__(self)
         self.subparser = {}
-        self.cli_parser = SubgroupConfigParser(name)
         self.name = name
+        self.cli_parser = SubgroupConfigParser(name)
+
+    def add_argument(self, *names, is_flag: bool = False, action: Callable = store_val, default_value: Any = None,
+                     help_text: str = '', argument_type: type = str, is_mandatory: bool = False) -> None:
+        """
+        Add an argument to the parser.
+        """
+        self.cli_parser.add_argument(*names, is_flag=is_flag, action=action, default_value=default_value,
+                                     help_text=help_text, argument_type=bool if is_flag else argument_type,
+                                     is_mandatory=is_mandatory)
 
     def validate(self, conf: dict) -> dict:
-        """ Check the parsed configuration"""
+        """
+        Check the parsed configuration.
+        """
 
         # check types
         for args, value in conf.items():
@@ -88,13 +95,12 @@
         return conf
 
 
-class RootConfigParsingManager(BaseConfigParsingManager):
+class RootConfigParsingManager(BaseConfigParsingManagerInterface):
     """
     Parser abstraction for the configuration
     """
 
     def __init__(self):
-        BaseConfigParsingManager.__init__(self)
         self.subparser = {}
         self.cli_parser = RootConfigParser()
 
@@ -124,7 +130,6 @@
         """
         Add a Subgroup Parser to call when <name> is encountered
         When name is encountered, the subgroup parser such as subgroup_parser.name match conf[name].type
-
         """
         if subgroup_name in self.subparser:
             if subgroup_parser.name in list(self.subparser[subgroup_name]):
@@ -156,8 +161,19 @@
 
         return conf
 
+    def add_argument(self, *names, is_flag: bool = False, action: Callable = store_val, default_value: Any = None,
+                     help_text: str = '', argument_type: type = str, is_mandatory: bool = False) -> None:
+        """
+        Add an argument to the parser.
+        """
+        self.cli_parser.add_argument(*names, is_flag=is_flag, action=action, default_value=default_value,
+                                     help_text=help_text, argument_type=bool if is_flag else argument_type,
+                                     is_mandatory=is_mandatory)
+
     def validate(self, conf: dict) -> dict:
-        """ Check the parsed configuration"""
+        """
+        Check the parsed configuration
+        """
 
         # check types
         for current_argument_name, current_argument_value in conf.items():

src/powerapi/database/base_db.py

@@ -73,9 +73,9 @@ class BaseDB:
     by each DB module. A database module correspond to a kind of BDD.
     For example, Mongodb, influxdb, csv are different kind of BDD.
     """
-    def __init__(self, report_type: Type[Report]):
-        self.asynchrone = False
-        self.exceptions = []
+    def __init__(self, report_type: Type[Report], exceptions: List[Type[Exception]] = None, asynchrone: bool = False):
+        self.exceptions = exceptions or []
+        self.asynchrone = asynchrone
         self.report_type = report_type
 
     def connect(self):

src/powerapi/database/csvdb.py

@@ -265,41 +265,34 @@
 
         :param report: Report
         """
-        csv_header, data = self.report_type.to_csv_lines(report, self.tags)
+        fixed_header, data = self.report_type.to_csv_lines(report, self.tags)
 
         # If the repository doesn't exist, create it
         rep_path = self.current_path + report.sensor + "-" + report.target
-        try:
-            os.makedirs(rep_path)
-        except FileExistsError:
-            pass
+        os.makedirs(rep_path, exist_ok=True)
 
         for filename, values in data.items():
-            rep_path_with_file = rep_path + '/' + filename + '.csv'
-            # Get the header and check if it's ok
-            for value in values:
-                header = csv_header + sorted(list(set([event_key for event_key, _ in value.items()]) - set(csv_header)))
+            output_filename = f'{rep_path}/{filename}.csv'
+
+            with open(output_filename, 'r+') as csvfile:
+                expected_header = fixed_header + sorted(set(values[0].keys()) - set(fixed_header))
                 header_exist = False
-                try:
-                    with open(rep_path_with_file) as csvfile:
-                        reader = csv.DictReader(csvfile)
-                        if reader.fieldnames:
-                            header_exist = True
-
-                        if header != reader.fieldnames:
-                            raise HeaderAreNotTheSameError("Header are not the same in " + rep_path_with_file)
-                        csvfile.flush()
-                        csvfile.close()
-                except FileNotFoundError:
-                    pass
-
-                # Write
-                with open(rep_path_with_file, 'a') as csvfile:
-                    writer = csv.DictWriter(csvfile, header)
-                    if not header_exist:
-                        writer.writeheader()
-                    writer.writerow(value)
-                    csvfile.close()
+
+                reader = csv.DictReader(csvfile)
+                if reader.fieldnames:
+                    header_exist = True
+                    if reader.fieldnames != expected_header:
+                        raise HeaderAreNotTheSameError(f"Header are not the same in {output_filename}")
+
+                # Go to EOF before writing rows
+                csvfile.seek(0, 2)
+
+                writer = csv.DictWriter(csvfile, fieldnames=expected_header)
+                if not header_exist:
+                    writer.writeheader()
+
+                for row in values:
+                    writer.writerow(row)
 
     def save_many(self, reports: List[Report]):
         """

src/powerapi/database/file_db.py

@@ -71,20 +71,19 @@
         :raise: StopIteration in stream mode when no report was found.
         """
 
-        file_object = open(self.filename, "r")
-        json_str = file_object.read()
-        file_object.close()
+        with open(self.filename, "r") as file_object:
+            json_str = file_object.read()
 
-        if json_str is None:
-            raise StopIteration()
+            if json_str is None:
+                raise StopIteration()
 
-        if json_str == self.previousJson:
-            logging.error("Error : Report did not change since last read")
-            raise StopIteration()
+            if json_str == self.previousJson:
+                logging.error("Error : Report did not change since last read")
+                raise StopIteration()
 
-        self.previousJson = json_str
+            self.previousJson = json_str
 
-        return self.report_type.from_json(json.loads(json_str))
+            return self.report_type.from_json(json.loads(json_str))
 
 
 class FileDB(BaseDB):
@@ -125,7 +124,7 @@
 
         :param report: Report to save
         """
-        file_object = open(self.filename, "w")
+
         line = {
             "sensor": report.sensor,
             "target": report.target,
@@ -135,9 +134,8 @@
 
         final_dict = {"PowerReport": [line]}
 
-        file_object.truncate(0)
-        file_object.write(str(final_dict))
-        file_object.close()
+        with open(self.filename, "w") as file_object:
+            file_object.write(str(final_dict))
 
     def save_many(self, reports: List[Report]):
         """

src/powerapi/database/influxdb2.py

@@ -90,10 +90,7 @@ def __iter__(self):
         raise NotImplementedError()
 
     def _ping_client(self):
-        # if hasattr(self.client, 'ping'):
         self.client.ping()
-        # else:
-        #    self.client.request(url="ping", method='GET', expected_response_code=204)
 
     def connect(self):
         """

src/powerapi/database/mongodb.py

@@ -29,6 +29,7 @@
 import logging
 try:
     import pymongo
+    import pymongo.errors
 except ImportError:
     logging.getLogger().info("PyMongo is not installed.")
 
@@ -103,7 +104,7 @@ def __init__(self, report_type: Type[Report], uri: str, db_name: str, collection
         :param collection_name: collection name in the mongodb
                                     (ex: "sensor")
         """
-        BaseDB.__init__(self, report_type)
+        BaseDB.__init__(self, report_type, [pymongo.errors.PyMongoError])
 
         #: (str): URI of the mongodb server
         self.uri = uri
@@ -121,8 +122,6 @@ def __init__(self, report_type: Type[Report], uri: str, db_name: str, collection
         #: targeted collection
         self.collection = None
 
-        self.exceptions = [pymongo.errors.PyMongoError]
-
     def connect(self):
         """
         Override from BaseDB.

src/powerapi/database/socket_db.py

@@ -46,8 +46,7 @@ class SocketDB(BaseDB):
     """
 
     def __init__(self, report_type: Type[Report], port: int):
-        BaseDB.__init__(self, report_type)
-        self.asynchrone = True
+        BaseDB.__init__(self, report_type, asynchrone=True)
         self.queue = None
         self.port = port
         self.server = None

src/powerapi/database/virtiofs_db.py

@@ -85,13 +85,12 @@
             return
 
         vm_filename, power = self.report_type.to_virtiofs_db(report)
-        vm_filename_path = self.root_directory_name + '/' + directory_name + '/'
+        vm_filename_path = f'{self.root_directory_name}/{directory_name}'
         if not os.path.exists(vm_filename_path):
             raise DirectoryDoesNotExistForVirtioFS(vm_filename_path)
 
-        vm_file = open(vm_filename_path + vm_filename, 'w+')
-        vm_file.write(str(power))
-        vm_file.close()
+        with open(vm_filename_path + vm_filename, 'w') as vm_file:
+            vm_file.write(str(power))
 
     def save_many(self, reports: List[Report]):
         for report in reports: