patches/openstack/cinder/sep-sp-iscsi.patch

From 2acfdddf0794754aa0e32a56800e77387f75ce38 Mon Sep 17 00:00:00 2001
From: Peter Penchev <openstack-dev@storpool.com>
Date: Mon, 12 Mar 2018 12:00:10 +0200
Subject: [PATCH] Add iSCSI export support to the StorPool driver

Add four new driver options:
- storpool_iscsi_cinder_volume: use StorPool iSCSI attachments whenever
  the cinder-volume service needs to attach a volume to the controller,
  e.g. for copying an image to a volume or vice versa
- storpool_iscsi_export_to:
  - an empty string to use the StorPool native protocol for exporting
    volumes
  - the string "*" to always use iSCSI for exporting volumes
  - an experimental, not fully supported list of IQN patterns to export
    volumes to using iSCSI; this results in a Cinder driver that exports
    different volumes using different storage protocols
- storpool_iscsi_portal_group: the name of the iSCSI portal group
  defined in the StorPool configuration to use for these export
- storpool_iscsi_learn_initiator_iqns: automatically create StorPool
  configuration records for an initiator when a volume is first exported
  to it

When exporting volumes via iSCSI, report the storage protocol as
"iSCSI".

Change-Id: I9de64306e0e6976268df782053b0651dd1cca96f
---
 .../unit/volume/drivers/test_storpool.py      | 521 +++++++++++++++++-
 cinder/volume/drivers/storpool.py             | 379 ++++++++++++-
 .../drivers/storpool-volume-driver.rst        |  68 ++-
 .../storpool-iscsi-cefcfe590a07c5c7.yaml      |  15 +
 4 files changed, 972 insertions(+), 11 deletions(-)
 create mode 100644 releasenotes/notes/storpool-iscsi-cefcfe590a07c5c7.yaml

diff --git a/cinder/tests/unit/volume/drivers/test_storpool.py b/cinder/tests/unit/volume/drivers/test_storpool.py
index 44707d0b8..d6347e1d5 100644
--- a/cinder/tests/unit/volume/drivers/test_storpool.py
+++ b/cinder/tests/unit/volume/drivers/test_storpool.py
@@ -14,14 +14,24 @@
 #    under the License.
 
 
+from __future__ import annotations
+
+import dataclasses
 import itertools
 import re
 import sys
+from typing import Any, NamedTuple, TYPE_CHECKING  # noqa: H301
 from unittest import mock
 
 import ddt
 from oslo_utils import units
 
+if TYPE_CHECKING:
+    if sys.version_info >= (3, 11):
+        from typing import Self
+    else:
+        from typing_extensions import Self
+
 
 fakeStorPool = mock.Mock()
 fakeStorPool.spopenstack = mock.Mock()
@@ -31,6 +41,7 @@ fakeStorPool.sptypes = mock.Mock()
 sys.modules['storpool'] = fakeStorPool
 
 
+from cinder.common import constants
 from cinder import exception
 from cinder.tests.unit import fake_constants
 from cinder.tests.unit import test
@@ -38,6 +49,13 @@ from cinder.volume import configuration as conf
 from cinder.volume.drivers import storpool as driver
 
 
+_ISCSI_IQN_OURS = 'beleriand'
+_ISCSI_IQN_OTHER = 'rohan'
+_ISCSI_IQN_THIRD = 'gondor'
+_ISCSI_PAT_OTHER = 'roh*'
+_ISCSI_PAT_BOTH = '*riand roh*'
+_ISCSI_PORTAL_GROUP = 'openstack_pg'
+
 volume_types = {
     fake_constants.VOLUME_TYPE_ID: {},
     fake_constants.VOLUME_TYPE2_ID: {'storpool_template': 'ssd'},
@@ -71,6 +89,10 @@ def snapshotName(vtype, vid):
     return 'os--snap--{t}--{id}'.format(t=vtype, id=vid)
 
 
+def targetName(vid):
+    return 'iqn.2012-11.storpool:{id}'.format(id=vid)
+
+
 class MockDisk(object):
     def __init__(self, diskId):
         self.id = diskId
@@ -195,6 +217,315 @@ def MockVolumeUpdateDesc(size):
     return {'size': size}
 
 
+@dataclasses.dataclass(frozen=True)
+class MockIscsiNetwork:
+    """Mock a StorPool IP CIDR network definition (partially)."""
+
+    address: str
+
+
+@dataclasses.dataclass(frozen=True)
+class MockIscsiPortalGroup:
+    """Mock a StorPool iSCSI portal group definition (partially)."""
+
+    name: str
+    networks: list[MockIscsiNetwork]
+
+
+@dataclasses.dataclass(frozen=True)
+class MockIscsiExport:
+    """Mock a StorPool iSCSI exported volume/target definition."""
+
+    portalGroup: str
+    target: str
+
+
+@dataclasses.dataclass(frozen=True)
+class MockIscsiInitiator:
+    """Mock a StorPool iSCSI initiator definition."""
+
+    name: str
+    exports: list[MockIscsiExport]
+
+
+@dataclasses.dataclass(frozen=True)
+class MockIscsiTarget:
+    """Mock a StorPool iSCSI volume-to-target mapping definition."""
+
+    name: str
+    volume: str
+
+
+class IscsiTestCase(NamedTuple):
+    """A single test case for the iSCSI config and export methods."""
+
+    initiator: str | None
+    volume: str | None
+    exported: bool
+    commands_count: int
+
+
+@dataclasses.dataclass(frozen=True)
+class MockIscsiConfig:
+    """Mock the structure returned by the "get current config" query."""
+
+    portalGroups: dict[str, MockIscsiPortalGroup]
+    initiators: dict[str, MockIscsiInitiator]
+    targets: dict[str, MockIscsiTarget]
+
+    @classmethod
+    def build(cls, tcase: IscsiTestCase) -> Self:
+        """Build a test config structure."""
+        initiators = {
+            '0': MockIscsiInitiator(name=_ISCSI_IQN_OTHER, exports=[]),
+        }
+        if tcase.initiator is not None:
+            initiators['1'] = MockIscsiInitiator(
+                name=tcase.initiator,
+                exports=(
+                    [
+                        MockIscsiExport(
+                            portalGroup=_ISCSI_PORTAL_GROUP,
+                            target=targetName(tcase.volume),
+                        ),
+                    ]
+                    if tcase.exported
+                    else []
+                ),
+            )
+
+        targets = {
+            '0': MockIscsiTarget(
+                name=targetName(fake_constants.VOLUME2_ID),
+                volume=volumeName(fake_constants.VOLUME2_ID),
+            ),
+        }
+        if tcase.volume is not None:
+            targets['1'] = MockIscsiTarget(
+                name=targetName(tcase.volume),
+                volume=volumeName(tcase.volume),
+            )
+
+        return cls(
+            portalGroups={
+                '0': MockIscsiPortalGroup(
+                    name=_ISCSI_PORTAL_GROUP + '-not',
+                    networks=[],
+                ),
+                '1': MockIscsiPortalGroup(
+                    name=_ISCSI_PORTAL_GROUP,
+                    networks=[
+                        MockIscsiNetwork(address="192.0.2.0"),
+                        MockIscsiNetwork(address="195.51.100.0"),
+                    ],
+                ),
+            },
+            initiators=initiators,
+            targets=targets,
+        )
+
+
+@dataclasses.dataclass(frozen=True)
+class MockIscsiConfigTop:
+    """Mock the top level of the "get the iSCSI configuration" response."""
+
+    iscsi: MockIscsiConfig
+
+
+class MockIscsiAPI:
+    """Mock only the iSCSI-related calls of the StorPool API bindings."""
+
+    _asrt: test.TestCase
+    _configs: list[MockIscsiConfig]
+
+    def __init__(
+        self,
+        configs: list[MockIscsiConfig],
+        asrt: test.TestCase,
+    ) -> None:
+        """Store the reference to the list of iSCSI config objects."""
+        self._asrt = asrt
+        self._configs = configs
+
+    def iSCSIConfig(self) -> MockIscsiConfigTop:
+        """Return the last version of the iSCSI configuration."""
+        return MockIscsiConfigTop(iscsi=self._configs[-1])
+
+    def _handle_export(
+        self,
+        cfg: MockIscsiConfig, cmd: dict[str, Any],
+    ) -> MockIscsiConfig:
+        """Add an export for an initiator."""
+        self._asrt.assertDictEqual(
+            cmd,
+            {
+                'initiator': _ISCSI_IQN_OURS,
+                'portalGroup': _ISCSI_PORTAL_GROUP,
+                'volumeName': volumeName(fake_constants.VOLUME_ID),
+            },
+        )
+        self._asrt.assertEqual(cfg.initiators['1'].name, cmd['initiator'])
+        self._asrt.assertListEqual(cfg.initiators['1'].exports, [])
+
+        return dataclasses.replace(
+            cfg,
+            initiators={
+                **cfg.initiators,
+                '1': dataclasses.replace(
+                    cfg.initiators['1'],
+                    exports=[
+                        MockIscsiExport(
+                            portalGroup=cmd['portalGroup'],
+                            target=targetName(fake_constants.VOLUME_ID),
+                        ),
+                    ],
+                ),
+            },
+        )
+
+    def _handle_delete_export(
+        self,
+        cfg: MockIscsiConfig,
+        cmd: dict[str, Any],
+    ) -> MockIscsiConfig:
+        """Delete an export for an initiator."""
+        self._asrt.assertDictEqual(
+            cmd,
+            {
+                'initiator': _ISCSI_IQN_OURS,
+                'portalGroup': _ISCSI_PORTAL_GROUP,
+                'volumeName': volumeName(fake_constants.VOLUME_ID),
+            },
+        )
+        self._asrt.assertEqual(cfg.initiators['1'].name, cmd['initiator'])
+        self._asrt.assertListEqual(
+            cfg.initiators['1'].exports,
+            [MockIscsiExport(portalGroup=_ISCSI_PORTAL_GROUP,
+                             target=cfg.targets['1'].name)])
+
+        updated_initiators = cfg.initiators
+        del updated_initiators['1']
+        return dataclasses.replace(cfg, initiators=updated_initiators)
+
+    def _handle_create_initiator(
+        self,
+        cfg: MockIscsiConfig,
+        cmd: dict[str, Any],
+    ) -> MockIscsiConfig:
+        """Add a whole new initiator."""
+        self._asrt.assertDictEqual(
+            cmd,
+            {
+                'name': _ISCSI_IQN_OURS,
+                'username': '',
+                'secret': '',
+            },
+        )
+        self._asrt.assertNotIn(
+            cmd['name'],
+            [init.name for init in cfg.initiators.values()],
+        )
+        self._asrt.assertListEqual(sorted(cfg.initiators), ['0'])
+
+        return dataclasses.replace(
+            cfg,
+            initiators={
+                **cfg.initiators,
+                '1': MockIscsiInitiator(name=cmd['name'], exports=[]),
+            },
+        )
+
+    def _handle_create_target(
+        self,
+        cfg: MockIscsiConfig,
+        cmd: dict[str, Any],
+    ) -> MockIscsiConfig:
+        """Add a target for a volume so that it may be exported."""
+        self._asrt.assertDictEqual(
+            cmd,
+            {'volumeName': volumeName(fake_constants.VOLUME_ID)},
+        )
+        self._asrt.assertListEqual(sorted(cfg.targets), ['0'])
+        return dataclasses.replace(
+            cfg,
+            targets={
+                **cfg.targets,
+                '1': MockIscsiTarget(
+                    name=targetName(fake_constants.VOLUME_ID),
+                    volume=volumeName(fake_constants.VOLUME_ID),
+                ),
+            },
+        )
+
+    def _handle_delete_target(
+        self,
+        cfg: MockIscsiConfig,
+        cmd: dict[str, Any]
+    ) -> MockIscsiConfig:
+        """Remove a target for a volume."""
+        self._asrt.assertDictEqual(
+            cmd,
+            {'volumeName': volumeName(fake_constants.VOLUME_ID)},
+        )
+
+        self._asrt.assertListEqual(sorted(cfg.targets), ['0', '1'])
+        updated_targets = cfg.targets
+        del updated_targets['1']
+        return dataclasses.replace(cfg, targets=updated_targets)
+
+    def _handle_initiator_add_network(
+        self,
+        cfg: MockIscsiConfig,
+        cmd: dict[str, Any],
+    ) -> MockIscsiConfig:
+        """Add a network that an initiator is allowed to log in from."""
+        self._asrt.assertDictEqual(
+            cmd,
+            {
+                'initiator': _ISCSI_IQN_OURS,
+                'net': '0.0.0.0/0',
+            },
+        )
+        return dataclasses.replace(cfg)
+
+    _CMD_HANDLERS = {
+        'createInitiator': _handle_create_initiator,
+        'createTarget': _handle_create_target,
+        'deleteTarget': _handle_delete_target,
+        'export': _handle_export,
+        'exportDelete': _handle_delete_export,
+        'initiatorAddNetwork': _handle_initiator_add_network,
+    }
+
+    def iSCSIConfigChange(
+        self,
+        commands: dict[str, list[dict[str, dict[str, Any]]]],
+    ) -> None:
+        """Apply the requested changes to the iSCSI configuration.
+
+        This method adds a new config object to the configs list,
+        making a shallow copy of the last one and applying the changes
+        specified in the list of commands.
+        """
+        self._asrt.assertListEqual(sorted(commands), ['commands'])
+        self._asrt.assertGreater(len(commands['commands']), 0)
+        for cmd in commands['commands']:
+            keys = sorted(cmd.keys())
+            cmd_name = keys[0]
+            self._asrt.assertListEqual(keys, [cmd_name])
+            handler = self._CMD_HANDLERS[cmd_name]
+            new_cfg = handler(self, self._configs[-1], cmd[cmd_name])
+            self._configs.append(new_cfg)
+
+
+_ISCSI_TEST_CASES = [
+    IscsiTestCase(None, None, False, 4),
+    IscsiTestCase(_ISCSI_IQN_OURS, None, False, 2),
+    IscsiTestCase(_ISCSI_IQN_OURS, fake_constants.VOLUME_ID, False, 1),
+    IscsiTestCase(_ISCSI_IQN_OURS, fake_constants.VOLUME_ID, True, 0),
+]
+
+
 def MockSPConfig(section = 's01'):
     res = {}
     m = re.match('^s0*([A-Za-z0-9]+)$', section)
@@ -237,7 +568,15 @@ class StorPoolTestCase(test.TestCase):
         self.cfg.volume_backend_name = 'storpool_test'
         self.cfg.storpool_template = None
         self.cfg.storpool_replication = 3
+        self.cfg.storpool_iscsi_cinder_volume = False
+        self.cfg.storpool_iscsi_export_to = ''
+        self.cfg.storpool_iscsi_learn_initiator_iqns = True
+        self.cfg.storpool_iscsi_portal_group = _ISCSI_PORTAL_GROUP
 
+        self._setup_test_driver()
+
+    def _setup_test_driver(self):
+        """Initialize a StorPool driver as per the current configuration."""
         mock_exec = mock.Mock()
         mock_exec.return_value = ('', '')
 
@@ -246,7 +585,7 @@ class StorPoolTestCase(test.TestCase):
         self.driver.check_for_setup_error()
 
     @ddt.data(
-        (5, TypeError),
+        (5, (TypeError, AttributeError)),
         ({'no-host': None}, KeyError),
         ({'host': 'sbad'}, driver.StorPoolConfigurationInvalid),
         ({'host': 's01'}, None),
@@ -262,7 +601,7 @@ class StorPoolTestCase(test.TestCase):
                               conn)
 
     @ddt.data(
-        (5, TypeError),
+        (5, (TypeError, AttributeError)),
         ({'no-host': None}, KeyError),
         ({'host': 'sbad'}, driver.StorPoolConfigurationInvalid),
     )
@@ -301,7 +640,7 @@ class StorPoolTestCase(test.TestCase):
             self.assertEqual(21, pool['total_capacity_gb'])
             self.assertEqual(5, int(pool['free_capacity_gb']))
 
-            self.assertTrue(pool['multiattach'])
+            self.assertFalse(pool['multiattach'])
             self.assertFalse(pool['QoS_support'])
             self.assertFalse(pool['thick_provisioning_support'])
             self.assertTrue(pool['thin_provisioning_support'])
@@ -720,3 +1059,179 @@ class StorPoolTestCase(test.TestCase):
                                'No such volume',
                                self.driver.revert_to_snapshot, None,
                                {'id': vol_id}, {'id': snap_id})
