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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sts-libs
-Version: 2.4.2
+Version: 2.6.0
 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.6.0/plans/fcoe/bnx2fc.fmf

@@ -0,0 +1,7 @@
+summary: FCoE tests on bnx2fc hardware
+discover:
+    how: fmf
+    filter: 'tag: fcoe & tag: -multihost'
+provision:
+    hardware:
+        hostname: rhel-storage-13.fast.eng.rdu2.dc.redhat.com

sts_libs-2.6.0/plans/fcoe/multihost.fmf

@@ -0,0 +1,16 @@
+enabled: false  # no two-host hardware setup available
+summary: FCoE multihost testing (tcm_fc target + initiator)
+discover:
+    - name: server
+      how: fmf
+      test: /tests/fcoe/multihost
+      where: server
+    - name: client
+      how: fmf
+      test: /tests/fcoe/multihost
+      where: client
+provision:
+    - name: server
+      role: server
+    - name: client
+      role: client

sts_libs-2.6.0/plans/fcoe/qedf.fmf

@@ -0,0 +1,7 @@
+summary: FCoE tests on qedf hardware
+discover:
+    how: fmf
+    filter: 'tag: fcoe & tag: -multihost'
+provision:
+    hardware:
+        hostname: storageqe-15.fast.eng.rdu2.dc.redhat.com

{sts_libs-2.4.2 → sts_libs-2.6.0}/plans/iscsi/offload/bnx2i.fmf

@@ -5,6 +5,6 @@ provision+:
   hardware:
     hostname: storageqe-83.lab.eng.brq2.redhat.com
 adjust+:
-    enabled: false
+  - enabled: false
     when: distro >= rhel-9.5
     because: bnx2 drivers are deprecated in rhel-9.5, and no longer maintained in RHEL-10

{sts_libs-2.4.2 → sts_libs-2.6.0}/plans/sts-ci/ci.fmf

@@ -13,4 +13,6 @@ discover:
       - "tag: -hw-memory"
       - "tag: -hw-disk"
       - "tag: -hw-cpu"
+      - "tag: -fcoe"
+      - "tag: -san"
       - "tier: 1"

