Merge pull request #23 from amd/alex_global_args

Added global args support in config

Author: alexandraBara

nodescraper/interfaces/dataplugin.py

@@ -241,6 +241,7 @@ def analyze(
         Returns:
             TaskResult: result of data analysis
         """
+
         if self.ANALYZER is None:
             self.analysis_result = TaskResult(
                 status=ExecutionStatus.NOT_RAN,

nodescraper/interfaces/task.py

@@ -80,6 +80,8 @@ def max_event_priority_level(self) -> EventPriority:
     def max_event_priority_level(self, input_value: str | EventPriority):
         if isinstance(input_value, str):
             value: EventPriority = getattr(EventPriority, input_value)
+        elif isinstance(input_value, int):
+            value = EventPriority(input_value)
         elif isinstance(input_value, EventPriority):
             value: EventPriority = input_value
         else:

nodescraper/pluginexecutor.py

@@ -33,7 +33,7 @@
 from pydantic import BaseModel
 
 from nodescraper.constants import DEFAULT_LOGGER
-from nodescraper.interfaces import ConnectionManager, DataPlugin
+from nodescraper.interfaces import ConnectionManager, DataPlugin, PluginInterface
 from nodescraper.models import PluginConfig, SystemInfo
 from nodescraper.models.pluginresult import PluginResult
 from nodescraper.pluginregistry import PluginRegistry
@@ -165,16 +165,25 @@ def run_queue(self) -> list[PluginResult]:
                     plugin_inst = plugin_class(**init_payload)
 
                     run_payload = copy.deepcopy(plugin_args)
-
                     run_args = TypeUtils.get_func_arg_types(plugin_class.run, plugin_class)
+
                     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]
 
-                        # TODO
-                        # enable global substitution in collection and analysis args
+                    try:
+                        global_run_args = self.apply_global_args_to_plugin(
+                            plugin_inst, plugin_class, self.plugin_config.global_args
+                        )
+                        run_payload.update(global_run_args)
+                    except ValueError as ve:
+                        self.logger.error(
+                            "Invalid global_args for plugin %s: %s. Skipping plugin.",
+                            plugin_name,
+                            str(ve),
+                        )
+                        continue
+
                     self.logger.info("-" * 50)
                     plugin_results.append(plugin_inst.run(**run_payload))
                 except Exception as e:
@@ -210,3 +219,42 @@ 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,
+    ) -> dict:
+        """
+        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.
+        """
+
+        run_args = {}
+        for key in global_args:
+            if key in ["collection_args", "analysis_args"] and isinstance(plugin_inst, DataPlugin):
+                continue
+            else:
+                run_args[key] = global_args[key]
+
+        if "collection_args" in global_args and hasattr(plugin_class, "COLLECTOR_ARGS"):
+            plugin_fields = set(plugin_class.COLLECTOR_ARGS.__fields__.keys())
+            filtered = {
+                k: v for k, v in global_args["collection_args"].items() if k in plugin_fields
+            }
+            if filtered:
+                run_args["collection_args"] = filtered
+
+        if "analysis_args" in global_args and hasattr(plugin_class, "ANALYZER_ARGS"):
+            plugin_fields = set(plugin_class.ANALYZER_ARGS.__fields__.keys())
+            filtered = {k: v for k, v in global_args["analysis_args"].items() if k in plugin_fields}
+            if filtered:
+                run_args["analysis_args"] = filtered
+
+        return run_args

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,41 @@
 #
 ###############################################################################
 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
+    COLLECTOR_ARGS = DummyArgs(foo="initial")
+    ANALYZER_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
+    collection_args = None
 
     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 +79,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 +118,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 +129,37 @@ 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, "not_in_model": "skip_this"},
+        "analysis_args": {"foo": "analyzed", "regex_match": False, "ignore_this": True},
+    }
+
+    executor = PluginExecutor(plugin_configs=[])
+    run_payload = executor.apply_global_args_to_plugin(plugin, TestPluginA, global_args)
+
+    assert run_payload["collection"] is True
+    assert run_payload["analysis"] is True
+    assert run_payload["preserve_connection"] is True
+    assert run_payload["data"]["some_version"] == "1"
+    assert run_payload["max_event_priority_level"] == 4
+    assert run_payload["system_interaction_level"] == "INTERACTIVE"
+
+    # Safely check filtered args
+    assert run_payload.get("collection_args") == {
+        "foo": "collected",
+        "regex_match": False,
+    }
+    assert run_payload.get("analysis_args") == {
+        "foo": "analyzed",
+        "regex_match": False,
+    }