Update xiv_ds8k driver name and description

The xiv_ds8k driver now supports IBM XIV, Spectrum Accelerate,
FlashSystem A9000, FlashSystem A9000R and DS8000 storage systems.
Therefore it should be renamed to IBM Storage driver.

The actual change includes:
- text changes in comments and documentation
- changes in fields in cinder.conf
- change in variable names
- change in file names

Implements: blueprint rename-xiv-ds8k-driver
Change-Id: Ia53a60e865ddac21029ca8518b6a506cb1682c51
DocImpact

cinder/opts.py

@@ -124,14 +124,14 @@ from cinder.volume.drivers.ibm import flashsystem_fc as \
 from cinder.volume.drivers.ibm import flashsystem_iscsi as \
     cinder_volume_drivers_ibm_flashsystemiscsi
 from cinder.volume.drivers.ibm import gpfs as cinder_volume_drivers_ibm_gpfs
+from cinder.volume.drivers.ibm import ibm_storage as \
+    cinder_volume_drivers_ibm_ibmstorage
 from cinder.volume.drivers.ibm.storwize_svc import storwize_svc_common as \
     cinder_volume_drivers_ibm_storwize_svc_storwizesvccommon
 from cinder.volume.drivers.ibm.storwize_svc import storwize_svc_fc as \
     cinder_volume_drivers_ibm_storwize_svc_storwizesvcfc
 from cinder.volume.drivers.ibm.storwize_svc import storwize_svc_iscsi as \
     cinder_volume_drivers_ibm_storwize_svc_storwizesvciscsi
-from cinder.volume.drivers.ibm import xiv_ds8k as \
-    cinder_volume_drivers_ibm_xivds8k
 from cinder.volume.drivers.infortrend.eonstor_ds_cli import common_cli as \
     cinder_volume_drivers_infortrend_eonstor_ds_cli_commoncli
 from cinder.volume.drivers.kaminario import kaminario_common as \
@@ -268,7 +268,7 @@ def list_opts():
                 cinder_volume_drivers_pure.PURE_OPTS,
                 cinder_context.context_opts,
                 cinder_scheduler_driver.scheduler_driver_opts,
-                cinder_volume_drivers_scality.volume_opts,
+                cinder_volume_drivers_ibm_ibmstorage.driver_opts,
                 cinder_volume_drivers_vmware_vmdk.vmdk_opts,
                 cinder_volume_drivers_lenovo_lenovocommon.common_opts,
                 cinder_volume_drivers_lenovo_lenovocommon.iscsi_opts,
@@ -281,6 +281,7 @@ def list_opts():
                 cinder_scheduler_weights_volumenumber.
                 volume_number_weight_opts,
                 cinder_volume_drivers_coho.coho_opts,
+                cinder_volume_drivers_scality.volume_opts,
                 cinder_volume_drivers_xio.XIO_OPTS,
                 cinder_volume_drivers_ibm_storwize_svc_storwizesvcfc.
                 storwize_svc_fc_opts,
@@ -353,7 +354,6 @@ def list_opts():
                 [cinder_volume_api.volume_host_opt],
                 [cinder_volume_api.volume_same_az_opt],
                 [cinder_volume_api.az_cache_time_opt],
-                cinder_volume_drivers_ibm_xivds8k.xiv_ds8k_opts,
                 cinder_volume_drivers_hpe_hpe3parcommon.hpe3par_opts,
                 cinder_volume_drivers_datera.d_opts,
                 cinder_volume_drivers_zadara.zadara_opts,

cinder/tests/unit/conf_fixture.py

@@ -23,8 +23,6 @@ CONF = cfg.CONF
 
 CONF.import_opt('policy_file', 'cinder.policy', group='oslo_policy')
 CONF.import_opt('volume_driver', 'cinder.volume.manager')
-CONF.import_opt('xiv_ds8k_proxy',
-                'cinder.volume.drivers.ibm.xiv_ds8k')
 CONF.import_opt('backup_driver', 'cinder.backup.manager')
 CONF.import_opt('fixed_key', 'cinder.keymgr.conf_key_mgr', group='keymgr')
 CONF.import_opt('scheduler_driver', 'cinder.scheduler.manager')
