sts-libs 2.4.1__tar.gz → 2.4.2__tar.gz

{sts_libs-2.4.1 → sts_libs-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sts-libs
-Version: 2.4.1
+Version: 2.4.2
 Summary: Library for pytest-based Linux storage tests
 Project-URL: Repository, https://gitlab.com/rh-kernel-stqe/sts/
 Author-email: Martin Hoyer <mhoyer@redhat.com>, Filip Suba <fsuba@redhat.com>, Zhaojuan Guo <zguo@redhat.com>, Bruno Goncalves <bgoncalv@redhat.com>, Jakub Krysl <jkrysl@redhat.com>

{sts_libs-2.4.1 → sts_libs-2.4.2}/pyproject.toml

@@ -7,7 +7,7 @@ name = 'sts-libs'
 description = 'Library for pytest-based Linux storage tests'
 readme = 'sts_libs/README.md'
 requires-python = '>=3.12'
-version = "2.4.1"
+version = "2.4.2"
 authors = [
   {name = 'Martin Hoyer', email = 'mhoyer@redhat.com'},
   {name = 'Filip Suba', email = 'fsuba@redhat.com'},

{sts_libs-2.4.1 → sts_libs-2.4.2}/sts_libs/src/sts/fixtures/iscsi_fixtures.py

@@ -19,11 +19,15 @@ from sts.iscsi.session import IscsiSession
 from sts.multipath import MultipathDevice, MultipathService
 from sts.scsi import ScsiDevice
 from sts.target import BackstoreFileio, Iscsi, IscsiLUN, create_basic_iscsi_target
+from sts.utils import wait_for
 from sts.utils.packages import ensure_installed, log_package_versions
 from sts.utils.system import SystemManager
 
 logger = logging.getLogger(__name__)
 
+ISCSI_DEVICE_SETTLE_TIMEOUT = 60
+ISCSI_DEVICE_POLL_INTERVAL = 0.2
+
 
 def generate_test_iqns(test_name: str) -> tuple[str, str, str]:
     """Generate (base_iqn, target_iqn, initiator_iqn) from test name."""
@@ -63,30 +67,62 @@ def iscsi_localhost_test(request: pytest.FixtureRequest, _iscsi_test: None) -> G
     target.delete_target()
 
 
-@pytest.fixture
-def get_test_device() -> Callable[[str], list[Path]]:
-    """Return a callable that finds test device paths (multipath first, then SCSI vendor)."""
-
-    def _get_test_device(vendor: str = 'LIO-ORG') -> list[Path]:
-        def _extract_paths(devices: Sequence[StorageDevice]) -> list[Path]:
-            return [Path(str(d.path)) for d in devices if d.path]
-
-        mp_service = MultipathService()
-        if mp_service.is_running():
-            devices = MultipathDevice.get_all()
-            if devices:
-                paths = _extract_paths(devices)
-                if paths:
-                    return paths
-
-        devices = ScsiDevice.get_by_vendor(vendor)
-        assert devices, f'No {vendor} devices found'
-
-        paths = _extract_paths(devices)
-        assert paths, f'No valid device paths found for {vendor} devices'
+def _get_target_device_paths(target_iqn: str) -> list[Path]:
+    """Return running SCSI disks belonging to an active target session."""
+    return [
+        ScsiDevice.DEV_PATH / disk.name
+        for session in IscsiSession.get_by_target(target_iqn)
+        for disk in session.get_disks()
+        if disk.is_running()
+    ]
+
+
+def _device_is_openable(path: Path) -> bool:
+    """Check whether a device node can be opened without issuing data I/O."""
+    try:
+        with path.open('rb'):
+            pass
+    except OSError:
+        return False
+    return True
+
+
+def _target_devices_ready(target_iqn: str, expected_count: int) -> bool:
+    """Check that all expected target disks are running and openable."""
+    paths = _get_target_device_paths(target_iqn)
+    return len(paths) == expected_count and all(_device_is_openable(path) for path in paths)
+
+
+def _find_test_devices(vendor: str = 'LIO-ORG', *, target_iqn: str | None = None) -> list[Path]:
+    """Find test device paths, optionally restricted to one iSCSI target."""
+    if target_iqn is not None:
+        paths = _get_target_device_paths(target_iqn)
+        assert paths, f'No running devices found for iSCSI target {target_iqn}'
         return paths
 
-    return _get_test_device
+    def _extract_paths(devices: Sequence[StorageDevice]) -> list[Path]:
+        return [Path(str(d.path)) for d in devices if d.path]
+
+    mp_service = MultipathService()
+    if mp_service.is_running():
+        devices = MultipathDevice.get_all()
+        if devices:
+            paths = _extract_paths(devices)
+            if paths:
+                return paths
+
+    devices = ScsiDevice.get_by_vendor(vendor)
+    assert devices, f'No {vendor} devices found'
+
+    paths = _extract_paths(devices)
+    assert paths, f'No valid device paths found for {vendor} devices'
+    return paths
+
+
+@pytest.fixture
+def get_test_device() -> Callable[..., list[Path]]:
+    """Return a callable that finds test device paths."""
+    return _find_test_devices
 
 
 @pytest.fixture
@@ -121,6 +157,11 @@ def iscsi_target(request: pytest.FixtureRequest, iscsi_localhost_test: None) ->
         target_iqn=target_iqn,
     )
     try:
+        assert wait_for(
+            lambda: _target_devices_ready(target_iqn, n_luns),
+            timeout=ISCSI_DEVICE_SETTLE_TIMEOUT,
+            poll=ISCSI_DEVICE_POLL_INTERVAL,
+        ), f'Timed out waiting for {n_luns} usable device(s) from iSCSI target {target_iqn}'
         yield node
     finally:
         node.logout()

{sts_libs-2.4.1 → sts_libs-2.4.2}/sts_libs/src/sts/pr.py

@@ -72,16 +72,21 @@ class PRDevice(StorageDevice):
         """Wait for udev, validate PR support, optionally register key, and load state.
 
         Raises:
-            DeviceError: If device is not fully ready or does not support
-                persistent reservations.
+            DeviceError: If the device is not ready or its persistent reservation
+                capabilities cannot be verified.
         """
         # Wait for device to be fully available before PR operations
         if not self.wait_udev():
             raise DeviceError(f'Device {self.path} is not fully ready')
 
-        # Validate PR capability
-        if not self.supports_pr:
-            raise DeviceError(f'Device {self.path} does not support persistent reservations')
+        # Validate PR capability while preserving the reason a query failed.
+        if not self.path:
+            raise DeviceError('Cannot check persistent reservation capabilities without a device path')
+        capabilities = self._sg_persist.report_capabilities_result(self.path)
+        if capabilities.failed:
+            detail = capabilities.stderr.strip() or f'exit status {capabilities.rc}'
+            raise DeviceError(f'Could not verify persistent reservation support on {self.path}: {detail}')
+        self._supports_pr = True
 
         # Auto-register key if requested
         if self.auto_register and self.register_key:

{sts_libs-2.4.1 → sts_libs-2.4.2}/sts_libs/src/sts/sg3_utils.py

@@ -459,12 +459,16 @@ class SgPersist(Sg3UtilsCommand):
 
     def report_capabilities(self, device: str | Path) -> bool:
         """Check whether a device supports persistent reservation operations."""
+        return self.report_capabilities_result(device).succeeded
+
+    def report_capabilities_result(self, device: str | Path) -> CommandResult:
+        """Query persistent reservation capabilities and preserve failure details."""
         result = self._run_command(self.COMMAND, '--in', '--report-capabilities', str(device))
 
         if not result.succeeded:
             logger.warning(f'Failed to check PR capabilities for {device}: {result.stderr}')
 
-        return result.succeeded
+        return result
 
 
 # =============================================================================

sts_libs-2.4.2/sts_libs/tests/fixtures/test_iscsi_fixtures.py

@@ -0,0 +1,69 @@
+# Copyright: Contributors to the sts project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Tests for iSCSI fixture device discovery and readiness."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from sts.fixtures import iscsi_fixtures
+from sts.iscsi.session import SessionDisk
+
+
+def test_get_target_device_paths_uses_matching_running_sessions(monkeypatch: pytest.MonkeyPatch) -> None:
+    session = MagicMock()
+    session.get_disks.return_value = [
+        SessionDisk(name='sdc', state='running', scsi_n='3', channel='0', id='0', lun='0'),
+        SessionDisk(name='sdd', state='blocked', scsi_n='3', channel='0', id='0', lun='1'),
+    ]
+    get_by_target = MagicMock(return_value=[session])
+    monkeypatch.setattr(iscsi_fixtures.IscsiSession, 'get_by_target', get_by_target)
+
+    paths = iscsi_fixtures._get_target_device_paths('iqn.test:target')
+
+    assert paths == [Path('/dev/sdc')]
+    get_by_target.assert_called_once_with('iqn.test:target')
+
+
+def test_target_devices_ready_requires_expected_count_and_openable_paths(monkeypatch: pytest.MonkeyPatch) -> None:
+    paths = [Path('/dev/sdc'), Path('/dev/sdd')]
+    monkeypatch.setattr(iscsi_fixtures, '_get_target_device_paths', lambda _target_iqn: paths)
+    is_openable = MagicMock(side_effect=lambda path: path == Path('/dev/sdc'))
+    monkeypatch.setattr(iscsi_fixtures, '_device_is_openable', is_openable)
+
+    assert not iscsi_fixtures._target_devices_ready('iqn.test:target', 1)
+    assert not iscsi_fixtures._target_devices_ready('iqn.test:target', 2)
+
+    is_openable.side_effect = None
+    is_openable.return_value = True
+    assert iscsi_fixtures._target_devices_ready('iqn.test:target', 2)
+
+
+def test_device_is_openable_checks_the_device_node(tmp_path: Path) -> None:
+    device = tmp_path / 'device'
+    device.touch()
+
+    assert iscsi_fixtures._device_is_openable(device)
+    assert not iscsi_fixtures._device_is_openable(tmp_path / 'missing')
+
+
+def test_find_test_devices_can_be_restricted_to_target(monkeypatch: pytest.MonkeyPatch) -> None:
+    target_paths = [Path('/dev/sdc')]
+    get_target_paths = MagicMock(return_value=target_paths)
+    monkeypatch.setattr(iscsi_fixtures, '_get_target_device_paths', get_target_paths)
+
+    paths = iscsi_fixtures._find_test_devices(target_iqn='iqn.test:target')
+
+    assert paths == target_paths
+    get_target_paths.assert_called_once_with('iqn.test:target')
+
+
+def test_find_test_devices_rejects_target_without_running_disks(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(iscsi_fixtures, '_get_target_device_paths', lambda _target_iqn: [])
+
+    with pytest.raises(AssertionError, match='No running devices found'):
+        iscsi_fixtures._find_test_devices(target_iqn='iqn.test:target')

{sts_libs-2.4.1 → sts_libs-2.4.2}/sts_libs/tests/test_pr.py

@@ -68,7 +68,7 @@ class TestPRDeviceSetup:
         with pytest.raises(DeviceError):
             device.setup()
 
-    def test_setup_raises_when_pr_unsupported(self, mock_run_with_result, mock_command_result) -> None:
+    def test_setup_preserves_pr_capability_failure(self, mock_run_with_result, mock_command_result) -> None:
         _, results = mock_run_with_result
         results['udevadm settle'] = mock_command_result(command='test', rc=0)
         results['sg_persist --in --report-capabilities /dev/sda'] = mock_command_result(
@@ -77,7 +77,10 @@ class TestPRDeviceSetup:
 
         device = PRDevice(path='/dev/sda')
 
-        with pytest.raises(DeviceError, match='does not support persistent reservations'):
+        with pytest.raises(
+            DeviceError,
+            match='Could not verify persistent reservation support on /dev/sda: not supported',
+        ):
             device.setup()
 
     def test_setup_auto_registers_key(self, mock_run_with_result, mock_command_result) -> None:

{sts_libs-2.4.1 → sts_libs-2.4.2}/sts_libs/tests/test_sg3_utils.py

@@ -654,6 +654,22 @@ class TestSgPersistReportCapabilities:
         persist = SgPersist()
         assert persist.report_capabilities('/dev/sda') is False
 
+    def test_report_capabilities_result_preserves_failure(
+        self,
+        mock_run_with_result: tuple[list[str], dict[str, CommandResult]],
+        mock_command_result: type[CommandResult],
+    ) -> None:
+        _calls, results = mock_run_with_result
+        results['sg_persist --in --report-capabilities /dev/sda'] = mock_command_result(
+            command='test', rc=56, stderr='No such device or address'
+        )
+        persist = SgPersist()
+
+        result = persist.report_capabilities_result('/dev/sda')
+
+        assert result.rc == 56
+        assert result.stderr == 'No such device or address'
+
 
 class TestSgInq:
     def test_inquiry_basic(

{sts_libs-2.4.1 → sts_libs-2.4.2}/tests/target/full/persistent-reservation/test_iscsi_pr.py

@@ -31,7 +31,6 @@ Reservation Types Tested:
 
 import logging
 import os
-import time
 from collections.abc import Callable
 
 import pytest
@@ -65,7 +64,7 @@ def test_iscsi_persistent_reservation(iscsi_target: IscsiNode, get_test_device:
     target_iqn = iscsi_target.target_iqn
     assert target_iqn is not None
 
-    iscsi_lun = get_test_device()[0]
+    iscsi_lun = get_test_device(target_iqn=target_iqn)[0]
 
     # Create PR device instance with a specific key
     registration_key = os.getenv('PR_REGISTRATION_KEY', '0xdeadbeef')
@@ -117,7 +116,7 @@ def test_iscsi_persistent_reservation(iscsi_target: IscsiNode, get_test_device:
     logger.info('Key unregistered successfully')
 
 
-@pytest.mark.usefixtures('_target_test')
+@pytest.mark.usefixtures('_target_test', '_require_sg3_utils')
 @pytest.mark.parametrize('iscsi_target', [{'size': '1G', 'n_luns': 1}], indirect=True)
 @pytest.mark.parametrize(
     'reservation_type',
@@ -142,7 +141,7 @@ def test_iscsi_reservation_types(iscsi_target: IscsiNode, get_test_device: Calla
     target_iqn = iscsi_target.target_iqn
     assert target_iqn is not None
 
-    iscsi_lun = get_test_device()[0]
+    iscsi_lun = get_test_device(target_iqn=target_iqn)[0]
 
     logger.info(f'Testing reservation type {reservation_type} on iSCSI LUN: {iscsi_lun}')
 
@@ -184,6 +183,3 @@ def test_iscsi_reservation_types(iscsi_target: IscsiNode, get_test_device: Calla
     logger.info('Key unregistered')
 
     logger.info(f'Reservation type {reservation_type} test completed successfully')
-
-    # Wait 5 seconds between reservation type tests
-    time.sleep(5)

{sts_libs-2.4.1 → sts_libs-2.4.2}/uv.lock

@@ -1001,7 +1001,7 @@ wheels = [
 
 [[package]]
 name = "sts-libs"
-version = "2.4.1"
+version = "2.4.2"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },