amd-node-scraper 0.0.1__py3-none-any.whl

nodescraper/plugins/inband/kernel_module/kernel_module_collector.py

@@ -0,0 +1,264 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from typing import Optional
+
+from nodescraper.base import InBandDataCollector
+from nodescraper.connection.inband import TextFileArtifact
+from nodescraper.connection.inband.inband import CommandArtifact
+from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus, OSFamily
+from nodescraper.models import TaskResult
+
+from .kernel_module_data import KernelModuleDataModel, ModuleInfo, ModuleParameter
+
+
+class KernelModuleCollector(InBandDataCollector[KernelModuleDataModel, None]):
+    """Read kernel modules and associated parameters"""
+
+    DATA_MODEL = KernelModuleDataModel
+    CMD_WINDOWS = "wmic os get Version /Value"
+    CMD = "cat /proc/modules"
+    CMD_MODINFO_AMDGPU = "modinfo amdgpu"
+
+    def parse_proc_modules(self, output: dict) -> dict:
+        """Parse command output and return dict of modules
+
+        Args:
+            output (dict): sut cmd output
+
+        Returns:
+            dict: parsed modules
+        """
+        modules = {}
+        for line in output.strip().splitlines():
+            parts = line.split()
+            if not parts:
+                continue
+            name = parts[0]
+            modules[name] = {
+                "parameters": {},
+            }
+        return modules
+
+    def _parse_modinfo(self, output: str) -> Optional[ModuleInfo]:
+        """Parse modinfo command output into structured ModuleInfo
+
+        Args:
+            output (str): modinfo command output
+
+        Returns:
+            Optional[ModuleInfo]: parsed module information or None if parsing fails
+        """
+        if not output or not output.strip():
+            return None
+
+        module_info = ModuleInfo()
+
+        for line in output.splitlines():
+            line = line.strip()
+            if not line or ":" not in line:
+                continue
+
+            field, _, value = line.partition(":")
+            field = field.strip()
+            value = value.strip()
+
+            if field == "filename":
+                module_info.filename = value
+            elif field == "version":
+                module_info.version = value
+            elif field == "license":
+                module_info.license = value
+            elif field == "description":
+                module_info.description = value
+            elif field == "author":
+                module_info.author.append(value)
+            elif field == "firmware":
+                module_info.firmware.append(value)
+            elif field == "srcversion":
+                module_info.srcversion = value
+            elif field == "depends":
+                if value:
+                    module_info.depends = [dep.strip() for dep in value.split(",") if dep.strip()]
+            elif field == "name":
+                module_info.name = value
+            elif field == "vermagic":
+                module_info.vermagic = value
+            elif field == "sig_id":
+                module_info.sig_id = value
+            elif field == "signer":
+                module_info.signer = value
+            elif field == "sig_key":
+                module_info.sig_key = value
+            elif field == "sig_hashalgo":
+                module_info.sig_hashalgo = value
+            elif field == "parm":
+                param_name, param_desc = value.split(":", 1) if ":" in value else (value, "")
+                param_name = param_name.strip()
+                param_desc = param_desc.strip()
+
+                param_type = None
+                if param_desc and "(" in param_desc and ")" in param_desc:
+                    type_start = param_desc.rfind("(")
+                    type_end = param_desc.rfind(")")
+                    if type_start < type_end:
+                        param_type = param_desc[type_start + 1 : type_end].strip()
+                        param_desc = param_desc[:type_start].strip()
+
+                module_info.parm.append(
+                    ModuleParameter(name=param_name, type=param_type, description=param_desc)
+                )
+
+        return module_info
+
+    def get_module_parameters(self, module_name: str) -> dict:
+        """Fetches parameter names and values for a given kernel module using _run_sut_cmd
+
+        Args:
+            module_name (str): name of module to fetch params for
+
+        Returns:
+            dict: param dict of module
+        """
+        param_dict = {}
+        param_dir = f"/sys/module/{module_name}/parameters"
+
+        list_params_cmd = f"ls {param_dir}"
+        res = self._run_sut_cmd(list_params_cmd)
+        if res.exit_code != 0:
+            return param_dict
+
+        for param in res.stdout.strip().splitlines():
+            param_path = f"{param_dir}/{param}"
+            value_res = self._run_sut_cmd(f"cat {param_path}")
+            value = value_res.stdout.strip() if value_res.exit_code == 0 else "<unreadable>"
+            param_dict[param] = value
+
+        return param_dict
+
+    def collect_all_module_info(self) -> tuple[dict, CommandArtifact]:
+        """Get all modules and its associated params and values
+
+        Raises:
+            RuntimeError: error for failing to get modules
+
+        Returns:
+            tuple[dict, CommandArtifact]: modules found and exit code
+        """
+        modules = {}
+        res = self._run_sut_cmd(self.CMD)
+        if res.exit_code != 0:
+            self._log_event(
+                category=EventCategory.OS,
+                description="Failed to read /proc/modules",
+                data={"command": res.command, "exit_code": res.exit_code},
+                priority=EventPriority.ERROR,
+                console_log=True,
+            )
+            return modules
+
+        modules = self.parse_proc_modules(res.stdout)
+
+        for mod in modules:
+            modules[mod]["parameters"] = self.get_module_parameters(mod)
+
+        if not modules:
+            self._log_event(
+                category=EventCategory.OS,
+                description="Error checking kernel modules",
+                data={"command": res.command, "exit_code": res.exit_code},
+                priority=EventPriority.ERROR,
+                console_log=True,
+            )
+
+        return modules
+
+    def collect_data(self, args=None) -> tuple[TaskResult, Optional[KernelModuleDataModel]]:
+        """
+        Collect kernel modules data.
+
+        Returns:
+            tuple[TaskResult, Optional[KernelModuleDataModel]]: tuple containing the task result and kernel data model or None if not found.
+        """
+        kernel_modules = {}
+        km_data: KernelModuleDataModel | None = None
+        if self.system_info.os_family == OSFamily.WINDOWS:
+            res = self._run_sut_cmd(self.CMD_WINDOWS)
+            if res.exit_code == 0:
+                for line in res.stdout.splitlines():
+                    if line.startswith("Version="):
+                        version = line.split("=", 1)[1]
+                        kernel_modules = {version: {"parameters": {}}}
+                        break
+
+        else:
+            kernel_modules = self.collect_all_module_info()
+
+        amdgpu_modinfo = None
+        if self.system_info.os_family != OSFamily.WINDOWS:
+            # Collect and parse modinfo amdgpu output
+            modinfo_res = self._run_sut_cmd(self.CMD_MODINFO_AMDGPU)
+            if modinfo_res.exit_code == 0 and modinfo_res.stdout:
+                amdgpu_modinfo = self._parse_modinfo(modinfo_res.stdout)
+                if amdgpu_modinfo:
+                    self.result.artifacts.append(
+                        TextFileArtifact(filename="modinfo_amdgpu.txt", contents=modinfo_res.stdout)
+                    )
+                else:
+                    self._log_event(
+                        category=EventCategory.OS,
+                        description="Could not parse modinfo amdgpu output",
+                        data={"command": modinfo_res.command},
+                        priority=EventPriority.WARNING,
+                    )
+            else:
+                self._log_event(
+                    category=EventCategory.OS,
+                    description="Could not collect modinfo amdgpu output",
+                    data={
+                        "command": modinfo_res.command,
+                        "exit_code": modinfo_res.exit_code,
+                        "stderr": modinfo_res.stderr,
+                    },
+                    priority=EventPriority.WARNING,
+                )
+
+        if kernel_modules:
+            km_data = KernelModuleDataModel(
+                kernel_modules=kernel_modules, amdgpu_modinfo=amdgpu_modinfo
+            )
+            self._log_event(
+                category="KERNEL_READ",
+                description="Kernel modules read",
+                data=km_data.model_dump(),
+                priority=EventPriority.INFO,
+            )
+            self.result.message = f"{len(km_data.kernel_modules)} kernel modules collected"
+            self.result.status = ExecutionStatus.OK
+        else:
+            self.result.message = "Kernel modules not found"
+            self.result.status = ExecutionStatus.ERROR
+
+        return self.result, km_data

