added global configs support

Author: alexandraBara

nodescraper/interfaces/dataplugin.py

@@ -38,6 +38,7 @@
     SystemInfo,
     TaskResult,
 )
+from nodescraper.utils import normalize_enum
 
 from .connectionmanager import TConnectArg, TConnectionManager
 from .task import SystemCompatibilityError
@@ -162,6 +163,10 @@ def collect(
             return self.collection_result
 
         try:
+            max_event_priority_level = normalize_enum(max_event_priority_level, EventPriority)
+            system_interaction_level = normalize_enum(
+                system_interaction_level, SystemInteractionLevel
+            )
             if not self.connection_manager:
                 if not self.CONNECTION_TYPE:
                     self.collection_result = TaskResult(
@@ -241,6 +246,9 @@ def analyze(
         Returns:
             TaskResult: result of data analysis
         """
+
+        max_event_priority_level = normalize_enum(max_event_priority_level, EventPriority)
+
         if self.ANALYZER is None:
             self.analysis_result = TaskResult(
                 status=ExecutionStatus.NOT_RAN,
@@ -298,6 +306,8 @@ def run(
             PluginResult: Plugin result
         """
         self.logger.info("Running plugin %s", self.__class__.__name__)
+        max_event_priority_level = normalize_enum(max_event_priority_level, EventPriority)
+        system_interaction_level = normalize_enum(system_interaction_level, SystemInteractionLevel)
         if collection:
             self.collect(
                 max_event_priority_level=max_event_priority_level,

nodescraper/pluginexecutor.py

@@ -33,7 +33,9 @@
 from pydantic import BaseModel
 
 from nodescraper.constants import DEFAULT_LOGGER
-from nodescraper.interfaces import ConnectionManager, DataPlugin
+from nodescraper.enums.eventpriority import EventPriority
+from nodescraper.enums.systeminteraction import SystemInteractionLevel
+from nodescraper.interfaces import ConnectionManager, DataPlugin, PluginInterface
 from nodescraper.models import PluginConfig, SystemInfo
 from nodescraper.models.pluginresult import PluginResult
 from nodescraper.pluginregistry import PluginRegistry
@@ -167,14 +169,29 @@ def run_queue(self) -> list[PluginResult]:
                     run_payload = copy.deepcopy(plugin_args)
 
                     run_args = TypeUtils.get_func_arg_types(plugin_class.run, plugin_class)
+
+                    enum_fields = {
+                        "max_event_priority_level": EventPriority,
+                        "system_interaction_level": SystemInteractionLevel,
+                    }
+
                     for arg in run_args.keys():
                         if arg == "preserve_connection" and issubclass(plugin_class, DataPlugin):
                             run_payload[arg] = True
                         elif arg in self.plugin_config.global_args:
                             run_payload[arg] = self.plugin_config.global_args[arg]
+                    try:
+                        self.apply_global_args_to_plugin(
+                            plugin_inst, plugin_class, self.plugin_config.global_args, enum_fields
+                        )
+                    except ValueError as ve:
+                        self.logger.error(
+                            "Invalid global_args for plugin %s: %s. Skipping plugin.",
+                            plugin_name,
+                            str(ve),
+                        )
+                        continue
 
-                        # TODO
-                        # enable global substitution in collection and analysis args
                     self.logger.info("-" * 50)
                     plugin_results.append(plugin_inst.run(**run_payload))
                 except Exception as e:
@@ -210,3 +227,68 @@ def run_queue(self) -> list[PluginResult]:
                     )
 
         return plugin_results
+
+    def apply_global_args_to_plugin(
+        self, plugin_inst: PluginInterface, plugin_class: type, global_args: dict, enum_fields: dict
+    ) -> None:
+        """
+        Applies global arguments to the plugin instance, including standard attributes
+        and merging Pydantic model arguments (collection_args, analysis_args).
+
+        Args:
+            plugin_inst: The plugin instance to update.
+            plugin_class: The plugin class (needed for model instantiation).
+            global_args: Dict of global argument overrides.
+        """
+
+        simple_keys = [
+            "collection",
+            "analysis",
+            "max_event_priority_level",
+            "system_interaction_level",
+            "preserve_connection",
+            "data",
+        ]
+
+        for key in simple_keys:
+            if key in global_args:
+                value = global_args[key]
+
+                if key in enum_fields:
+                    enum_type = enum_fields[key]
+                    if isinstance(value, str):
+                        try:
+                            value = enum_type[value.upper()]
+                        except KeyError as kerr:
+                            raise ValueError(
+                                f"Invalid enum name '{value}' for {enum_type.__name__}"
+                            ) from kerr
+                    elif isinstance(value, int):
+                        try:
+                            value = enum_type(value)
+                        except ValueError as verr:
+                            raise ValueError(
+                                f"Invalid enum value '{value}' for {enum_type.__name__}"
+                            ) from verr
+
+                setattr(plugin_inst, key, value)
+
+        if "collection_args" in global_args:
+            update_data = global_args["collection_args"]
+            existing = getattr(plugin_inst, "COLLECTION_ARGS", None)
+            model_class = getattr(plugin_class, "COLLECTOR_ARGS", None)
+
+            if isinstance(existing, BaseModel):
+                plugin_inst.COLLECTION_ARGS = existing.model_copy(update=update_data)
+            elif model_class and issubclass(model_class, BaseModel):
+                plugin_inst.COLLECTION_ARGS = model_class.model_validate(update_data)
+
+        if "analysis_args" in global_args:
+            update_data = global_args["analysis_args"]
+            existing = getattr(plugin_inst, "ANALYSIS_ARGS", None)
+            model_class = getattr(plugin_class, "ANALYZER_ARGS", None)
+
+            if isinstance(existing, BaseModel):
+                plugin_inst.ANALYSIS_ARGS = existing.model_copy(update=update_data)
+            elif model_class and issubclass(model_class, BaseModel):
+                plugin_inst.ANALYSIS_ARGS = model_class.model_validate(update_data)

nodescraper/utils.py

@@ -169,3 +169,13 @@ def bytes_to_human_readable(input_bytes: int) -> str:
 
     gb = round(mb / 1000, 2)
     return f"{gb}GB"
+
+
+def normalize_enum(value, enum_type):
+    if isinstance(value, enum_type):
+        return value
+    elif isinstance(value, int):
+        return enum_type(value)
+    elif isinstance(value, str):
+        return enum_type[value.upper()]
+    raise ValueError(f"Invalid value '{value}' for enum {enum_type.__name__}")

test/unit/conftest.py

@@ -55,6 +55,7 @@ class DummyDataModel(DataModel):
 
 class DummyArg(BaseModel):
     value: int
+    regex_match: bool = True
 
 
 class DummyResult:

test/unit/framework/test_plugin_executor.py

@@ -24,29 +24,40 @@
 #
 ###############################################################################
 import pytest
-from common.shared_utils import MockConnectionManager
+from common.shared_utils import DummyDataModel, MockConnectionManager
+from pydantic import BaseModel
 
 from nodescraper.enums import ExecutionStatus
+from nodescraper.enums.eventpriority import EventPriority
+from nodescraper.enums.systeminteraction import SystemInteractionLevel
 from nodescraper.interfaces import PluginInterface
 from nodescraper.models import PluginConfig, PluginResult
 from nodescraper.pluginexecutor import PluginExecutor
 from nodescraper.pluginregistry import PluginRegistry
 
 
-class TestPluginA(PluginInterface[MockConnectionManager, None]):
+class DummyArgs(BaseModel):
+    foo: str = "bar"
+    regex_match: bool = True
+
 
+class TestPluginA(PluginInterface[MockConnectionManager, None]):
     CONNECTION_TYPE = MockConnectionManager
+    COLLECTION_ARGS = DummyArgs(foo="initial")
+    ANALYSIS_ARGS = DummyArgs(foo="initial")
+    collection = False
+    analysis = False
+    preserve_connection = False
+    data = DummyDataModel(some_version="1")
+    max_event_priority_level = EventPriority.INFO
+    system_interaction_level = SystemInteractionLevel.PASSIVE
 
     def run(self):
         self._update_queue(("TestPluginB", {}))
-        return PluginResult(
-            source="testA",
-            status=ExecutionStatus.ERROR,
-        )
+        return PluginResult(source="testA", status=ExecutionStatus.ERROR)
 
 
 class TestPluginB(PluginInterface[MockConnectionManager, None]):
-
     CONNECTION_TYPE = MockConnectionManager
 
     def run(self, test_arg=None):
@@ -67,10 +78,7 @@ def plugin_registry():
     "input_configs, output_config",
     [
         (
-            [
-                PluginConfig(plugins={"Plugin1": {}}),
-                PluginConfig(plugins={"Plugin2": {}}),
-            ],
+            [PluginConfig(plugins={"Plugin1": {}}), PluginConfig(plugins={"Plugin2": {}})],
             PluginConfig(plugins={"Plugin1": {}, "Plugin2": {}}),
         ),
         (
@@ -109,7 +117,8 @@ def test_plugin_queue(plugin_registry):
 
 def test_queue_callback(plugin_registry):
     executor = PluginExecutor(
-        plugin_configs=[PluginConfig(plugins={"TestPluginA": {}})], plugin_registry=plugin_registry
+        plugin_configs=[PluginConfig(plugins={"TestPluginA": {}})],
+        plugin_registry=plugin_registry,
     )
 
     results = executor.run_queue()
@@ -119,3 +128,33 @@ def test_queue_callback(plugin_registry):
     assert results[0].status == ExecutionStatus.ERROR
     assert results[1].source == "testB"
     assert results[1].status == ExecutionStatus.OK
+
+
+def test_apply_global_args_to_plugin():
+    plugin = TestPluginA()
+    global_args = {
+        "collection": True,
+        "analysis": True,
+        "preserve_connection": True,
+        "data": {"some_version": "1"},
+        "max_event_priority_level": 4,
+        "system_interaction_level": "INTERACTIVE",
+        "collection_args": {"foo": "collected", "regex_match": False},
+        "analysis_args": {"foo": "analyzed", "regex_match": False},
+    }
+    enum_fields = {
+        "max_event_priority_level": EventPriority,
+        "system_interaction_level": SystemInteractionLevel,
+    }
+
+    executor = PluginExecutor(plugin_configs=[])
+    executor.apply_global_args_to_plugin(plugin, TestPluginA, global_args, enum_fields)
+
+    assert plugin.collection is True
+    assert plugin.analysis is True
+    assert plugin.preserve_connection is True
+    assert plugin.data["some_version"] == "1"
+    assert plugin.max_event_priority_level == EventPriority.CRITICAL
+    assert plugin.system_interaction_level == SystemInteractionLevel.INTERACTIVE
+    assert plugin.COLLECTION_ARGS.foo == "collected"
+    assert plugin.ANALYSIS_ARGS.foo == "analyzed"