@@ -42,9 +40,6 @@ def set_defaults(conf):
     conf.set_default('sqlite_synchronous', False, group='database')
     conf.set_default('policy_file', 'cinder.tests.unit/policy.json',
                      group='oslo_policy')
-    conf.set_default(
-        'xiv_ds8k_proxy',
-        'cinder.tests.unit.test_ibm_xiv_ds8k.XIVDS8KFakeProxyDriver')
     conf.set_default('backup_driver', 'cinder.tests.unit.backup.fake_service')
     conf.set_default('fixed_key', default='0' * 64, group='keymgr')
     conf.set_default('scheduler_driver',

cinder/tests/unit/volume/drivers/ibm/test_ibm_storage.py

@@ -29,7 +29,7 @@ from cinder.i18n import _
 from cinder.objects import fields
 from cinder import test
 from cinder.volume import configuration as conf
-from cinder.volume.drivers.ibm import xiv_ds8k
+from cinder.volume.drivers.ibm import ibm_storage
 from cinder.volume import volume_types
 
 FAKE = "fake"
@@ -81,30 +81,37 @@ CG_SNAPSHOT = {'id': CG_SNAPSHOT_ID,
 
 CONNECTOR = {'initiator': "iqn.2012-07.org.fake:01:948f189c4695", }
 
+FAKE_PROXY = 'cinder.tests.unit.volume.drivers.ibm.test_ibm_storage' \
+    '.IBMStorageFakeProxyDriver'
 
-class XIVDS8KFakeProxyDriver(object):
-    """Fake IBM XIV and DS8K Proxy Driver."""
 
-    def __init__(self, xiv_ds8k_info, logger, expt,
+class IBMStorageFakeProxyDriver(object):
+    """Fake IBM Storage driver
+
+    Fake IBM Storage driver for IBM XIV, Spectrum Accelerate,
+    FlashSystem A9000, FlashSystem A9000R and DS8000 storage systems.
+    """
+
+    def __init__(self, ibm_storage_info, logger, expt,
                  driver=None, active_backend_id=None):
         """Initialize Proxy."""
 
-        self.xiv_ds8k_info = xiv_ds8k_info
+        self.ibm_storage_info = ibm_storage_info
         self.logger = logger
         self.exception = expt
-        self.xiv_ds8k_portal = \
+        self.storage_portal = \
-            self.xiv_ds8k_iqn = FAKE
+            self.storage_iqn = FAKE
 
         self.volumes = {}
         self.snapshots = {}
         self.driver = driver
 
     def setup(self, context):
-        if self.xiv_ds8k_info['xiv_ds8k_user'] != self.driver\
+        if self.ibm_storage_info['user'] != self.driver\
                 .configuration.san_login:
             raise self.exception.NotAuthorized()
 
-        if self.xiv_ds8k_info['xiv_ds8k_address'] != self.driver\
+        if self.ibm_storage_info['address'] != self.driver\
                 .configuration.san_ip:
             raise self.exception.HostNotFound(host='fake')
 
@@ -143,14 +150,14 @@ class XIVDS8KFakeProxyDriver(object):
 
         return {'driver_volume_type': 'iscsi',
                 'data': {'target_discovered': True,
-                         'target_portal': self.xiv_ds8k_portal,
+                         'target_portal': self.storage_portal,
-                         'target_iqn': self.xiv_ds8k_iqn,
+                         'target_iqn': self.storage_iqn,
                          'target_lun': lun_id,
                          'volume_id': volume['id'],
                          'multipath': True,
                          'provider_location': "%s,1 %s %s" % (
-                             self.xiv_ds8k_portal,
+                             self.storage_portal,
-                             self.xiv_ds8k_iqn,
+                             self.storage_iqn,
                              lun_id), },
                 }
 
@@ -284,20 +291,22 @@ class XIVDS8KFakeProxyDriver(object):
         return target_id, volume_update_list
 
 
-class XIVDS8KVolumeDriverTest(test.TestCase):
+class IBMStorageVolumeDriverTest(test.TestCase):
-    """Test IBM XIV and DS8K volume driver."""
+    """Test IBM Storage driver
+
+    Test IBM Storage driver for IBM XIV, Spectrum Accelerate,
+    FlashSystem A9000, FlashSystem A9000R and DS8000 storage Systems.
+    """
 
     def setUp(self):
-        """Initialize IBM XIV and DS8K Driver."""
+        """Initialize IBM Storage Driver."""
-        super(XIVDS8KVolumeDriverTest, self).setUp()
+        super(IBMStorageVolumeDriverTest, self).setUp()
 
         configuration = mock.Mock(conf.Configuration)
         configuration.san_is_local = False
-        configuration.xiv_ds8k_proxy = (
+        configuration.proxy = FAKE_PROXY
-            'cinder.tests.unit.volume.drivers.ibm.' +
+        configuration.connection_type = 'iscsi'
-            'test_ibm_xiv_ds8k.XIVDS8KFakeProxyDriver')
+        configuration.chap = 'disabled'
-        configuration.xiv_ds8k_connection_type = 'iscsi'
-        configuration.xiv_chap = 'disabled'
         configuration.san_ip = FAKE
         configuration.management_ips = FAKE
         configuration.san_login = FAKE
@@ -305,35 +314,35 @@ class XIVDS8KVolumeDriverTest(test.TestCase):
         configuration.san_password = FAKE
         configuration.append_config_values(mock.ANY)
 
-        self.driver = xiv_ds8k.XIVDS8KDriver(
+        self.driver = ibm_storage.IBMStorageDriver(
             configuration=configuration)
 
-    def test_initialized_should_set_xiv_ds8k_info(self):
+    def test_initialized_should_set_ibm_storage_info(self):
         """Test that the san flags are passed to the IBM proxy."""
 
         self.assertEqual(
-            self.driver.xiv_ds8k_proxy.xiv_ds8k_info['xiv_ds8k_user'],
+            self.driver.proxy.ibm_storage_info['user'],
             self.driver.configuration.san_login)
         self.assertEqual(
-            self.driver.xiv_ds8k_proxy.xiv_ds8k_info['xiv_ds8k_pass'],
+            self.driver.proxy.ibm_storage_info['password'],
             self.driver.configuration.san_password)
         self.assertEqual(
-            self.driver.xiv_ds8k_proxy.xiv_ds8k_info['xiv_ds8k_address'],
+            self.driver.proxy.ibm_storage_info['address'],
             self.driver.configuration.san_ip)
         self.assertEqual(
-            self.driver.xiv_ds8k_proxy.xiv_ds8k_info['xiv_ds8k_vol_pool'],
+            self.driver.proxy.ibm_storage_info['vol_pool'],
             self.driver.configuration.san_clustername)
 
     def test_setup_should_fail_if_credentials_are_invalid(self):
-        """Test that the xiv_ds8k_proxy validates credentials."""
+        """Test that the proxy validates credentials."""
 
-        self.driver.xiv_ds8k_proxy.xiv_ds8k_info['xiv_ds8k_user'] = 'invalid'
+        self.driver.proxy.ibm_storage_info['user'] = 'invalid'
         self.assertRaises(exception.NotAuthorized, self.driver.do_setup, None)
 
     def test_setup_should_fail_if_connection_is_invalid(self):
-        """Test that the xiv_ds8k_proxy validates connection."""
+        """Test that the proxy validates connection."""
 
-        self.driver.xiv_ds8k_proxy.xiv_ds8k_info['xiv_ds8k_address'] = \
+        self.driver.proxy.ibm_storage_info['address'] = \
             'invalid'
         self.assertRaises(exception.HostNotFound, self.driver.do_setup, None)
 
@@ -342,7 +351,7 @@ class XIVDS8KVolumeDriverTest(test.TestCase):
 
         self.driver.do_setup(None)
         self.driver.create_volume(VOLUME)
-        has_volume = self.driver.xiv_ds8k_proxy.volume_exists(VOLUME)
+        has_volume = self.driver.proxy.volume_exists(VOLUME)
         self.assertTrue(has_volume)
         self.driver.delete_volume(VOLUME)
 
@@ -352,7 +361,7 @@ class XIVDS8KVolumeDriverTest(test.TestCase):
         self.driver.do_setup(None)
 
         self.assertFalse(
-            self.driver.xiv_ds8k_proxy.volume_exists({'name': FAKE})
+            self.driver.proxy.volume_exists({'name': FAKE})
         )
 
     def test_delete_volume(self):
@@ -361,7 +370,7 @@ class XIVDS8KVolumeDriverTest(test.TestCase):
         self.driver.do_setup(None)
         self.driver.create_volume(VOLUME)
         self.driver.delete_volume(VOLUME)
-        has_volume = self.driver.xiv_ds8k_proxy.volume_exists(VOLUME)
+        has_volume = self.driver.proxy.volume_exists(VOLUME)
         self.assertFalse(has_volume)
 
     def test_delete_volume_should_fail_for_not_existing_volume(self):
@@ -371,7 +380,7 @@ class XIVDS8KVolumeDriverTest(test.TestCase):
         self.driver.delete_volume(VOLUME)
 
     def test_create_volume_should_fail_if_no_pool_space_left(self):
-        """Verify that the xiv_ds8k_proxy validates volume pool space."""
+        """Verify that the proxy validates volume pool space."""
 
         self.driver.do_setup(None)
         self.assertRaises(exception.VolumeBackendAPIException,
@@ -388,7 +397,7 @@ class XIVDS8KVolumeDriverTest(test.TestCase):
         self.driver.initialize_connection(VOLUME, CONNECTOR)
 
         self.assertTrue(
-            self.driver.xiv_ds8k_proxy.is_volume_attached(VOLUME, CONNECTOR))
+            self.driver.proxy.is_volume_attached(VOLUME, CONNECTOR))
 
         self.driver.terminate_connection(VOLUME, CONNECTOR)
         self.driver.delete_volume(VOLUME)
@@ -410,7 +419,7 @@ class XIVDS8KVolumeDriverTest(test.TestCase):
         self.driver.initialize_connection(VOLUME, CONNECTOR)
         self.driver.terminate_connection(VOLUME, CONNECTOR)
 
-        self.assertFalse(self.driver.xiv_ds8k_proxy.is_volume_attached(
+        self.assertFalse(self.driver.proxy.is_volume_attached(
             VOLUME,
             CONNECTOR))
 
@@ -519,7 +528,7 @@ class XIVDS8KVolumeDriverTest(test.TestCase):
         host = {
             'host': 'foo',
             'capabilities': {
-                'location_info': 'xiv_ds8k_fake_1',
+                'location_info': 'ibm_storage_fake_1',
                 'extent_size': '1024'
             }
         }
@@ -557,7 +566,7 @@ class XIVDS8KVolumeDriverTest(test.TestCase):
         host = {
             'host': 'foo',
             'capabilities': {
-                'location_info': 'xiv_ds8k_fake_1',
+                'location_info': 'ibm_storage_fake_1',
                 'extent_size': '1024'
             }
         }

cinder/volume/drivers/ibm/ibm_storage.py

@@ -19,7 +19,8 @@
 #   Avishay Traeger <avishay@il.ibm.com>
 
 """
-Unified Volume driver for IBM XIV and DS8K Storage Systems.
+IBM Storage driver is a unified Volume driver for IBM XIV, Spectrum Accelerate,
+FlashSystem A9000, FlashSystem A9000R and DS8000 storage systems.
 """
 
 from oslo_config import cfg
@@ -27,22 +28,21 @@ from oslo_log import log as logging
 from oslo_utils import importutils
 
 from cinder import exception
-from cinder import interface
 from cinder.volume import driver
 from cinder.volume.drivers.san import san
 
-xiv_ds8k_opts = [
+driver_opts = [
     cfg.StrOpt(
-        'xiv_ds8k_proxy',
+        'proxy',
-        default='xiv_ds8k_openstack.nova_proxy.XIVDS8KNovaProxy',
+        default='storage.proxy.IBMStorageProxy',
         help='Proxy driver that connects to the IBM Storage Array'),
     cfg.StrOpt(
-        'xiv_ds8k_connection_type',
+        'connection_type',
         default='iscsi',
         choices=['fibre_channel', 'iscsi'],
         help='Connection type to the IBM Storage Array'),
     cfg.StrOpt(
-        'xiv_chap',
+        'chap',
         default='disabled',
         choices=['disabled', 'enabled'],
         help='CHAP authentication mode, effective only for iscsi'
@@ -54,47 +54,48 @@ xiv_ds8k_opts = [
 ]
 
 CONF = cfg.CONF
-CONF.register_opts(xiv_ds8k_opts)
+CONF.register_opts(driver_opts)
 
 LOG = logging.getLogger(__name__)
 
 
-@interface.volumedriver
+class IBMStorageDriver(san.SanDriver,
-class XIVDS8KDriver(san.SanDriver,
+                       driver.ManageableVD,
-                    driver.ManageableVD,
+                       driver.ExtendVD,
-                    driver.ExtendVD,
+                       driver.SnapshotVD,
-                    driver.SnapshotVD,
+                       driver.MigrateVD,
-                    driver.MigrateVD,
+                       driver.ConsistencyGroupVD,
-                    driver.ConsistencyGroupVD,
+                       driver.CloneableImageVD,
-                    driver.CloneableImageVD,
+                       driver.TransferVD):
-                    driver.TransferVD):
+    """IBM Storage driver
-    """Unified IBM XIV and DS8K volume driver."""
+
+    IBM Storage driver is a unified Volume driver for IBM XIV, Spectrum
+    Accelerate, FlashSystem A9000, FlashSystem A9000R and DS8000 storage
+    systems.
+    """
 
     def __init__(self, *args, **kwargs):
         """Initialize the driver."""
 
-        super(XIVDS8KDriver, self).__init__(*args, **kwargs)
+        super(IBMStorageDriver, self).__init__(*args, **kwargs)
 
-        self.configuration.append_config_values(xiv_ds8k_opts)
+        self.configuration.append_config_values(driver_opts)
 
-        proxy = importutils.import_class(self.configuration.xiv_ds8k_proxy)
+        proxy = importutils.import_class(self.configuration.proxy)
 
         active_backend_id = kwargs.get('active_backend_id', None)
 
-        # NOTE: All Array specific configurations are prefixed with:
+        # Driver additional flags should be specified in the cinder.conf
-        # "xiv_ds8k_array_"
-        # These additional flags should be specified in the cinder.conf
         # preferably in each backend configuration.
 
-        self.xiv_ds8k_proxy = proxy(
+        self.proxy = proxy(
             {
-                "xiv_ds8k_user": self.configuration.san_login,
+                "user": self.configuration.san_login,
-                "xiv_ds8k_pass": self.configuration.san_password,
+                "password": self.configuration.san_password,
-                "xiv_ds8k_address": self.configuration.san_ip,
+                "address": self.configuration.san_ip,
-                "xiv_ds8k_vol_pool": self.configuration.san_clustername,
+                "vol_pool": self.configuration.san_clustername,
-                "xiv_ds8k_connection_type":
+                "connection_type": self.configuration.connection_type,
-                self.configuration.xiv_ds8k_connection_type,
+                "chap": self.configuration.chap,
-                "xiv_chap": self.configuration.xiv_chap,
                 "management_ips": self.configuration.management_ips
             },
             LOG,
@@ -103,81 +104,81 @@ class XIVDS8KDriver(san.SanDriver,
             active_backend_id=active_backend_id)
 
     def do_setup(self, context):
-        """Setup and verify IBM XIV and DS8K Storage connection."""
+        """Setup and verify connection to IBM Storage."""
 
-        self.xiv_ds8k_proxy.setup(context)
+        self.proxy.setup(context)
 
     def ensure_export(self, context, volume):
         """Ensure an export."""
 
-        return self.xiv_ds8k_proxy.ensure_export(context, volume)
+        return self.proxy.ensure_export(context, volume)
 
     def create_export(self, context, volume, connector):
         """Create an export."""
 
-        return self.xiv_ds8k_proxy.create_export(context, volume)
+        return self.proxy.create_export(context, volume)
 
     def create_volume(self, volume):
-        """Create a volume on the IBM XIV and DS8K Storage system."""
+        """Create a volume on the IBM Storage system."""
 
-        return self.xiv_ds8k_proxy.create_volume(volume)
+        return self.proxy.create_volume(volume)
 
     def delete_volume(self, volume):
-        """Delete a volume on the IBM XIV and DS8K Storage system."""
+        """Delete a volume on the IBM Storage system."""
 
-        self.xiv_ds8k_proxy.delete_volume(volume)
+        self.proxy.delete_volume(volume)
 
     def remove_export(self, context, volume):
         """Disconnect a volume from an attached instance."""
 
-        return self.xiv_ds8k_proxy.remove_export(context, volume)
+        return self.proxy.remove_export(context, volume)
 
     def initialize_connection(self, volume, connector):
         """Map the created volume."""
 
-        return self.xiv_ds8k_proxy.initialize_connection(volume, connector)
+        return self.proxy.initialize_connection(volume, connector)
 
     def terminate_connection(self, volume, connector, **kwargs):
         """Terminate a connection to a volume."""
 
-        return self.xiv_ds8k_proxy.terminate_connection(volume, connector)
+        return self.proxy.terminate_connection(volume, connector)
 
     def create_volume_from_snapshot(self, volume, snapshot):
         """Create a volume from a snapshot."""
 
-        return self.xiv_ds8k_proxy.create_volume_from_snapshot(
+        return self.proxy.create_volume_from_snapshot(
             volume,
             snapshot)
 
     def create_snapshot(self, snapshot):
         """Create a snapshot."""
 
-        return self.xiv_ds8k_proxy.create_snapshot(snapshot)
+        return self.proxy.create_snapshot(snapshot)
 
     def delete_snapshot(self, snapshot):
         """Delete a snapshot."""
 
-        return self.xiv_ds8k_proxy.delete_snapshot(snapshot)
+        return self.proxy.delete_snapshot(snapshot)
 
     def get_volume_stats(self, refresh=False):
         """Get volume stats."""
 
-        return self.xiv_ds8k_proxy.get_volume_stats(refresh)
+        return self.proxy.get_volume_stats(refresh)
 
     def create_cloned_volume(self, tgt_volume, src_volume):
         """Create Cloned Volume."""
 
-        return self.xiv_ds8k_proxy.create_cloned_volume(tgt_volume, src_volume)
+        return self.proxy.create_cloned_volume(tgt_volume, src_volume)
 
     def extend_volume(self, volume, new_size):
         """Extend Created Volume."""
 
-        self.xiv_ds8k_proxy.extend_volume(volume, new_size)
+        self.proxy.extend_volume(volume, new_size)
 
     def migrate_volume(self, context, volume, host):
         """Migrate the volume to the specified host."""
 
-        return self.xiv_ds8k_proxy.migrate_volume(context, volume, host)
+        return self.proxy.migrate_volume(context, volume, host)
 
     def manage_existing(self, volume, existing_ref):
         """Brings an existing backend storage object under Cinder management.
@@ -187,8 +188,9 @@ class XIVDS8KDriver(san.SanDriver,
         be interpreted.  It should be sufficient to identify a storage object
         that the driver should somehow associate with the newly-created cinder
         volume structure.
-        In the case of XIV, the existing_ref consists of a single field named
+        In the case of XIV family and FlashSystem A9000 family, the
-        'existing_ref' representing the name of the volume on the storage.
+        existing_ref consists of a single field named 'existing_ref'
+        representing the name of the volume on the storage.
 
         There are two ways to do this:
 
@@ -209,72 +211,72 @@ class XIVDS8KDriver(san.SanDriver,
         object.  If they are incompatible, raise a
         ManageExistingVolumeTypeMismatch, specifying a reason for the failure.
         """
-        return self.xiv_ds8k_proxy.manage_volume(volume, existing_ref)
+        return self.proxy.manage_volume(volume, existing_ref)
 
     def manage_existing_get_size(self, volume, existing_ref):
         """Return size of volume to be managed by manage_existing."""
 
-        return self.xiv_ds8k_proxy.manage_volume_get_size(volume, existing_ref)
+        return self.proxy.manage_volume_get_size(volume, existing_ref)
 
     def unmanage(self, volume):
         """Removes the specified volume from Cinder management."""
 
-        return self.xiv_ds8k_proxy.unmanage_volume(volume)
+        return self.proxy.unmanage_volume(volume)
 
     def freeze_backend(self, context):
         """Notify the backend that it's frozen. """
 
-        return self.xiv_ds8k_proxy.freeze_backend(context)
+        return self.proxy.freeze_backend(context)
 
     def thaw_backend(self, context):
         """Notify the backend that it's unfrozen/thawed. """
 
-        return self.xiv_ds8k_proxy.thaw_backend(context)
+        return self.proxy.thaw_backend(context)
 
     def failover_host(self, context, volumes, secondary_id=None):
         """Failover a backend to a secondary replication target. """
 
-        return self.xiv_ds8k_proxy.failover_host(
+        return self.proxy.failover_host(
             context, volumes, secondary_id)
 
     def get_replication_status(self, context, volume):
         """Return replication status."""
 
-        return self.xiv_ds8k_proxy.get_replication_status(context, volume)
+        return self.proxy.get_replication_status(context, volume)
 
     def retype(self, ctxt, volume, new_type, diff, host):
         """Convert the volume to be of the new type."""
 
-        return self.xiv_ds8k_proxy.retype(ctxt, volume, new_type, diff, host)
+        return self.proxy.retype(ctxt, volume, new_type, diff, host)
 
     def create_consistencygroup(self, context, group):
         """Creates a consistency group."""
 
-        return self.xiv_ds8k_proxy.create_consistencygroup(context, group)
+        return self.proxy.create_consistencygroup(context, group)
 
     def delete_consistencygroup(self, context, group, volumes):
         """Deletes a consistency group."""
 
-        return self.xiv_ds8k_proxy.delete_consistencygroup(
+        return self.proxy.delete_consistencygroup(
             context, group, volumes)
 
     def create_cgsnapshot(self, context, cgsnapshot, snapshots):
         """Creates a consistency group snapshot."""
 
-        return self.xiv_ds8k_proxy.create_cgsnapshot(
+        return self.proxy.create_cgsnapshot(
             context, cgsnapshot, snapshots)
 
     def delete_cgsnapshot(self, context, cgsnapshot, snapshots):
         """Deletes a consistency group snapshot."""
 
-        return self.xiv_ds8k_proxy.delete_cgsnapshot(
+        return self.proxy.delete_cgsnapshot(
             context, cgsnapshot, snapshots)
 
     def update_consistencygroup(self, context, group,
                                 add_volumes, remove_volumes):
         """Adds or removes volume(s) to/from an existing consistency group."""
 
-        return self.xiv_ds8k_proxy.update_consistencygroup(
+        return self.proxy.update_consistencygroup(
             context, group, add_volumes, remove_volumes)
 
     def create_consistencygroup_from_src(
@@ -282,6 +284,6 @@ class XIVDS8KDriver(san.SanDriver,
             source_cg=None, source_vols=None):
         """Creates a consistencygroup from source."""
 
-        return self.xiv_ds8k_proxy.create_consistencygroup_from_src(
+        return self.proxy.create_consistencygroup_from_src(
             context, group, volumes, cgsnapshot, snapshots,
             source_cg, source_vols)

cinder/volume/manager.py

@@ -151,6 +151,8 @@ MAPPING = {
     'cinder.volume.drivers.hpe.hpe_lefthand_iscsi.HPELeftHandISCSIDriver',
     'cinder.volume.drivers.san.hp.hp_xp_fc.HPXPFCDriver':
     'cinder.volume.drivers.hpe.hpe_xp_fc.HPEXPFCDriver',
+    'cinder.volume.drivers.ibm.xiv_ds8k':
+    'cinder.volume.drivers.ibm.ibm_storage',
 }
 
 

releasenotes/notes/rename_xiv_ds8k_to_ibm_storage-154eca69c44b3f95.yaml

@@ -0,0 +1,15 @@
+---
+features:
+  - The xiv_ds8k driver now supports IBM XIV, Spectrum
+    Accelerate, FlashSystem A9000, FlashSystem A9000R
+    and DS8000 storage systems, and was renamed to IBM
+    Storage Driver for OpenStack. The changes include text
+    changes, file names, names of cinder.conf flags, and
+    names of the proxy classes.
+upgrade:
+  - Users of the IBM Storage Driver, previously known as
+    the IBM XIV/DS8K driver, upgrading from Mitaka or
+    previous releases, need to reconfigure the relevant
+    cinder.conf entries. In most cases the change is just
+    removal of the xiv-ds8k field prefix, but for details
+    use the driver documentation.