+
+    @ddt.data(
+        # The default values
+        ('', False, constants.STORPOOL, _ISCSI_IQN_OURS, False),
+
+        # Export to all
+        ('*', True, constants.ISCSI, _ISCSI_IQN_OURS, True),
+        ('*', True, constants.ISCSI, _ISCSI_IQN_OURS, True),
+
+        # Only export to the controller
+        ('', False, constants.STORPOOL, _ISCSI_IQN_OURS, False),
+
+        # Some of the not-fully-supported pattern lists
+        (_ISCSI_PAT_OTHER, False, constants.STORPOOL, _ISCSI_IQN_OURS, False),
+        (_ISCSI_PAT_OTHER, False, constants.STORPOOL, _ISCSI_IQN_OTHER, True),
+        (_ISCSI_PAT_BOTH, False, constants.STORPOOL, _ISCSI_IQN_OURS, True),
+        (_ISCSI_PAT_BOTH, False, constants.STORPOOL, _ISCSI_IQN_OTHER, True),
+    )
+    @ddt.unpack
+    def test_wants_iscsi(self, storpool_iscsi_export_to, use_iscsi,
+                         storage_protocol, hostname, expected):
+        """Check the "should this export use iSCSI?" detection."""
+        self.cfg.storpool_iscsi_export_to = storpool_iscsi_export_to
+        self._setup_test_driver()
+        self.assertEqual(self.driver._use_iscsi, use_iscsi)
+
+        # Make sure the driver reports the correct protocol in the stats
+        self.driver._update_volume_stats()
+        self.assertEqual(self.driver._stats["vendor_name"], "StorPool")
+        self.assertEqual(self.driver._stats["storage_protocol"],
+                         storage_protocol)
+
+        def check(conn, forced, expected):
+            """Pass partially or completely valid connector info."""
+            for initiator in (None, hostname):
+                for host in (None, _ISCSI_IQN_THIRD):
+                    self.assertEqual(
+                        self.driver._connector_wants_iscsi({
+                            "host": host,
+                            "initiator": initiator,
+                            **conn,
+                        }),
+                        expected if initiator is not None and host is not None
+                        else forced)
+
+        # If storpool_iscsi_cinder_volume is set and this is the controller,
+        # then yes.
+        check({"storpool_wants_iscsi": True}, True, True)
+
+        # If storpool_iscsi_cinder_volume is not set or this is not the
+        # controller, then look at the specified expected value.
+        check({"storpool_wants_iscsi": False}, use_iscsi, expected)
+        check({}, use_iscsi, expected)
+
+    def _validate_iscsi_config(
+        self,
+        cfg: MockIscsiConfig,
+        res: dict[str, Any],
+        tcase: IscsiTestCase,
+    ) -> None:
+        """Make sure the returned structure makes sense."""
+        initiator = res['initiator']
+        cfg_initiator = cfg.initiators.get('1')
+
+        self.assertIs(res['cfg'].iscsi, cfg)
+        self.assertEqual(res['pg'].name, _ISCSI_PORTAL_GROUP)
+
+        if tcase.initiator is None:
+            self.assertIsNone(initiator)
+        else:
+            self.assertIsNotNone(initiator)
+        self.assertEqual(initiator, cfg_initiator)
+
+        if tcase.volume is None:
+            self.assertIsNone(res['target'])
+        else:
+            self.assertIsNotNone(res['target'])
+        self.assertEqual(res['target'], cfg.targets.get('1'))
+
+        if tcase.initiator is None:
+            self.assertIsNone(cfg_initiator)
+            self.assertIsNone(res['export'])
+        else:
+            self.assertIsNotNone(cfg_initiator)
+            if tcase.exported:
+                self.assertIsNotNone(res['export'])
+                self.assertEqual(res['export'], cfg_initiator.exports[0])
+            else:
+                self.assertIsNone(res['export'])
+
+    @ddt.data(*_ISCSI_TEST_CASES)
+    def test_iscsi_get_config(self, tcase: IscsiTestCase) -> None:
+        """Make sure the StorPool iSCSI configuration is parsed correctly."""
+        cfg_orig = MockIscsiConfig.build(tcase)
+        configs = [cfg_orig]
+        iapi = MockIscsiAPI(configs, self)
+        with mock.patch.object(self.driver._attach, 'api', new=lambda: iapi):
+            res = self.driver._get_iscsi_config(
+                _ISCSI_IQN_OURS,
+                fake_constants.VOLUME_ID,
+            )
+
+        self._validate_iscsi_config(cfg_orig, res, tcase)
+
+    @ddt.data(*_ISCSI_TEST_CASES)
+    def test_iscsi_create_export(self, tcase: IscsiTestCase) -> None:
+        """Make sure _create_iscsi_export() makes the right API calls."""
+        cfg_orig = MockIscsiConfig.build(tcase)
+        configs = [cfg_orig]
+        iapi = MockIscsiAPI(configs, self)
+        with mock.patch.object(self.driver._attach, 'api', new=lambda: iapi):
+            self.driver._create_iscsi_export(
+                {
+                    'id': fake_constants.VOLUME_ID,
+                    'display_name': fake_constants.VOLUME_NAME,
+                },
+                {
+                    # Yeah, okay, so we cheat a little bit here...
+                    'host': _ISCSI_IQN_OURS + '.hostname',
+                    'initiator': _ISCSI_IQN_OURS,
+                },
+            )
+
+        self.assertEqual(len(configs), tcase.commands_count + 1)
+        cfg_final = configs[-1]
+        self.assertEqual(cfg_final.initiators['1'].name, _ISCSI_IQN_OURS)
+        self.assertEqual(
+            cfg_final.initiators['1'].exports[0].target,
+            targetName(fake_constants.VOLUME_ID),
+        )
+        self.assertEqual(
+            cfg_final.targets['1'].volume,
+            volumeName(fake_constants.VOLUME_ID),
+        )
+
+    @ddt.data(*_ISCSI_TEST_CASES)
+    def test_remove_iscsi_export(self, tcase: IscsiTestCase):
+        cfg_orig = MockIscsiConfig.build(tcase)
+        configs = [cfg_orig]
+        iapi = MockIscsiAPI(configs, self)
+
+        def _target_exists(cfg: MockIscsiConfig, volume: str) -> bool:
+            for name, target in cfg.targets.items():
+                if target.volume == volumeName(volume):
+                    return True
+            return False
+
+        def _export_exists(cfg: MockIscsiConfig, volume: str) -> bool:
+            for name, initiator in cfg.initiators.items():
+                for export in initiator.exports:
+                    if export.target == targetName(volume):
+                        return True
+            return False
+
+        if tcase.exported:
+            self.assertTrue(
+                _target_exists(iapi.iSCSIConfig().iscsi, tcase.volume))
+            self.assertTrue(
+                _export_exists(iapi.iSCSIConfig().iscsi, tcase.volume))
+
+        with mock.patch.object(self.driver._attach, 'api', new=lambda: iapi):
+            self.driver._remove_iscsi_export(
+                {
+                    'id': fake_constants.VOLUME_ID,
+                    'display_name': fake_constants.VOLUME_NAME,
+                },
+                {
+                    'host': _ISCSI_IQN_OURS + '.hostname',
+                    'initiator': _ISCSI_IQN_OURS,
+                },
+            )
+
+        self.assertFalse(
+            _target_exists(iapi.iSCSIConfig().iscsi, tcase.volume))
+        self.assertFalse(
+            _export_exists(iapi.iSCSIConfig().iscsi, tcase.volume))
diff --git a/cinder/volume/drivers/storpool.py b/cinder/volume/drivers/storpool.py
index a8200a7f1..d931200f6 100644
--- a/cinder/volume/drivers/storpool.py
+++ b/cinder/volume/drivers/storpool.py
@@ -15,6 +15,7 @@
 
 """StorPool block device driver"""
 
