added filtering for devices, bug fix + updated utest

Author: alexandraBara

nodescraper/plugins/inband/storage/analyzer_args.py

@@ -30,4 +30,5 @@
 
 class StorageAnalyzerArgs(BaseModel):
     min_required_free_space_abs: Optional[str] = None
-    min_required_free_space_prct: int = 10
+    min_required_free_space_prct: Optional[int] = None
+    ignore_devices: Optional[list] = []

nodescraper/plugins/inband/storage/storage_analyzer.py

@@ -53,13 +53,23 @@ def analyze_data(
         """
         if args is None:
             args = StorageAnalyzerArgs()
+            if (
+                args.min_required_free_space_abs is None
+                and args.min_required_free_space_prct is None
+            ):
+                args.min_required_free_space_prct = 10
+                self.logger.warning(
+                    "No defaults provided for storage analyzer arguments. Setting min_required_free_space_prct=10"
+                )
 
         if not data.storage_data:
             self.result.message = "No storage data available"
             self.result.status = ExecutionStatus.NOT_RAN
             return self.result
 
         for device_name, device_data in data.storage_data.items():
+            if args.ignore_devices and device_name in args.ignore_devices:
+                continue
             condition = False
             if args.min_required_free_space_abs:
                 min_free_abs = convert_to_bytes(args.min_required_free_space_abs)
@@ -69,35 +79,29 @@ def analyze_data(
             else:
                 condition = True
 
-            free_prct = 100 - device_data.percent
-            condition = condition and (free_prct < args.min_required_free_space_prct)
+            if args.min_required_free_space_prct:
+                free_prct = 100 - device_data.percent
+                condition = condition and (free_prct > args.min_required_free_space_prct)
 
             if condition:
                 self.result.message = f"'{device_name}' has {bytes_to_human_readable(device_data.free)} available, {device_data.percent}% used"
                 self.result.status = ExecutionStatus.OK
-                break
             else:
                 self.result.message = "Not enough disk storage!"
                 self.result.status = ExecutionStatus.ERROR
-                # find the device with the largest total storage, and its free space
-                largest_device = max(
-                    data.storage_data,
-                    key=lambda x: convert_to_bytes(str(data.storage_data[x].total)),
-                )
-                largest_free = data.storage_data[largest_device].free
-                largest_percent = data.storage_data[largest_device].percent
-                largest_used = data.storage_data[largest_device].used
                 event_data = {
-                    "largest_device": {
-                        "device": largest_device,
-                        "total": data.storage_data[largest_device].total,
-                        "free": largest_free,
-                        "percent": largest_percent,
+                    "offending_device": {
+                        "device": device_name,
+                        "total": device_data.total,
+                        "free": device_data.free,
+                        "percent": device_data.percent,
                     },
                 }
+                device = convert_to_bytes(str(device_data.total))
+                prct = device_data.percent
                 self._log_event(
                     category=EventCategory.STORAGE,
-                    description=f"{self.result.message} {bytes_to_human_readable(largest_used)} and {largest_percent}%,  used on {largest_device}",
+                    description=f"{self.result.message} {bytes_to_human_readable(device)} and {prct}%,  used on {device_name}",
                     data=event_data,
                     priority=EventPriority.CRITICAL,
                     console_log=True,

test/unit/plugin/test_storage_analyzer.py

@@ -57,22 +57,21 @@ def analyzer(system_info):
 
 
 def test_only_absolute_threshold_fails(analyzer, model_obj):
-    args = StorageAnalyzerArgs(min_required_free_space_abs="1TB")
+    args = StorageAnalyzerArgs(min_required_free_space_abs="800GB")
     result = analyzer.analyze_data(model_obj, args)
-    assert result.status == ExecutionStatus.ERROR
-    assert any(event.category == EventCategory.STORAGE.value for event in result.events)
-    assert any(event.priority == EventPriority.CRITICAL for event in result.events)
+    assert result.status == ExecutionStatus.OK
+    assert "'/dev/nvme0n1p2' has 869.8GB available, 3.0% used" in result.message
 
 
 def test_only_percentage_threshold_fails(analyzer, model_obj):
-    args = StorageAnalyzerArgs(min_required_free_space_prct=50)
+    args = StorageAnalyzerArgs(min_required_free_space_prct=99)
     result = analyzer.analyze_data(model_obj, args)
     assert result.status == ExecutionStatus.ERROR
     assert any(event.category == EventCategory.STORAGE.value for event in result.events)
     assert any(event.priority == EventPriority.CRITICAL for event in result.events)
 
 
-def test_windows_nominal(system_info):
+def test_both_abs_and_prct_fail(system_info):
     system_info.os_family = OSFamily.WINDOWS
     analyzer = StorageAnalyzer(system_info=system_info)
 
@@ -87,14 +86,29 @@ def test_windows_nominal(system_info):
         }
     )
 
-    args = StorageAnalyzerArgs(min_required_free_space_abs="10GB", min_required_free_space_prct=50)
+    args = StorageAnalyzerArgs(min_required_free_space_abs="10GB", min_required_free_space_prct=96)
     result = analyzer.analyze_data(model, args)
-    assert result.status == ExecutionStatus.OK
-    assert " has 466.44GB available, 53.97% used" in result.message
-    assert len(result.events) == 0
+    assert result.status == ExecutionStatus.ERROR
+    assert "Not enough disk storage!" in result.message
+    assert len(result.events) == 1
+    assert any(e.category == EventCategory.STORAGE.value for e in result.events)
+    assert any(e.priority == EventPriority.CRITICAL for e in result.events)
 
-    args2 = StorageAnalyzerArgs(min_required_free_space_prct=40)
+    args2 = StorageAnalyzerArgs(min_required_free_space_prct=40, min_required_dree_space_abs="1GB")
     result2 = analyzer.analyze_data(model, args2)
-    assert result2.status == ExecutionStatus.ERROR
-    assert any(e.category == EventCategory.STORAGE.value for e in result2.events)
-    assert any(e.priority == EventPriority.CRITICAL for e in result2.events)
+    assert result2.status == ExecutionStatus.OK
+
+
+def test_device_filter(analyzer, model_obj):
+    model_obj.storage_data["some_device"] = DeviceStorageData(
+        total=1000, free=100, used=900, percent=90
+    )
+
+    args = StorageAnalyzerArgs(min_required_free_space_prct="20")
+    result = analyzer.analyze_data(model_obj, args)
+    assert result.status == ExecutionStatus.ERROR
+    assert len(result.events) == 1
+
+    args2 = StorageAnalyzerArgs(min_required_free_space_prct="20", ignore_devices=["some_device"])
+    result2 = analyzer.analyze_data(model_obj, args2)
+    assert result2.status == ExecutionStatus.OK