nodescraper/plugins/inband/kernel_module/kernel_module_data.py

@@ -0,0 +1,60 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from nodescraper.models import DataModel
+
+
+class ModuleParameter(BaseModel):
+    name: str
+    type: Optional[str] = None
+    description: Optional[str] = None
+
+
+class ModuleInfo(BaseModel):
+    filename: Optional[str] = None
+    version: Optional[str] = None
+    license: Optional[str] = None
+    description: Optional[str] = None
+    author: list[str] = Field(default_factory=list)
+    firmware: list[str] = Field(default_factory=list)
+    srcversion: Optional[str] = None
+    depends: list[str] = Field(default_factory=list)
+    name: Optional[str] = None
+    vermagic: Optional[str] = None
+    sig_id: Optional[str] = None
+    signer: Optional[str] = None
+    sig_key: Optional[str] = None
+    sig_hashalgo: Optional[str] = None
+    parm: list[ModuleParameter] = Field(default_factory=list)
+
+
+class KernelModuleDataModel(DataModel):
+    kernel_modules: dict
+    amdgpu_modinfo: Optional[ModuleInfo] = None

nodescraper/plugins/inband/kernel_module/kernel_module_plugin.py

@@ -0,0 +1,43 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from nodescraper.base import InBandDataPlugin
+
+from .analyzer_args import KernelModuleAnalyzerArgs
+from .kernel_module_analyzer import KernelModuleAnalyzer
+from .kernel_module_collector import KernelModuleCollector
+from .kernel_module_data import KernelModuleDataModel
+
+
+class KernelModulePlugin(InBandDataPlugin[KernelModuleDataModel, None, KernelModuleAnalyzerArgs]):
+    """Plugin for collection and analysis of kernel data"""
+
+    DATA_MODEL = KernelModuleDataModel
+
+    COLLECTOR = KernelModuleCollector
+
+    ANALYZER = KernelModuleAnalyzer
+
+    ANALYZER_ARGS = KernelModuleAnalyzerArgs

