Merge branch 'development' into alex_dmidecode

Author: alexandraBara

docs/PLUGIN_DOC.md

@@ -17,8 +17,8 @@
 | MemoryPlugin | free -b<br>/usr/bin/lsmem<br>wmic OS get FreePhysicalMemory /Value; wmic ComputerSystem get TotalPhysicalMemory /Value | - | [MemoryDataModel](#MemoryDataModel-Model) | [MemoryCollector](#Collector-Class-MemoryCollector) | [MemoryAnalyzer](#Data-Analyzer-Class-MemoryAnalyzer) |
 | NvmePlugin | nvme smart-log {dev}<br>nvme error-log {dev} --log-entries=256<br>nvme id-ctrl {dev}<br>nvme id-ns {dev}{ns}<br>nvme fw-log {dev}<br>nvme self-test-log {dev}<br>nvme get-log {dev} --log-id=6 --log-len=512<br>nvme telemetry-log {dev} --output-file={dev}_{f_name} | - | [NvmeDataModel](#NvmeDataModel-Model) | [NvmeCollector](#Collector-Class-NvmeCollector) | - |
 | OsPlugin | sh -c '( lsb_release -ds \|\| (cat /etc/*release \| grep PRETTY_NAME) \|\| uname -om ) 2>/dev/null \| head -n1'<br>cat /etc/*release \| grep VERSION_ID<br>wmic os get Version /value<br>wmic os get Caption /Value | **Analyzer Args:**<br>- `exp_os`: Union[str, list]<br>- `exact_match`: bool | [OsDataModel](#OsDataModel-Model) | [OsCollector](#Collector-Class-OsCollector) | [OsAnalyzer](#Data-Analyzer-Class-OsAnalyzer) |
-| PackagePlugin | dnf list --installed<br>dpkg-query -W<br>pacman -Q<br>cat /etc/*release<br>wmic product get name,version | **Analyzer Args:**<br>- `exp_package_ver`: Dict[str, Optional[str]]<br>- `regex_match`: bool | [PackageDataModel](#PackageDataModel-Model) | [PackageCollector](#Collector-Class-PackageCollector) | [PackageAnalyzer](#Data-Analyzer-Class-PackageAnalyzer) |
-| PciePlugin | lspci -d {vendor_id}: -nn<br>lspci -x<br>lspci -xxxx<br>lspci -PP<br>lspci -PP -d {vendor_id}:{dev_id}<br>lspci -vt<br>lspci -vvv | **Analyzer Args:**<br>- `exp_speed`: int<br>- `exp_width`: int<br>- `exp_sriov_count`: int<br>- `exp_gpu_count_override`: Optional[int]<br>- `exp_max_payload_size`: Union[Dict[int, int], int, NoneType]<br>- `exp_max_rd_req_size`: Union[Dict[int, int], int, NoneType]<br>- `exp_ten_bit_tag_req_en`: Union[Dict[int, int], int, NoneType] | [PcieDataModel](#PcieDataModel-Model) | [PcieCollector](#Collector-Class-PcieCollector) | [PcieAnalyzer](#Data-Analyzer-Class-PcieAnalyzer) |
+| PackagePlugin | dnf list --installed<br>dpkg-query -W<br>pacman -Q<br>cat /etc/*release<br>wmic product get name,version | **Analyzer Args:**<br>- `exp_package_ver`: Dict[str, Optional[str]]<br>- `regex_match`: bool<br>- `rocm_regex`: Optional[str]<br>- `enable_rocm_regex`: bool | [PackageDataModel](#PackageDataModel-Model) | [PackageCollector](#Collector-Class-PackageCollector) | [PackageAnalyzer](#Data-Analyzer-Class-PackageAnalyzer) |
+| PciePlugin | lspci -d {vendor_id}: -nn<br>lspci -x<br>lspci -xxxx<br>lspci -PP<br>lspci -PP -d {vendor_id}:{dev_id}<br>lspci -vvv<br>lspci -vvvt | **Analyzer Args:**<br>- `exp_speed`: int<br>- `exp_width`: int<br>- `exp_sriov_count`: int<br>- `exp_gpu_count_override`: Optional[int]<br>- `exp_max_payload_size`: Union[Dict[int, int], int, NoneType]<br>- `exp_max_rd_req_size`: Union[Dict[int, int], int, NoneType]<br>- `exp_ten_bit_tag_req_en`: Union[Dict[int, int], int, NoneType] | [PcieDataModel](#PcieDataModel-Model) | [PcieCollector](#Collector-Class-PcieCollector) | [PcieAnalyzer](#Data-Analyzer-Class-PcieAnalyzer) |
 | ProcessPlugin | top -b -n 1<br>rocm-smi --showpids<br>top -b -n 1 -o %CPU  | **Analyzer Args:**<br>- `max_kfd_processes`: int<br>- `max_cpu_usage`: float | [ProcessDataModel](#ProcessDataModel-Model) | [ProcessCollector](#Collector-Class-ProcessCollector) | [ProcessAnalyzer](#Data-Analyzer-Class-ProcessAnalyzer) |
 | RocmPlugin | {rocm_path}/opencl/bin/*/clinfo<br>env \| grep -Ei 'rocm\|hsa\|hip\|mpi\|openmp\|ucx\|miopen'<br>ls /sys/class/kfd/kfd/proc/<br>grep -i -E 'rocm' /etc/ld.so.conf.d/*<br>{rocm_path}/bin/rocminfo<br>ls -v -d /opt/rocm*<br>ls -v -d /opt/rocm-[3-7]* \| tail -1<br>ldconfig -p \| grep -i -E 'rocm'<br>/opt/rocm/.info/version-rocm<br>/opt/rocm/.info/version | **Analyzer Args:**<br>- `exp_rocm`: Union[str, list]<br>- `exp_rocm_latest`: str | [RocmDataModel](#RocmDataModel-Model) | [RocmCollector](#Collector-Class-RocmCollector) | [RocmAnalyzer](#Data-Analyzer-Class-RocmAnalyzer) |
 | StoragePlugin | sh -c 'df -lH -B1 \| grep -v 'boot''<br>wmic LogicalDisk Where DriveType="3" Get DeviceId,Size,FreeSpace | - | [StorageDataModel](#StorageDataModel-Model) | [StorageCollector](#Collector-Class-StorageCollector) | [StorageAnalyzer](#Data-Analyzer-Class-StorageAnalyzer) |
@@ -428,7 +428,7 @@ class for collection of PCIe data only supports Linux OS type.
 
     This class will collect important PCIe data from the system running the commands
     - `lspci -vvv` : Verbose collection of PCIe data
-    - `lspci -vt`: Tree view of PCIe data
+    - `lspci -vvvt`: Verbose tree view of PCIe data
     - `lspci -PP`: Path view of PCIe data for the GPUs
     - If system interaction level is set to STANDARD or higher, the following commands will be run with sudo:
         - `lspci -xxxx`: Hex view of PCIe data for the GPUs
@@ -448,7 +448,7 @@ class for collection of PCIe data only supports Linux OS type.
 
 - **SUPPORTED_OS_FAMILY**: `{<OSFamily.LINUX: 3>}`
 - **CMD_LSPCI_VERBOSE**: `lspci -vvv`
-- **CMD_LSPCI_TREE**: `lspci -vt`
+- **CMD_LSPCI_VERBOSE_TREE**: `lspci -vvvt`
 - **CMD_LSPCI_PATH**: `lspci -PP`
 - **CMD_LSPCI_HEX_SUDO**: `lspci -xxxx`
 - **CMD_LSPCI_HEX**: `lspci -x`
@@ -466,8 +466,8 @@ PcieDataModel
 - lspci -xxxx
 - lspci -PP
 - lspci -PP -d {vendor_id}:{dev_id}
-- lspci -vt
 - lspci -vvv
+- lspci -vvvt
 
 ## Collector Class ProcessCollector
 
@@ -810,6 +810,8 @@ Pacakge data contains the package data for the system
 ### Model annotations and fields
 
 - **version_info**: `dict[str, str]`
+- **rocm_regex**: `str`
+- **enable_rocm_regex**: `bool`
 
 ## PcieDataModel Model
 
@@ -1322,6 +1324,8 @@ Check sysctl matches expected sysctl details
 
 - **exp_package_ver**: `Dict[str, Optional[str]]`
 - **regex_match**: `bool`
+- **rocm_regex**: `Optional[str]`
+- **enable_rocm_regex**: `bool`
 
 ## Analyzer Args Class PcieAnalyzerArgs
 

nodescraper/interfaces/task.py

@@ -107,6 +107,8 @@ def _build_event(
             data = {"task_name": self.__class__.__name__, "task_type": self.TASK_TYPE}
 
         else:
+            # Copy to avoid mutating the caller's dict
+            data = copy.copy(data)
             data["task_name"] = self.__class__.__name__
             data["task_type"] = self.TASK_TYPE
 

nodescraper/plugins/inband/device_enumeration/device_enumeration_collector.py

@@ -26,7 +26,7 @@
 from typing import Optional
 
 from nodescraper.base import InBandDataCollector
-from nodescraper.connection.inband.inband import CommandArtifact
+from nodescraper.connection.inband.inband import CommandArtifact, TextFileArtifact
 from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus, OSFamily
 from nodescraper.models import TaskResult
 
@@ -38,9 +38,10 @@ class DeviceEnumerationCollector(InBandDataCollector[DeviceEnumerationDataModel,
 
     DATA_MODEL = DeviceEnumerationDataModel
 
-    CMD_CPU_COUNT_LINUX = "lscpu | grep Socket | awk '{ print $2 }'"
     CMD_GPU_COUNT_LINUX = "lspci -d {vendorid_ep}: | grep -i 'VGA\\|Display\\|3D' | wc -l"
     CMD_VF_COUNT_LINUX = "lspci -d {vendorid_ep}: | grep -i 'Virtual Function' | wc -l"
+    CMD_LSCPU_LINUX = "lscpu"
+    CMD_LSHW_LINUX = "lshw"
 
     CMD_CPU_COUNT_WINDOWS = (
         'powershell -Command "(Get-WmiObject -Class Win32_Processor | Measure-Object).Count"'
@@ -61,9 +62,8 @@ def _warning(
             description=description,
             data={
                 "command": command.command,
-                "stdout": command.stdout,
-                "stderr": command.stderr,
                 "exit_code": command.exit_code,
+                "stderr": command.stderr,
             },
             priority=EventPriority.WARNING,
         )
@@ -75,8 +75,7 @@ def collect_data(self, args=None) -> tuple[TaskResult, Optional[DeviceEnumeratio
         On Windows, use WMI and hyper-v cmdlets
         """
         if self.system_info.os_family == OSFamily.LINUX:
-            # Count CPU sockets
-            cpu_count_res = self._run_sut_cmd(self.CMD_CPU_COUNT_LINUX)
+            lscpu_res = self._run_sut_cmd(self.CMD_LSCPU_LINUX, log_artifact=False)
 
             # Count all AMD GPUs
             vendor_id = format(self.system_info.vendorid_ep, "x")
@@ -86,17 +85,42 @@ def collect_data(self, args=None) -> tuple[TaskResult, Optional[DeviceEnumeratio
 
             # Count AMD Virtual Functions
             vf_count_res = self._run_sut_cmd(self.CMD_VF_COUNT_LINUX.format(vendorid_ep=vendor_id))
+
+            # Collect lshw output
+            lshw_res = self._run_sut_cmd(self.CMD_LSHW_LINUX, sudo=True, log_artifact=False)
         else:
             cpu_count_res = self._run_sut_cmd(self.CMD_CPU_COUNT_WINDOWS)
             gpu_count_res = self._run_sut_cmd(self.CMD_GPU_COUNT_WINDOWS)
             vf_count_res = self._run_sut_cmd(self.CMD_VF_COUNT_WINDOWS)
 
         device_enum = DeviceEnumerationDataModel()
 
-        if cpu_count_res.exit_code == 0:
-            device_enum.cpu_count = int(cpu_count_res.stdout)
+        if self.system_info.os_family == OSFamily.LINUX:
+            if lscpu_res.exit_code == 0 and lscpu_res.stdout:
+                # Extract socket count from lscpu output
+                for line in lscpu_res.stdout.splitlines():
+                    if line.startswith("Socket(s):"):
+                        try:
+                            device_enum.cpu_count = int(line.split(":")[1].strip())
+                            break
+                        except (ValueError, IndexError):
+                            self._warning(
+                                description="Cannot parse CPU count from lscpu output",
+                                command=lscpu_res,
+                            )
+                device_enum.lscpu_output = lscpu_res.stdout
+                self._log_event(
+                    category=EventCategory.PLATFORM,
+                    description="Collected lscpu output",
+                    priority=EventPriority.INFO,
+                )
+            else:
+                self._warning(description="Cannot collect lscpu output", command=lscpu_res)
         else:
-            self._warning(description="Cannot determine CPU count", command=cpu_count_res)
+            if cpu_count_res.exit_code == 0:
+                device_enum.cpu_count = int(cpu_count_res.stdout)
+            else:
+                self._warning(description="Cannot determine CPU count", command=cpu_count_res)
 
         if gpu_count_res.exit_code == 0:
             device_enum.gpu_count = int(gpu_count_res.stdout)
@@ -112,14 +136,33 @@ def collect_data(self, args=None) -> tuple[TaskResult, Optional[DeviceEnumeratio
                 category=EventCategory.SW_DRIVER,
             )
 
+        # Collect lshw output on Linux
+        if self.system_info.os_family == OSFamily.LINUX:
+            if lshw_res.exit_code == 0 and lshw_res.stdout:
+                device_enum.lshw_output = lshw_res.stdout
+                self.result.artifacts.append(
+                    TextFileArtifact(filename="lshw.txt", contents=lshw_res.stdout)
+                )
+                self._log_event(
+                    category=EventCategory.PLATFORM,
+                    description="Collected lshw output",
+                    priority=EventPriority.INFO,
+                )
+            else:
+                self._warning(description="Cannot collect lshw output", command=lshw_res)
+
         if device_enum.cpu_count or device_enum.gpu_count or device_enum.vf_count:
+            log_data = device_enum.model_dump(
+                exclude_none=True,
+                exclude={"lscpu_output", "lshw_output", "task_name", "task_type", "parent"},
+            )
             self._log_event(
                 category=EventCategory.PLATFORM,
                 description=f"Counted {device_enum.cpu_count} CPUs, {device_enum.gpu_count} GPUs, {device_enum.vf_count} VFs",
-                data=device_enum.model_dump(exclude_none=True),
+                data=log_data,
                 priority=EventPriority.INFO,
             )
-            self.result.message = f"Device Enumeration: {device_enum.model_dump(exclude_none=True)}"
+            self.result.message = f"Device Enumeration: {log_data}"
             self.result.status = ExecutionStatus.OK
             return self.result, device_enum
         else:

nodescraper/plugins/inband/device_enumeration/deviceenumdata.py

@@ -32,3 +32,5 @@ class DeviceEnumerationDataModel(DataModel):
     cpu_count: Optional[int] = None
     gpu_count: Optional[int] = None
     vf_count: Optional[int] = None
+    lscpu_output: Optional[str] = None
+    lshw_output: Optional[str] = None

nodescraper/plugins/inband/package/analyzer_args.py

@@ -34,7 +34,15 @@
 class PackageAnalyzerArgs(AnalyzerArgs):
     exp_package_ver: Dict[str, Optional[str]] = Field(default_factory=dict)
     regex_match: bool = False
+    # rocm_regex is optional and should be specified in plugin_config.json if needed
+    rocm_regex: Optional[str] = None
+    enable_rocm_regex: bool = False
 
     @classmethod
     def build_from_model(cls, datamodel: PackageDataModel) -> "PackageAnalyzerArgs":
-        return cls(exp_package_ver=datamodel.version_info)
+        # Use custom rocm_regex from collection_args if enable_rocm_regex is true
+        rocm_regex = None
+        if datamodel.enable_rocm_regex and datamodel.rocm_regex:
+            rocm_regex = datamodel.rocm_regex
+
+        return cls(exp_package_ver=datamodel.version_info, rocm_regex=rocm_regex)

nodescraper/plugins/inband/package/package_analyzer.py

@@ -44,7 +44,7 @@ def regex_version_data(
         package_data: dict[str, str],
         key_search: re.Pattern[str],
         value_search: Optional[Pattern[str]],
-    ) -> bool:
+    ) -> tuple[bool, list[tuple[str, str, str]]]:
         """Searches the package values for the key and value search patterns
 
         Args:
@@ -53,10 +53,12 @@ def regex_version_data(
             value_search (Optional[Pattern[str]]): a compiled regex pattern to search for the package version, if None then any version is accepted
 
         Returns:
-            bool: A boolean indicating if the value was found
+            tuple: (value_found, version_mismatches) where value_found is a bool and
+                   version_mismatches is a list of (package_name, expected_pattern, found_version) tuples
         """
 
         value_found = False
+        version_mismatches = []
         for name, version in package_data.items():
             self.logger.debug("Package data: %s, %s", name, version)
             key_search_res = key_search.search(name)
@@ -66,6 +68,7 @@ def regex_version_data(
                     continue
                 value_search_res = value_search.search(version)
                 if not value_search_res:
+                    version_mismatches.append((name, value_search.pattern, version))
                     self._log_event(
                         EventCategory.APPLICATION,
                         f"Package {key_search.pattern} Version Mismatch, Expected {value_search.pattern} but found {version}",
@@ -77,7 +80,7 @@ def regex_version_data(
                             "found_version": version,
                         },
                     )
-        return value_found
+        return value_found, version_mismatches
 
     def package_regex_search(
         self, package_data: dict[str, str], exp_package_data: dict[str, Optional[str]]
@@ -87,16 +90,23 @@ def package_regex_search(
         Args:
             package_data (dict[str, str]): a dictionary of package names and versions
             exp_package_data (dict[str, Optional[str]]): a dictionary of expected package names and versions
+
+        Returns:
+            tuple: (not_found_keys, regex_errors, version_mismatches) containing lists of errors
         """
         not_found_keys = []
+        regex_errors = []
+        version_mismatches = []
+
         for exp_key, exp_value in exp_package_data.items():
             try:
                 if exp_value is not None:
                     value_search = re.compile(exp_value)
                 else:
                     value_search = None
                 key_search = re.compile(exp_key)
-            except re.error:
+            except re.error as e:
+                regex_errors.append((exp_key, exp_value, str(e)))
                 self._log_event(
                     EventCategory.RUNTIME,
                     f"Regex Compile Error either {exp_key} {exp_value}",
@@ -108,10 +118,13 @@ def package_regex_search(
                 )
                 continue
 
-            key_found = self.regex_version_data(package_data, key_search, value_search)
+            key_found, mismatches = self.regex_version_data(package_data, key_search, value_search)
+
+            # Collect version mismatches
+            version_mismatches.extend(mismatches)
 
             if not key_found:
-                not_found_keys.append(exp_key)
+                not_found_keys.append((exp_key, exp_value))
                 self._log_event(
                     EventCategory.APPLICATION,
                     f"Package {exp_key} not found in the package list",
@@ -123,7 +136,8 @@ def package_regex_search(
                         "found_version": None,
                     },
                 )
-        return not_found_keys
+
+        return not_found_keys, regex_errors, version_mismatches
 
     def package_exact_match(
         self, package_data: dict[str, str], exp_package_data: dict[str, Optional[str]]
@@ -190,9 +204,43 @@ def analyze_data(
             return self.result
 
         if args.regex_match:
-            not_found_keys = self.package_regex_search(data.version_info, args.exp_package_ver)
-            self.result.message = f"Packages not found: {not_found_keys}"
-            self.result.status = ExecutionStatus.ERROR
+            not_found_keys, regex_errors, version_mismatches = self.package_regex_search(
+                data.version_info, args.exp_package_ver
+            )
+
+            # Adding details for err message
+            error_parts = []
+            if not_found_keys:
+                packages_detail = ", ".join(
+                    [
+                        f"'{pkg}' (expected version: {ver if ver else 'any'})"
+                        for pkg, ver in not_found_keys
+                    ]
+                )
+                error_parts.append(f"Packages not found: {packages_detail}")
+
+            if regex_errors:
+                regex_detail = ", ".join(
+                    [f"'{pkg}' pattern (version: {ver})" for pkg, ver, _ in regex_errors]
+                )
+                error_parts.append(f"Regex compile errors: {regex_detail}")
+
+            if version_mismatches:
+                version_detail = ", ".join(
+                    [
+                        f"'{pkg}' (expected: {exp}, found: {found})"
+                        for pkg, exp, found in version_mismatches
+                    ]
+                )
+                error_parts.append(f"Version mismatches: {version_detail}")
+
+            total_errors = len(not_found_keys) + len(regex_errors) + len(version_mismatches)
+            if total_errors > 0:
+                self.result.message = f"{'; '.join(error_parts)}"
+                self.result.status = ExecutionStatus.ERROR
+            else:
+                self.result.message = "All packages found and versions matched"
+                self.result.status = ExecutionStatus.OK
         else:
             self.logger.info("Expected packages: %s", list(args.exp_package_ver.keys()))
             not_found_match, not_found_version = self.package_exact_match(