+import fnmatch
 import platform
 
 from oslo_config import cfg
@@ -43,6 +44,32 @@ if storpool:
 
 
 storpool_opts = [
+    cfg.BoolOpt('storpool_iscsi_cinder_volume',
+                default=False,
+                help='Let the cinder-volume service use iSCSI instead of '
+                     'the StorPool block device driver for accessing '
+                     'StorPool volumes, e.g. when creating a volume from '
+                     'an image or vice versa.'),
+    cfg.StrOpt('storpool_iscsi_export_to',
+               default='',
+               help='Whether to export volumes using iSCSI. '
+                    'An empty string (the default) makes the driver export '
+                    'all volumes using the StorPool native network protocol. '
+                    'The value "*" makes the driver export all volumes using '
+                    'iSCSI (see the Cinder StorPool driver documentation for '
+                    'how this option and ``storpool_iscsi_cinder_volume`` '
+                    'interact). Any other value leads to an experimental '
+                    'not fully supported configuration and is interpreted as '
+                    'a whitespace-separated list of patterns for IQNs for '
+                    'hosts that need volumes to be exported via iSCSI, e.g. '
+                    '"iqn.1991-05.com.microsoft:\\*" for Windows hosts.'),
+    cfg.BoolOpt('storpool_iscsi_learn_initiator_iqns',
+                default=True,
+                help='Create a StorPool record for a new initiator as soon as '
+                     'Cinder asks for a volume to be exported to it.'),
+    cfg.StrOpt('storpool_iscsi_portal_group',
+               default=None,
+               help='The portal group to export volumes via iSCSI in.'),
     cfg.StrOpt('storpool_template',
                default=None,
                help='The StorPool template for volumes with no type.'),
@@ -93,9 +120,10 @@ class StorPoolDriver(driver.VolumeDriver):
                   add ignore_errors to the internal _detach_volume() method
         1.2.3   - Advertise some more driver capabilities.
         2.0.0   - Implement revert_to_snapshot().
+        2.1.0   - Add iSCSI export support.
     """
 
-    VERSION = '2.0.0'
+    VERSION = '2.1.0'
     CI_WIKI_NAME = 'StorPool_distributed_storage_CI'
 
     def __init__(self, *args, **kwargs):
@@ -105,6 +133,7 @@ class StorPoolDriver(driver.VolumeDriver):
         self._ourId = None
         self._ourIdInt = None
         self._attach = None
+        self._use_iscsi = False
 
     @staticmethod
     def get_driver_options():
@@ -159,10 +188,327 @@ class StorPoolDriver(driver.VolumeDriver):
             raise StorPoolConfigurationInvalid(
                 section=hostname, param='SP_OURID', error=e)
 
+    def _connector_wants_iscsi(self, connector):
+        """Should we do this export via iSCSI?
+
+        Check the configuration to determine whether this connector is
+        expected to provide iSCSI exports as opposed to native StorPool
+        protocol ones.  Match the initiator's IQN against the list of
+        patterns supplied in the "storpool_iscsi_export_to" configuration
+        setting.
+        """
+        if connector is None:
+            return False
+        if self._use_iscsi:
+            LOG.debug('  - forcing iSCSI for all exported volumes')
+            return True
+        if connector.get('storpool_wants_iscsi'):
+            LOG.debug('  - forcing iSCSI for the controller')
+            return True
+
+        try:
+            iqn = connector.get('initiator')
+        except Exception:
+            iqn = None
+        try:
+            host = connector.get('host')
+        except Exception:
+            host = None
+        if iqn is None or host is None:
+            LOG.debug('  - this connector certainly does not want iSCSI')
+            return False
+
+        LOG.debug('  - check whether %(host)s (%(iqn)s) wants iSCSI',
+                  {
+                      'host': host,
+                      'iqn': iqn,
+                  })
+
+        export_to = self.configuration.storpool_iscsi_export_to
+        if export_to is None:
+            return False
+
+        for pat in export_to.split():
+            LOG.debug('    - matching against %(pat)s', {'pat': pat})
+            if fnmatch.fnmatch(iqn, pat):
+                LOG.debug('      - got it!')
+                return True
+        LOG.debug('    - nope')
+        return False
+
     def validate_connector(self, connector):
+        if self._connector_wants_iscsi(connector):
+            return True
         return self._storpool_client_id(connector) >= 0
 
+    def _get_iscsi_config(self, iqn, volume_id):
+        """Get the StorPool iSCSI config items pertaining to this volume.
+
+        Find the elements of the StorPool iSCSI configuration tree that
+        will be needed to create, ensure, or remove the iSCSI export of
+        the specified volume to the specified initiator.
+        """
+        cfg = self._attach.api().iSCSIConfig()
+
+        pg_name = self.configuration.storpool_iscsi_portal_group
+        pg_found = [
+            pg for pg in cfg.iscsi.portalGroups.values() if pg.name == pg_name
+        ]
+        if not pg_found:
+            raise Exception('StorPool Cinder iSCSI configuration error: '
+                            'no portal group "{pg}"'.format(pg=pg_name))
+        pg = pg_found[0]
+
+        # Do we know about this initiator?
+        i_found = [
+            init for init in cfg.iscsi.initiators.values() if init.name == iqn
+        ]
+        if i_found:
+            initiator = i_found[0]
+        else:
+            initiator = None
+
+        # Is this volume already being exported?
+        volname = self._attach.volumeName(volume_id)
+        t_found = [
+            tgt for tgt in cfg.iscsi.targets.values() if tgt.volume == volname
+        ]
+        if t_found:
+            target = t_found[0]
+        else:
+            target = None
+
+        # OK, so is this volume being exported to this initiator?
+        export = None
+        if initiator is not None and target is not None:
+            e_found = [
+                exp for exp in initiator.exports
+                if exp.portalGroup == pg.name and exp.target == target.name
+            ]
+            if e_found:
+                export = e_found[0]
+
+        return {
+            'cfg': cfg,
+            'pg': pg,
+            'initiator': initiator,
+            'target': target,
+            'export': export,
+            'volume_name': volname,
+            'volume_id': volume_id,
+        }
+
+    def _create_iscsi_export(self, volume, connector):
+        """Create (if needed) an iSCSI export for the StorPool volume."""
+        LOG.debug(
+            '_create_iscsi_export() invoked for volume '
+            '"%(vol_name)s" (%(vol_id)s) connector %(connector)s',
+            {
+                'vol_name': volume['display_name'],
+                'vol_id': volume['id'],
+                'connector': connector,
+            }
+        )
+        iqn = connector['initiator']
+        try:
+            cfg = self._get_iscsi_config(iqn, volume['id'])
+        except Exception as exc:
+            LOG.error(
+                'Could not fetch the iSCSI config: %(exc)s', {'exc': exc}
+            )
+            raise
+
+        if cfg['initiator'] is None:
+            if not (self.configuration.storpool_iscsi_learn_initiator_iqns or
+                    self.configuration.storpool_iscsi_cinder_volume and
+                    connector.get('storpool_wants_iscsi')):
+                raise Exception('The "{iqn}" initiator IQN for the "{host}" '
+                                'host is not defined in the StorPool '
+                                'configuration.'
+                                .format(iqn=iqn, host=connector['host']))
+            else:
+                LOG.info('Creating a StorPool iSCSI initiator '
+                         'for "{host}s" ({iqn}s)',
+                         {'host': connector['host'], 'iqn': iqn})
+                self._attach.api().iSCSIConfigChange({
+                    'commands': [
+                        {
+                            'createInitiator': {
+                                'name': iqn,
+                                'username': '',
+                                'secret': '',
+                            },
+                        },
+                        {
+                            'initiatorAddNetwork': {
+                                'initiator': iqn,
+                                'net': '0.0.0.0/0',
+                            },
+                        },
+                    ]
+                })
+
+        if cfg['target'] is None:
+            LOG.info(
+                'Creating a StorPool iSCSI target '
+                'for the "%(vol_name)s" volume (%(vol_id)s)',
+                {
+                    'vol_name': volume['display_name'],
+                    'vol_id': volume['id'],
+                }
+            )
+            self._attach.api().iSCSIConfigChange({
+                'commands': [
+                    {
+                        'createTarget': {
+                            'volumeName': cfg['volume_name'],
+                        },
+                    },
+                ]
+            })
+            cfg = self._get_iscsi_config(iqn, volume['id'])
+
+        if cfg['export'] is None:
+            LOG.info('Creating a StorPool iSCSI export '
+                     'for the "{vol_name}s" volume ({vol_id}s) '
+                     'to the "{host}s" initiator ({iqn}s) '
+                     'in the "{pg}s" portal group',
+                     {
+                         'vol_name': volume['display_name'],
+                         'vol_id': volume['id'],
+                         'host': connector['host'],
+                         'iqn': iqn,
+                         'pg': cfg['pg'].name
+                     })
+            self._attach.api().iSCSIConfigChange({
+                'commands': [
+                    {
+                        'export': {
+                            'initiator': iqn,
+                            'portalGroup': cfg['pg'].name,
+                            'volumeName': cfg['volume_name'],
+                        },
+                    },
+                ]
+            })
+
+        target_portals = [
+            "{addr}:3260".format(addr=net.address)
+            for net in cfg['pg'].networks
+        ]
+        target_iqns = [cfg['target'].name] * len(target_portals)
+        target_luns = [0] * len(target_portals)
+        if connector.get('multipath', False):
+            multipath_settings = {
+                'target_iqns': target_iqns,
+                'target_portals': target_portals,
+                'target_luns': target_luns,
+            }
+        else:
+            multipath_settings = {}
+
+        res = {
+            'driver_volume_type': 'iscsi',
+            'data': {
+                **multipath_settings,
+                'target_discovered': False,
+                'target_iqn': target_iqns[0],
+                'target_portal': target_portals[0],
+                'target_lun': target_luns[0],
+                'volume_id': volume['id'],
+                'discard': True,
+            },
+        }
+        LOG.debug('returning %(res)s', {'res': res})
+        return res
+
+    def _remove_iscsi_export(self, volume, connector):
+        """Remove an iSCSI export for the specified StorPool volume."""
+        LOG.debug(
+            '_remove_iscsi_export() invoked for volume '
+            '"%(vol_name)s" (%(vol_id)s) connector %(conn)s',
+            {
+                'vol_name': volume['display_name'],
+                'vol_id': volume['id'],
+                'conn': connector,
+            }
+        )
+        try:
+            cfg = self._get_iscsi_config(connector['initiator'], volume['id'])
+        except Exception as exc:
+            LOG.error(
+                'Could not fetch the iSCSI config: %(exc)s', {'exc': exc}
+            )
+            raise
+
+        if cfg['export'] is not None:
+            LOG.info('Removing the StorPool iSCSI export '
+                     'for the "%(vol_name)s" volume (%(vol_id)s) '
+                     'to the "%(host)s" initiator (%(iqn)s) '
+                     'in the "%(pg)s" portal group',
+                     {
+                         'vol_name': volume['display_name'],
+                         'vol_id': volume['id'],
+                         'host': connector['host'],
+                         'iqn': connector['initiator'],
+                         'pg': cfg['pg'].name,
+                     })
+            try:
+                self._attach.api().iSCSIConfigChange({
+                    'commands': [
+                        {
+                            'exportDelete': {
+                                'initiator': cfg['initiator'].name,
+                                'portalGroup': cfg['pg'].name,
+                                'volumeName': cfg['volume_name'],
+                            },
+                        },
+                    ]
+                })
+            except spapi.ApiError as e:
+                if e.name not in ('objectExists', 'objectDoesNotExist'):
+                    raise
+                LOG.info('Looks like somebody beat us to it')
+
+        if cfg['target'] is not None:
+            last = True
+            for initiator in cfg['cfg'].iscsi.initiators.values():
+                if initiator.name == cfg['initiator'].name:
+                    continue
+                for exp in initiator.exports:
+                    if exp.target == cfg['target'].name:
+                        last = False
+                        break
+                if not last:
+                    break
+
+            if last:
+                LOG.info(
+                    'Removing the StorPool iSCSI target '
+                    'for the "{vol_name}s" volume ({vol_id}s)',
+                    {
+                        'vol_name': volume['display_name'],
+                        'vol_id': volume['id'],
+                    }
+                )
+                try:
+                    self._attach.api().iSCSIConfigChange({
+                        'commands': [
+                            {
+                                'deleteTarget': {
+                                    'volumeName': cfg['volume_name'],
+                                },
+                            },
+                        ]
+                    })
+                except spapi.ApiError as e:
+                    if e.name not in ('objectDoesNotExist', 'invalidParam'):
+                        raise
+                    LOG.info('Looks like somebody beat us to it')
+
     def initialize_connection(self, volume, connector):
+        if self._connector_wants_iscsi(connector):
+            return self._create_iscsi_export(volume, connector)
         return {'driver_volume_type': 'storpool',
                 'data': {
                     'client_id': self._storpool_client_id(connector),
@@ -171,6 +517,9 @@ class StorPoolDriver(driver.VolumeDriver):
                 }}
 
     def terminate_connection(self, volume, connector, **kwargs):
+        if self._connector_wants_iscsi(connector):
+            LOG.debug('- removing an iSCSI export')
+            self._remove_iscsi_export(volume, connector)
         pass
 
     def create_snapshot(self, snapshot):
@@ -272,11 +621,20 @@ class StorPoolDriver(driver.VolumeDriver):
                     )
 
     def create_export(self, context, volume, connector):
-        pass
+        if self._connector_wants_iscsi(connector):
+            LOG.debug('- creating an iSCSI export')
+            self._create_iscsi_export(volume, connector)
 
     def remove_export(self, context, volume):
         pass
 
+    def _attach_volume(self, context, volume, properties, remote=False):
+        if self.configuration.storpool_iscsi_cinder_volume and not remote:
+            LOG.debug('- adding the "storpool_wants_iscsi" flag')
+            properties['storpool_wants_iscsi'] = True
+
+        return super()._attach_volume(context, volume, properties, remote)
+
     def delete_volume(self, volume):
         name = self._attach.volumeName(volume['id'])
         try:
@@ -313,6 +671,17 @@ class StorPoolDriver(driver.VolumeDriver):
             LOG.error("StorPoolDriver API initialization failed: %s", e)
             raise
 
+        export_to = self.configuration.storpool_iscsi_export_to
+        export_to_set = export_to is not None and export_to.split()
+        vol_iscsi = self.configuration.storpool_iscsi_cinder_volume
+        pg_name = self.configuration.storpool_iscsi_portal_group
+        if (export_to_set or vol_iscsi) and pg_name is None:
+            msg = _('The "storpool_iscsi_portal_group" option is required if '
+                    'any patterns are listed in "storpool_iscsi_export_to"')
+            raise exception.VolumeDriverException(message=msg)
+
+        self._use_iscsi = export_to == "*"
+
     def _update_volume_stats(self):
         try:
             dl = self._attach.api().disksList()
@@ -338,7 +707,7 @@ class StorPoolDriver(driver.VolumeDriver):
             'total_capacity_gb': total / units.Gi,
             'free_capacity_gb': free / units.Gi,
             'reserved_percentage': 0,
-            'multiattach': True,
+            'multiattach': self._use_iscsi,
             'QoS_support': False,
             'thick_provisioning_support': False,
             'thin_provisioning_support': True,
@@ -357,7 +726,9 @@ class StorPoolDriver(driver.VolumeDriver):
                 'volume_backend_name') or 'storpool',
             'vendor_name': 'StorPool',
             'driver_version': self.VERSION,
-            'storage_protocol': constants.STORPOOL,
+            'storage_protocol': (
+                constants.ISCSI if self._use_iscsi else constants.STORPOOL
+            ),
             # Driver capabilities
             'clone_across_pools': True,
             'sparse_copy_volume': True,
diff --git a/doc/source/configuration/block-storage/drivers/storpool-volume-driver.rst b/doc/source/configuration/block-storage/drivers/storpool-volume-driver.rst
index d2c5895a9..936e83675 100644
--- a/doc/source/configuration/block-storage/drivers/storpool-volume-driver.rst
+++ b/doc/source/configuration/block-storage/drivers/storpool-volume-driver.rst
@@ -19,12 +19,15 @@ Prerequisites
 * The controller and all the compute nodes must have access to the StorPool
   API service.
 
-* All nodes where StorPool-backed volumes will be attached must have access to
+* If iSCSI is not being used as a transport (see below), all nodes where
+  StorPool-backed volumes will be attached must have access to
   the StorPool data network and run the ``storpool_block`` service.
 
-* If StorPool-backed Cinder volumes need to be created directly from Glance
-  images, then the node running the ``cinder-volume`` service must also have
-  access to the StorPool data network and run the ``storpool_block`` service.
+* If Glance uses Cinder as its image store, or if StorPool-backed Cinder
+  volumes need to be created directly from Glance images, and iSCSI is not
+  being used as a transport, then the node running the ``cinder-volume``
+  service must also have access to the StorPool data network and run
+  the ``storpool_block`` service.
 
 * All nodes that need to access the StorPool API (the compute nodes and
   the node running the ``cinder-volume`` service) must have the following
@@ -34,6 +37,34 @@ Prerequisites
   * the storpool Python bindings package
   * the storpool.spopenstack Python helper package
 
+Using iSCSI as the transport protocol
+-------------------------------------
+
+The StorPool distributed storage system uses its own, highly optimized and
+tailored for its specifics, network protocol for communication between
+the storage servers and the clients (the OpenStack cluster nodes where
+StorPool-backed volumes will be attached). There are cases when granting
+various nodes access to the StorPool data network or installing and
+running the ``storpool_block`` client service on them may pose difficulties.
+The StorPool servers may also expose the user-created volumes and snapshots
+using the standard iSCSI protocol that only requires TCP routing and
+connectivity between the storage servers and the StorPool clients.
+The StorPool Cinder driver may be configured to export volumes and
+snapshots via iSCSI using the ``storpool_iscsi_export_to`` and
+``storpool_iscsi_portal_group`` configuration options.
+
+Additionally, even if e.g. the hypervisor nodes running Nova will use
+the StorPool network protocol and run the ``storpool_block`` service
+(so the ``storpool_iscsi_export_to`` option has its default empty string
+value), the ``storpool_iscsi_cinder_volume`` option configures the
+StorPool Cinder driver so that only the ``cinder-volume`` service will
+use the iSCSI protocol when attaching volumes and snapshots to transfer
+data to and from Glance images.
+
+Multiattach support for StorPool is only enabled if iSCSI is used:
+``storpool_iscsi_export_to`` is set to ``*``, that is, when all StorPool
+volumes will be exported via iSCSI to all initiators.
+
 Configuring the StorPool volume driver
 --------------------------------------
 
@@ -55,6 +86,35 @@ volume backend definition) and per volume type:
   with the default placement constraints for the StorPool cluster.
   The default value for the chain replication is 3.
 
+In addition, if the iSCSI protocol is used to access the StorPool cluster as
+described in the previous section, the following options may be defined in
+the ``cinder.conf`` volume backend definition:
+
+- ``storpool_iscsi_export_to``: if set to the value ``*``, the StorPool
+  Cinder driver will export volumes and snapshots using the iSCSI
+  protocol instead of the StorPool network protocol. The
+  ``storpool_iscsi_portal_group`` option must also be specified.
+
+- ``storpool_iscsi_portal_group``: if the ``storpool_iscsi_export_to``
+  option is set to the value ``*`` or the
+  ``storpool_iscsi_cinder_volume`` option is turned on, this option
+  specifies the name of the iSCSI portal group that Cinder volumes will
+  be exported to.
+
+- ``storpool_iscsi_cinder_volume``: if enabled, even if the
+  ``storpool_iscsi_export_to`` option has its default empty value, the
+  ``cinder-volume`` service will use iSCSI to attach the volumes and
+  snapshots for transferring data to and from Glance images if Glance is
+  configured to use the Cinder glance_store.
+
+- ``storpool_iscsi_learn_initiator_iqns``: if enabled, the StorPool
+  Cinder driver will automatically use the StorPool API to create
+  definitions for new initiators in the StorPool cluster's
+  configuration. This is the default behavior of the driver; it may be
+  disabled in the rare case if, e.g. because of site policy, OpenStack
+  iSCSI initiators (e.g. Nova hypervisors) need to be explicitly allowed
+  to use the StorPool iSCSI targets.
+
 Using the StorPool volume driver
 --------------------------------
 
diff --git a/releasenotes/notes/storpool-iscsi-cefcfe590a07c5c7.yaml b/releasenotes/notes/storpool-iscsi-cefcfe590a07c5c7.yaml
new file mode 100644
index 000000000..3863e4099
--- /dev/null
+++ b/releasenotes/notes/storpool-iscsi-cefcfe590a07c5c7.yaml
@@ -0,0 +1,15 @@
+features:
+  - |
+    StorPool driver: Added support for exporting the StorPool-backed
+    volumes using the iSCSI protocol, so that the Cinder volume service
+    and/or the Nova or Glance consumers do not need to have the StorPool
+    block device third-party service installed. See the StorPool driver
+    section in the Cinder documentation for more information on the
+    ``storpool_iscsi_export_to``, ``storpool_iscsi_portal_group``,
+    ``storpool_iscsi_cinder_volume``, and
+    ``storpool_iscsi_learn_initiator_iqns`` options.
+
+    .. note::
+       Multiattach support for StorPool is now only enabled if
+       ``storpool_iscsi_export_to`` is set to ``*``, that is, when all
+       StorPool volumes will be exported via iSCSI to all initiators.
-- 
2.43.0