{sts_libs-2.4.2 → sts_libs-2.6.0}/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.2"
+version = "2.6.0"
 authors = [
   {name = 'Martin Hoyer', email = 'mhoyer@redhat.com'},
   {name = 'Filip Suba', email = 'fsuba@redhat.com'},

sts_libs-2.6.0/sts_libs/src/sts/fcoe.py

@@ -0,0 +1,404 @@
+# Copyright: Contributors to the sts project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""FCoE (Fibre Channel over Ethernet) instance management.
+
+Supports both software FCoE (via fcoeadm/fipvlan) and hardware FCoE
+offload (qedf, bnx2fc) where FC hosts appear directly via the driver.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import secrets
+import shutil
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar
+
+from sts.fc import FcDevice
+from sts.models import StsBaseModel
+from sts.utils.cmdline import run
+from sts.utils.errors import DeviceError
+
+if TYPE_CHECKING:
+    from typing import Self
+
+    from sts.utils.cmdline import CommandResult
+
+logger = logging.getLogger(__name__)
+
+
+class FcoeError(DeviceError):
+    """FCoE subsystem error."""
+
+
+FC_HOST_PATH = Path('/sys/class/fc_host')
+FCOE_CONFIG_DIR = Path('/etc/fcoe')
+FCOE_SYSCONFIG = Path('/etc/sysconfig/fcoe')
+
+
+class FcoeInstance(StsBaseModel):
+    """Active FCoE instance tying an ethernet NIC to an FC host.
+
+    Attributes:
+        interface: Underlying ethernet interface name (e.g. 'eth0')
+        fcoe_interface: FCoE VLAN interface name (e.g. 'eth0.200-fcoe')
+        host_id: FC host number (e.g. '7')
+        wwnn: World Wide Node Name
+        wwpn: World Wide Port Name
+        driver: FCoE driver name (e.g. 'bnx2fc', 'qedf')
+    """
+
+    interface: str
+    fcoe_interface: str | None = None
+    host_id: str | None = None
+    wwnn: str | None = None
+    wwpn: str | None = None
+    driver: str | None = None
+
+    HOST_PATH: ClassVar[Path] = FC_HOST_PATH
+
+    def discover(self) -> Self:
+        """Populate instance fields from fcoeadm -i output."""
+        for inst in get_instances():
+            if inst.interface == self.interface or inst.fcoe_interface == self.fcoe_interface:
+                self.fcoe_interface = inst.fcoe_interface
+                self.host_id = inst.host_id
+                self.wwnn = inst.wwnn
+                self.wwpn = inst.wwpn
+                self.driver = inst.driver
+                return self
+        raise FcoeError(f'FCoE instance not found for interface {self.interface}')
+
+    def destroy(self) -> CommandResult:
+        """Destroy this FCoE instance via fcoeadm -d."""
+        iface = self.fcoe_interface or self.interface
+        return run(f'fcoeadm -d {iface}')
+
+    def get_fc_host_attr(self, attr: str) -> str | None:
+        """Read an fc_host sysfs attribute.
+
+        Args:
+            attr: Attribute name under /sys/class/fc_host/hostN/
+        """
+        if not self.host_id:
+            return None
+        result = run(f'cat {self.HOST_PATH}/host{self.host_id}/{attr}')
+        if result.failed:
+            return None
+        return result.stdout.strip()
+
+    def get_statistics(self, stat: str) -> str | None:
+        """Read an fc_host statistics sysfs attribute.
+
+        Args:
+            stat: Statistic name under /sys/class/fc_host/hostN/statistics/
+        """
+        if not self.host_id:
+            return None
+        result = run(f'cat {self.HOST_PATH}/host{self.host_id}/statistics/{stat}')
+        if result.failed:
+            return None
+        return result.stdout.strip()
+
+    def create_vport(self, wwnn: str, wwpn: str) -> bool:
+        """Create an NPIV virtual port via sysfs."""
+        if not self.host_id:
+            return False
+        compact_wwpn = wwpn.replace(':', '')
+        compact_wwnn = wwnn.replace(':', '')
+        result = run(f'echo {compact_wwpn}:{compact_wwnn} > {self.HOST_PATH}/host{self.host_id}/vport_create')
+        return result.succeeded
+
+    def delete_vport(self, wwnn: str, wwpn: str) -> bool:
+        """Delete an NPIV virtual port via sysfs."""
+        if not self.host_id:
+            return False
+        compact_wwpn = wwpn.replace(':', '')
+        compact_wwnn = wwnn.replace(':', '')
+        result = run(f'echo {compact_wwpn}:{compact_wwnn} > {self.HOST_PATH}/host{self.host_id}/vport_delete')
+        return result.succeeded
+
+
+def _build_instance(data: dict[str, str | None]) -> FcoeInstance:
+    """Build FcoeInstance from parsed fcoeadm data."""
+    fcoe_iface = data.get('fcoe_interface', '')
+    if not fcoe_iface:
+        raise FcoeError('Cannot build FcoeInstance: missing fcoe_interface')
+    base_iface = re.split(r'[.]', fcoe_iface)[0]
+    return FcoeInstance(
+        interface=base_iface,
+        fcoe_interface=fcoe_iface,
+        host_id=data.get('host_id'),
+        wwpn=data.get('wwpn'),
+        wwnn=data.get('wwnn'),
+        driver=data.get('driver'),
+    )
+
+
+def _parse_fcoeadm_instances(output: str) -> list[FcoeInstance]:
+    """Parse fcoeadm -i output into FcoeInstance objects."""
+    instances: list[FcoeInstance] = []
+    current: dict[str, str | None] = {}
+
+    for raw_line in output.splitlines():
+        stripped = raw_line.strip()
+        if stripped.startswith('Description:'):
+            if current.get('fcoe_interface'):
+                instances.append(_build_instance(current))
+            current = {}
+        if stripped.startswith('Interface:'):
+            current['fcoe_interface'] = stripped.split(':', 1)[1].strip()
+        elif stripped.startswith('Symbolic Name:'):
+            sym_name = stripped.split(':', 1)[1].strip()
+            if 'over ' in sym_name and not current.get('fcoe_interface'):
+                current['fcoe_interface'] = sym_name.split('over ', 1)[1].strip()
+            for drv in ('bnx2fc', 'qedf', 'fnic'):
+                if drv in sym_name:
+                    current['driver'] = drv
+                    break
+        elif stripped.startswith('OS Device Name:'):
+            host = stripped.split(':', 1)[1].strip()
+            current['host_id'] = host.removeprefix('host')
+        elif stripped.startswith('Port Name:'):
+            current['wwpn'] = stripped.split(':', 1)[1].strip()
+        elif stripped.startswith('Node Name:'):
+            current['wwnn'] = stripped.split(':', 1)[1].strip()
+
+    if current.get('fcoe_interface'):
+        instances.append(_build_instance(current))
+
+    return instances
+
+
+def get_instances() -> list[FcoeInstance]:
+    """Get all active FCoE instances from fcoeadm -i."""
+    result = run('fcoeadm -i')
+    if result.failed or 'No FCoE' in result.stdout:
+        return []
+    return _parse_fcoeadm_instances(result.stdout)
+
+
+def _parse_fcoeadm_targets(output: str) -> list[dict[str, str]]:
+    """Parse fcoeadm -t output into list of target dicts."""
+    targets: list[dict[str, str]] = []
+    current: dict[str, str] = {}
+
+    for raw_line in output.splitlines():
+        stripped = raw_line.strip()
+        if stripped.startswith('Interface:'):
+            if current:
+                targets.append(current)
+            current = {'interface': stripped.split(':', 1)[1].strip()}
+        elif stripped.startswith('Node Name:'):
+            current['node_name'] = stripped.split(':', 1)[1].strip()
+        elif stripped.startswith('Port Name:'):
+            current['port_name'] = stripped.split(':', 1)[1].strip()
+        elif stripped.startswith('Roles:'):
+            current['roles'] = stripped.split(':', 1)[1].strip()
+
+    if current:
+        targets.append(current)
+    return targets
+
+
+def get_targets() -> list[dict[str, str]]:
+    """Get all FCoE targets from fcoeadm -t."""
+    result = run('fcoeadm -t')
+    if result.failed or 'No FCoE' in result.stdout:
+        return []
+    return _parse_fcoeadm_targets(result.stdout)
+
+
+def create_instance(interface: str) -> FcoeInstance:
+    """Create an FCoE instance on the given ethernet interface.
+
+    Args:
+        interface: Ethernet interface name (e.g. 'eth3')
+    """
+    result = run(f'fcoeadm -c {interface}')
+    if result.failed:
+        raise FcoeError(f'Failed to create FCoE instance on {interface}: {result.stderr}')
+
+    deadline = time.monotonic() + 30
+    while time.monotonic() < deadline:
+        for inst in get_instances():
+            if interface in (inst.interface, inst.fcoe_interface):
+                return inst
+        time.sleep(1)
+    raise FcoeError(f'FCoE instance on {interface} not found after creation (30s timeout)')
+
+
+def wait_fcoe_interface(interface: str, timeout: int = 30) -> bool:
+    """Poll until an FCoE interface appears in fcoeadm -i output.
+
+    Args:
+        interface: Interface name to wait for
+        timeout: Maximum wait time in seconds
+    """
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        for inst in get_instances():
+            if interface in (inst.interface, inst.fcoe_interface):
+                return True
+        time.sleep(1)
+    return False
+
+
+def generate_vport_wwn() -> tuple[str, str]:
+    """Generate a random WWNN:WWPN pair for NPIV vport creation."""
+
+    def _random_wwn(prefix: int) -> str:
+        octets = [prefix] + [secrets.randbelow(256) for _ in range(7)]
+        return ':'.join(f'{b:02x}' for b in octets)
+
+    return _random_wwn(0x20), _random_wwn(0x10)
+
+
+def get_fcoe_config_path(interface: str) -> Path:
+    """Get the FCoE config file path for an interface."""
+    return FCOE_CONFIG_DIR / f'cfg-{interface}'
+
+
+def write_fcoe_config(interface: str, **options: str) -> None:
+    """Write FCoE config file for an interface.
+
+    Args:
+        interface: FCoE interface name
+        **options: Config key=value pairs (e.g. FCOE_ENABLE='yes')
+    """
+    config_path = get_fcoe_config_path(interface)
+    with config_path.open('w') as f:
+        f.writelines(f'{key}={value}\n' for key, value in options.items())
+
+
+def get_fcoemon_opts() -> str:
+    """Read FCOEMON_OPTS from /etc/sysconfig/fcoe."""
+    with FCOE_SYSCONFIG.open() as f:
+        for line in f:
+            if line.startswith('FCOEMON_OPTS='):
+                return line.split('=', 1)[1].strip().strip('"')
+    return ''
+
+
+def set_fcoemon_opts(opts: str) -> None:
+    """Write FCOEMON_OPTS to /etc/sysconfig/fcoe."""
+    with FCOE_SYSCONFIG.open() as f:
+        lines = f.readlines()
+    replaced = False
+    with FCOE_SYSCONFIG.open('w') as f:
+        for line in lines:
+            if line.startswith('FCOEMON_OPTS='):
+                f.write(f'FCOEMON_OPTS="{opts}"\n')
+                replaced = True
+            else:
+                f.write(line)
+        if not replaced:
+            f.write(f'FCOEMON_OPTS="{opts}"\n')
+
+
+FCOE_DRIVERS: set[str] = {'bnx2fc', 'qedf', 'fnic'}
+
+
+def discover_fcoe_hosts() -> list[FcoeInstance]:
+    """Discover FCoE hosts from sysfs, supporting both hw and sw FCoE.
+
+    For hw-FCoE (qedf, bnx2fc offload), FC hosts exist without fcoeadm.
+    For sw-FCoE, fcoeadm -i is used to find instances.
+    """
+    instances: list[FcoeInstance] = []
+    seen_hosts: set[str] = set()
+
+    for inst in get_instances():
+        if inst.host_id:
+            seen_hosts.add(inst.host_id)
+        instances.append(inst)
+
+    for host_id in FcDevice.get_hosts():
+        if host_id in seen_hosts:
+            continue
+        transport = FcDevice.get_host_transport_type(host_id)
+        if transport != 'FCoE':
+            continue
+
+        wwpn_result = run(f'cat {FC_HOST_PATH}/host{host_id}/port_name')
+        wwpn = FcDevice.standardize_wwn(wwpn_result.stdout.strip()) if wwpn_result.succeeded else None
+        wwnn_result = run(f'cat {FC_HOST_PATH}/host{host_id}/node_name')
+        wwnn = FcDevice.standardize_wwn(wwnn_result.stdout.strip()) if wwnn_result.succeeded else None
+        driver_result = run(f'cat {FC_HOST_PATH}/host{host_id}/driver_name')
+        if driver_result.succeeded:
+            driver = driver_result.stdout.strip()
+        else:
+            lsscsi_result = run(f'lsscsi -H {host_id}')
+            parts = lsscsi_result.stdout.split() if lsscsi_result.succeeded else []
+            driver = parts[1] if len(parts) > 1 else None
+
+        instances.append(
+            FcoeInstance(
+                interface=f'host{host_id}',
+                host_id=host_id,
+                wwpn=wwpn,
+                wwnn=wwnn,
+                driver=driver,
+            )
+        )
+
+    return instances
+
+
+def setup_fcoe() -> list[FcoeInstance]:
+    """Set up FCoE and discover instances (hw-offload or software).
+
+    Loads bnx2fc module (sw-FCoE driver), starts lldpad and fcoe services,
+    runs fipvlan for VLAN discovery. Falls back to discovering hardware
+    FCoE hosts from sysfs if no sw-FCoE instances are found.
+    """
+    run('modprobe bnx2fc')
+    run('systemctl start lldpad')
+    run('systemctl start fcoe')
+    run('fipvlan -a -c -s')
+
+    deadline = time.monotonic() + 30
+    instances: list[FcoeInstance] = []
+    while time.monotonic() < deadline:
+        instances = discover_fcoe_hosts()
+        if instances:
+            break
+        time.sleep(2)
+    if not instances:
+        raise FcoeError('No FCoE instances discovered (hw or sw)')
+
+    for inst in instances:
+        if inst.fcoe_interface:
+            config_path = get_fcoe_config_path(inst.interface)
+            if not config_path.exists():
+                cfg_template = FCOE_CONFIG_DIR / 'cfg-ethx'
+                if cfg_template.exists():
+                    shutil.copy2(cfg_template, config_path)
+
+    hw_count = sum(1 for i in instances if not i.fcoe_interface)
+    sw_count = sum(1 for i in instances if i.fcoe_interface)
+    logger.info(f'FCoE setup complete: {hw_count} hw-offload, {sw_count} software instance(s)')
+    return instances
+
+
+def setup_soft_fcoe() -> list[FcoeInstance]:
+    """Set up FCoE (kept for backward compatibility)."""
+    return setup_fcoe()
+
+
+def teardown_soft_fcoe() -> None:
+    """Tear down software FCoE instances (hw-offload hosts are left alone)."""
+    for inst in get_instances():
+        inst.destroy()
+
+    run('systemctl stop fcoe')
+    run('systemctl stop lldpad')
+
+    for cfg in FCOE_CONFIG_DIR.glob('cfg-*'):
+        if cfg.name != 'cfg-ethx':
+            cfg.unlink(missing_ok=True)
+
+    logger.info('Soft FCoE teardown complete')

sts_libs-2.6.0/sts_libs/src/sts/fixtures/fcoe_fixtures.py

@@ -0,0 +1,91 @@
+# Copyright: Contributors to the sts project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# pyright: reportUnusedFunction=false
+
+"""FCoE test fixtures."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+import pytest
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+from sts.fcoe import (
+    FcoeError,
+    FcoeInstance,
+    generate_vport_wwn,
+    setup_fcoe,
+    teardown_soft_fcoe,
+)
+from sts.multipath import MultipathDevice
+from sts.scsi import ScsiDevice
+from sts.utils.packages import ensure_installed
+
+logger = logging.getLogger(__name__)
+
+FCOE_PACKAGES = ('fcoe-utils', 'lldpad')
+
+
+@pytest.fixture(scope='class')
+def soft_fcoe_setup() -> Generator[list[FcoeInstance]]:
+    """Discover FCoE instances (hw-offload or software), yield, teardown sw instances on exit.
+
+    Skips if no FCoE instances are discovered.
+    """
+    ensure_installed(*FCOE_PACKAGES)
+    try:
+        instances = setup_fcoe()
+    except (FcoeError, OSError) as exc:
+        pytest.skip(f'FCoE setup failed: {exc}')
+    yield instances
+    teardown_soft_fcoe()
+
+
+@pytest.fixture(scope='class')
+def fcoe_instance(soft_fcoe_setup: list[FcoeInstance]) -> FcoeInstance:
+    """First available FCoE instance, skip if none."""
+    if not soft_fcoe_setup:
+        pytest.skip('No FCoE instances available')
+    return soft_fcoe_setup[0]
+
+
+@pytest.fixture(scope='class')
+def fcoe_instances(soft_fcoe_setup: list[FcoeInstance]) -> list[FcoeInstance]:
+    """All discovered FCoE instances."""
+    return soft_fcoe_setup
+
+
+@pytest.fixture
+def fcoe_vport(fcoe_instance: FcoeInstance) -> Generator[tuple[str, str]]:
+    """Create an NPIV vport, yield (wwnn, wwpn), delete on exit."""
+    wwnn, wwpn = generate_vport_wwn()
+    created = fcoe_instance.create_vport(wwnn, wwpn)
+    if not created:
+        pytest.skip('Failed to create NPIV vport')
+    yield wwnn, wwpn
+    fcoe_instance.delete_vport(wwnn, wwpn)
+
+
+@pytest.fixture(scope='class')
+def fcoe_multipath_device(soft_fcoe_setup: list[FcoeInstance]) -> MultipathDevice:
+    """Multipath device backed by FCoE paths, skip if none found."""
+    fcoe_host_ids = {inst.host_id for inst in soft_fcoe_setup if inst.host_id}
+    if not fcoe_host_ids:
+        pytest.skip('No FCoE hosts available')
+
+    all_scsi = ScsiDevice.get_all_scsi_devices()
+    fcoe_dev_names = {d.name for d in all_scsi if d.host_id in fcoe_host_ids and d.name}
+    if not fcoe_dev_names:
+        pytest.skip('No SCSI devices found on FCoE hosts')
+
+    for mpath in MultipathDevice.get_all():
+        path_names = {p.get('dev') for p in mpath.paths if p.get('dev')}
+        if path_names & fcoe_dev_names:
+            return mpath
+
+    pytest.skip('No multipath device found with FCoE paths')

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

@@ -68,36 +68,20 @@ def iscsi_localhost_test(request: pytest.FixtureRequest, _iscsi_test: None) -> G
 
 
 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
+    """Return ready SCSI disks belonging to an active target session."""
+    return [path for session in IscsiSession.get_by_target(target_iqn) for path in session.get_ready_disk_paths()]
 
 
 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)
+    return len(_get_target_device_paths(target_iqn)) == expected_count
 
 
 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}'
+        assert paths, f'No ready devices found for iSCSI target {target_iqn}'
         return paths
 
     def _extract_paths(devices: Sequence[StorageDevice]) -> list[Path]:
@@ -151,12 +135,13 @@ def iscsi_target(request: pytest.FixtureRequest, iscsi_localhost_test: None) ->
             IscsiLUN(target_wwn=target_iqn).create_lun(storage_object=backstore.path)
             backstores.append((backstore_name, backing_file))
 
-    node = setup_and_login(
-        portal='127.0.0.1:3260',
-        initiator_iqn=initiator_iqn,
-        target_iqn=target_iqn,
-    )
+    node: IscsiNode | None = None
     try:
+        node = setup_and_login(
+            portal='127.0.0.1:3260',
+            initiator_iqn=initiator_iqn,
+            target_iqn=target_iqn,
+        )
         assert wait_for(
             lambda: _target_devices_ready(target_iqn, n_luns),
             timeout=ISCSI_DEVICE_SETTLE_TIMEOUT,
@@ -164,7 +149,8 @@ def iscsi_target(request: pytest.FixtureRequest, iscsi_localhost_test: None) ->
         ), f'Timed out waiting for {n_luns} usable device(s) from iSCSI target {target_iqn}'
         yield node
     finally:
-        node.logout()
+        if node is not None:
+            node.logout()
         Iscsi(target_wwn=target_iqn).delete_target()
         for backstore_name, backing_file in reversed(backstores):
             result = BackstoreFileio(name=backstore_name).delete_backstore()

{sts_libs-2.4.2 → sts_libs-2.6.0}/sts_libs/src/sts/iscsi/__init__.py

@@ -12,6 +12,7 @@ import logging
 from typing import TYPE_CHECKING
 
 from sts.iscsi.config import ISCSID_SERVICE_NAME, IscsiInterface, set_initiatorname
+from sts.iscsi.errors import IscsiError
 from sts.iscsi.iscsiadm import IscsiAdm
 from sts.iscsi.node import IscsiNode
 from sts.utils.system import SystemManager
@@ -42,8 +43,7 @@ def setup_and_login(
 ) -> IscsiNode:
     """Set initiator name, discover target (if needed), and log in."""
     if not set_initiatorname(initiator_iqn):
-        logger.error('Failed to set initiator name')
-        return IscsiNode(target_iqn='', portal=portal, iface=iface)
+        raise IscsiError(f'Failed to set initiator name {initiator_iqn}')
 
     iscsiadm = IscsiAdm()
     node = IscsiNode(

{sts_libs-2.4.2 → sts_libs-2.6.0}/sts_libs/src/sts/iscsi/config.py

@@ -46,10 +46,17 @@ def wait_for_iscsid() -> bool:
 
 
 def set_initiatorname(name: str) -> bool:
-    """Write initiator name to /etc/iscsi/initiatorname.iscsi and restart iscsid."""
+    """Configure the initiator name and ensure iscsid is running with it."""
     system = SystemManager()
+    path = Path('/etc/iscsi/initiatorname.iscsi')
+    content = f'InitiatorName={name}\n'
     try:
-        Path('/etc/iscsi/initiatorname.iscsi').write_text(f'InitiatorName={name}\n')
+        is_current = path.exists() and path.read_text() == content
+        if is_current and system.is_service_running(ISCSID_SERVICE_NAME) and wait_for_iscsid():
+            return True
+
+        if not is_current:
+            path.write_text(content)
         if not system.service_restart(ISCSID_SERVICE_NAME):
             logger.error('Failed to restart iscsid')
             return False

sts_libs-2.6.0/sts_libs/src/sts/iscsi/errors.py

@@ -0,0 +1,12 @@
+# Copyright: Contributors to the sts project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""iSCSI-related errors."""
+
+from __future__ import annotations
+
+from sts.utils.errors import STSError
+
+
+class IscsiError(STSError):
+    """Base class for iSCSI-related errors."""