nodescraper/plugins/inband/memory/__init__.py

@@ -0,0 +1,25 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################

nodescraper/plugins/inband/memory/analyzer_args.py

@@ -0,0 +1,45 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from nodescraper.models.analyzerargs import AnalyzerArgs
+
+from .memorydata import MemoryDataModel
+
+
+class MemoryAnalyzerArgs(AnalyzerArgs):
+    ratio: float = 0.66
+    memory_threshold: str = "30Gi"
+
+    @classmethod
+    def build_from_model(cls, datamodel: MemoryDataModel) -> "MemoryAnalyzerArgs":
+        """build analyzer args from data model
+
+        Args:
+            datamodel (MemoryDataModel): data model for plugin
+
+        Returns:
+            MemoryAnalyzerArgs: instance of analyzer args class
+        """
+        return cls(memory_threshold=datamodel.mem_total)

nodescraper/plugins/inband/memory/memory_analyzer.py

@@ -0,0 +1,98 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from typing import Optional
+
+from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus
+from nodescraper.interfaces import DataAnalyzer
+from nodescraper.models import TaskResult
+from nodescraper.utils import convert_to_bytes
+
+from .analyzer_args import MemoryAnalyzerArgs
+from .memorydata import MemoryDataModel
+
+
+class MemoryAnalyzer(DataAnalyzer[MemoryDataModel, MemoryAnalyzerArgs]):
+    """Check memory usage is within the maximum allowed used memory"""
+
+    DATA_MODEL = MemoryDataModel
+
+    def analyze_data(
+        self, data: MemoryDataModel, args: Optional[MemoryAnalyzerArgs] = None
+    ) -> TaskResult:
+        """Analyze the memory data to check if the memory usage is within the maximum allowed used memory.
+
+        Args:
+            data (MemoryDataModel): memory data to analyze.
+            args (Optional[MemoryAnalyzerArgs], optional): memory analysis arguments. Defaults to None.
+        Returns:
+            TaskResult: Result of the memory analysis containing the status and message.
+        """
+
+        if not args:
+            args = MemoryAnalyzerArgs()
+
+        def _bytes_to_gb(n: float) -> float:
+            return n / (1024**3)
+
+        free_memory = convert_to_bytes(data.mem_free)
+        total_memory = convert_to_bytes(data.mem_total)
+        used_memory = total_memory - free_memory
+
+        threshold_bytes = convert_to_bytes(args.memory_threshold)
+
+        if total_memory > threshold_bytes:
+            base_bytes = threshold_bytes
+            base_source = "memory_threshold (max_expected)"
+        else:
+            base_bytes = total_memory
+            base_source = "total_memory"
+
+        max_allowed_used_mem = base_bytes * args.ratio
+
+        used_gb = _bytes_to_gb(used_memory)
+        allowed_gb = _bytes_to_gb(max_allowed_used_mem)
+        base_gb = _bytes_to_gb(base_bytes)
+
+        if used_memory < max_allowed_used_mem:
+            self.result.message = (
+                f"Memory usage is within limit: Used {used_gb:.2f} GB "
+                f"(allowed {allowed_gb:.2f} GB; base={base_source} {base_gb:.2f} GB × ratio={args.ratio:.2f})"
+            )
+            self.result.status = ExecutionStatus.OK
+        else:
+            self.result.message = (
+                f"Memory usage exceeded max allowed! Used {used_gb:.2f} GB, "
+                f"max allowed {allowed_gb:.2f} GB "
+                f"(base={base_source} {base_gb:.2f} GB × ratio={args.ratio:.2f})"
+            )
+            self.result.status = ExecutionStatus.ERROR
+            self._log_event(
+                category=EventCategory.OS,
+                description=self.result.message,
+                priority=EventPriority.CRITICAL,
+            )
+
+        return self.result