Rebranding of VxFlex OS driver to PowerFlex

Renamed VxFlex OS driver to PowerFlex and move it to
another location. Change configuration options names
and removed deprecated ScaleIO name and related sio_
configuration options.

Change-Id: Iab5d66bbaab6533a4c1f8911e35fcd3a2cf09762
Implements: blueprint vxflexos-rebranding-driver

cinder/opts.py

@@ -72,6 +72,8 @@ from cinder.volume import api as cinder_volume_api
 from cinder.volume import driver as cinder_volume_driver
 from cinder.volume.drivers.datera import datera_iscsi as \
     cinder_volume_drivers_datera_dateraiscsi
+from cinder.volume.drivers.dell_emc.powerflex import driver as \
+    cinder_volume_drivers_dell_emc_powerflex_driver
 from cinder.volume.drivers.dell_emc.powermax import common as \
     cinder_volume_drivers_dell_emc_powermax_common
 from cinder.volume.drivers.dell_emc.sc import storagecenter_common as \
@@ -80,8 +82,6 @@ from cinder.volume.drivers.dell_emc.unity import driver as \
     cinder_volume_drivers_dell_emc_unity_driver
 from cinder.volume.drivers.dell_emc.vnx import common as \
     cinder_volume_drivers_dell_emc_vnx_common
-from cinder.volume.drivers.dell_emc.vxflexos import driver as \
-    cinder_volume_drivers_dell_emc_vxflexos_driver
 from cinder.volume.drivers.dell_emc import xtremio as \
     cinder_volume_drivers_dell_emc_xtremio
 from cinder.volume.drivers.fujitsu.eternus_dx import eternus_dx_common as \
@@ -289,12 +289,13 @@ def list_opts():
                 cinder_volume_driver.scst_opts,
                 cinder_volume_driver.image_opts,
                 cinder_volume_driver.fqdn_opts,
+                cinder_volume_drivers_dell_emc_powerflex_driver.
+                powerflex_opts,
                 cinder_volume_drivers_dell_emc_powermax_common.powermax_opts,
                 cinder_volume_drivers_dell_emc_sc_storagecentercommon.
                 common_opts,
                 cinder_volume_drivers_dell_emc_unity_driver.UNITY_OPTS,
                 cinder_volume_drivers_dell_emc_vnx_common.VNX_OPTS,
-                cinder_volume_drivers_dell_emc_vxflexos_driver.vxflexos_opts,
                 cinder_volume_drivers_dell_emc_xtremio.XTREMIO_OPTS,
                 cinder_volume_drivers_fujitsu_eternus_dx_eternusdxcommon.
                 FJ_ETERNUS_DX_OPT_opts,

cinder/tests/unit/volume/drivers/dell_emc/powerflex/__init__.py

@@ -18,9 +18,9 @@ import requests
 import six
 
 from cinder.tests.unit import test
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
 from cinder.volume import configuration as conf
-from cinder.volume.drivers.dell_emc.vxflexos import driver
+from cinder.volume.drivers.dell_emc.powerflex import driver
 
 
 class CustomResponseMode(object):
@@ -62,8 +62,8 @@ class CustomResponseMode(object):
         self.test_instance.HTTPS_MOCK_RESPONSES = self.current_responses
 
 
-class TestVxFlexOSDriver(test.TestCase):
+class TestPowerFlexDriver(test.TestCase):
-    """Base ``TestCase`` subclass for the ``VxFlexOSDriver``"""
+    """Base ``TestCase`` subclass for the ``PowerFlexDriver``"""
     RESPONSE_MODE = type(str('ResponseMode'), (object, ), dict(
         Valid='0',
         Invalid='1',
@@ -117,18 +117,19 @@ class TestVxFlexOSDriver(test.TestCase):
     def setUp(self):
         """Setup a test case environment.
 
-        Creates a ``VxFlexOSDriver`` instance
+        Creates a ``PowerFlexDriver`` instance
         Mocks the ``requests.get/post`` methods to return
                   ``MockHTTPSResponse``'s instead.
         """
-        super(TestVxFlexOSDriver, self).setUp()
+        super(TestPowerFlexDriver, self).setUp()
-        self.configuration = conf.Configuration(driver.vxflexos_opts,
+        self.configuration = conf.Configuration(driver.powerflex_opts,
                                                 conf.SHARED_CONF_GROUP)
         self._set_overrides()
-        self.driver = mocks.VxFlexOSDriver(configuration=self.configuration)
+        self.driver = mocks.PowerFlexDriver(configuration=self.configuration)
-        self.driver.primary_client = mocks.VxFlexOSClient(self.configuration)
+        self.driver.primary_client = mocks.PowerFlexClient(self.configuration)
-        self.driver.secondary_client = mocks.VxFlexOSClient(self.configuration,
+        self.driver.secondary_client = mocks.PowerFlexClient(
-                                                            is_primary=False)
+            self.configuration,
+            is_primary=False)
         self.driver.do_setup({})
 
         self.mock_object(requests, 'get', self.do_request)
@@ -141,18 +142,18 @@ class TestVxFlexOSDriver(test.TestCase):
         # Override the defaults to fake values
         self.override_config('san_ip', override='127.0.0.1',
                              group=conf.SHARED_CONF_GROUP)
-        self.override_config('vxflexos_rest_server_port', override='8888',
+        self.override_config('powerflex_rest_server_port', override='8888',
                              group=conf.SHARED_CONF_GROUP)
         self.override_config('san_login', override='test',
                              group=conf.SHARED_CONF_GROUP)
         self.override_config('san_password', override='pass',
                              group=conf.SHARED_CONF_GROUP)
-        self.override_config('vxflexos_storage_pools',
+        self.override_config('powerflex_storage_pools',
                              override='PD1:SP1',
                              group=conf.SHARED_CONF_GROUP)
         self.override_config('max_over_subscription_ratio',
                              override=5.0, group=conf.SHARED_CONF_GROUP)
-        self.override_config('vxflexos_server_api_version',
+        self.override_config('powerflex_server_api_version',
                              override='2.0.0', group=conf.SHARED_CONF_GROUP)
 
     def do_request(self, url, *args, **kwargs):

cinder/tests/unit/volume/drivers/dell_emc/powerflex/mocks.py

@@ -18,14 +18,14 @@ from oslo_config import cfg
 import requests
 import six
 
-from cinder.volume.drivers.dell_emc.vxflexos import driver
+from cinder.volume.drivers.dell_emc.powerflex import driver
-from cinder.volume.drivers.dell_emc.vxflexos import rest_client
+from cinder.volume.drivers.dell_emc.powerflex import rest_client
 
 CONF = cfg.CONF
 
 
-class VxFlexOSDriver(driver.VxFlexOSDriver):
+class PowerFlexDriver(driver.PowerFlexDriver):
-    """Mock VxFlex OS Driver class.
+    """Mock PowerFlex Driver class.
 
     Provides some fake configuration options
     """
@@ -34,7 +34,7 @@ class VxFlexOSDriver(driver.VxFlexOSDriver):
             "thin" if self.configuration.san_thin_provision else "thick"
         )
         self.configuration.max_over_subscription_ratio = (
-            self.configuration.vxflexos_max_over_subscription_ratio
+            self.configuration.powerflex_max_over_subscription_ratio
         )
 
     def local_path(self, volume):
@@ -50,8 +50,8 @@ class VxFlexOSDriver(driver.VxFlexOSDriver):
         pass
 
 
-class VxFlexOSClient(rest_client.RestClient):
+class PowerFlexClient(rest_client.RestClient):
-    """Mock VxFlex OS Rest Client class.
+    """Mock PowerFlex Rest Client class.
 
     Provides some fake configuration options
     """

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_attach_detach_volume.py

@@ -16,10 +16,10 @@
 from cinder import context
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
 
 
-class TestAttachDetachVolume(vxflexos.TestVxFlexOSDriver):
+class TestAttachDetachVolume(powerflex.TestPowerFlexDriver):
 
     def setUp(self):
         super(TestAttachDetachVolume, self).setUp()

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_create_cloned_volume.py

@@ -21,13 +21,13 @@ from cinder import context
 from cinder import exception
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
-from cinder.volume.drivers.dell_emc.vxflexos import utils as flex_utils
+from cinder.volume.drivers.dell_emc.powerflex import utils as flex_utils
 
 
-class TestCreateClonedVolume(vxflexos.TestVxFlexOSDriver):
+class TestCreateClonedVolume(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.create_cloned_volume()``"""
+    """Test cases for ``PowerFlexDriver.create_cloned_volume()``"""
     def setUp(self):
         """Setup a test case environment.
 

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_create_snapshot.py

@@ -22,13 +22,13 @@ from cinder import exception
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_snapshot
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
-from cinder.volume.drivers.dell_emc.vxflexos import utils as flex_utils
+from cinder.volume.drivers.dell_emc.powerflex import utils as flex_utils
 
 
-class TestCreateSnapShot(vxflexos.TestVxFlexOSDriver):
+class TestCreateSnapShot(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.create_snapshot()``"""
+    """Test cases for ``PowerFlexDriver.create_snapshot()``"""
     def return_fake_volume(self, ctx, id):
         return self.fake_volume
 

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_create_volume.py

@@ -20,12 +20,12 @@ import ddt
 from cinder import context
 from cinder import exception
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
 
 
 @ddt.ddt
-class TestCreateVolume(vxflexos.TestVxFlexOSDriver):
+class TestCreateVolume(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.create_volume()``"""
+    """Test cases for ``PowerFlexDriver.create_volume()``"""
     def setUp(self):
         """Setup a test case environment.
 

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_create_volume_from_snapshot.py

@@ -20,13 +20,13 @@ from cinder import context
 from cinder import exception
 from cinder.tests.unit import fake_snapshot
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
-from cinder.volume.drivers.dell_emc.vxflexos import utils as flex_utils
+from cinder.volume.drivers.dell_emc.powerflex import utils as flex_utils
 
 
-class TestCreateVolumeFromSnapShot(vxflexos.TestVxFlexOSDriver):
+class TestCreateVolumeFromSnapShot(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.create_volume_from_snapshot()``"""
+    """Test cases for ``PowerFlexDriver.create_volume_from_snapshot()``"""
     def setUp(self):
         """Setup a test case environment.
 

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_delete_snapshot.py

@@ -19,14 +19,14 @@ from cinder import exception
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit.fake_snapshot import fake_snapshot_obj
 from cinder.tests.unit.fake_volume import fake_volume_obj
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
 from cinder.volume import configuration
-from cinder.volume.drivers.dell_emc.vxflexos import utils as flex_utils
+from cinder.volume.drivers.dell_emc.powerflex import utils as flex_utils
 
 
-class TestDeleteSnapShot(vxflexos.TestVxFlexOSDriver):
+class TestDeleteSnapShot(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.delete_snapshot()``"""
+    """Test cases for ``PowerFlexDriver.delete_snapshot()``"""
     def setUp(self):
         """Setup a test case environment.
 
@@ -99,7 +99,7 @@ class TestDeleteSnapShot(vxflexos.TestVxFlexOSDriver):
 
     def test_delete_snapshot(self):
         """Setting the unmap volume before delete flag for tests """
-        self.override_config('vxflexos_unmap_volume_before_deletion', True,
+        self.override_config('powerflex_unmap_volume_before_deletion', True,
                              configuration.SHARED_CONF_GROUP)
         self.set_https_response_mode(self.RESPONSE_MODE.Valid)
         self.driver.delete_snapshot(self.snapshot)

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_delete_volume.py

@@ -18,14 +18,14 @@ from cinder import context
 from cinder import exception
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
 from cinder.volume import configuration
-from cinder.volume.drivers.dell_emc.vxflexos import utils as flex_utils
+from cinder.volume.drivers.dell_emc.powerflex import utils as flex_utils
 
 
-class TestDeleteVolume(vxflexos.TestVxFlexOSDriver):
+class TestDeleteVolume(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.delete_volume()``"""
+    """Test cases for ``PowerFlexDriver.delete_volume()``"""
     def setUp(self):
         """Setup a test case environment.
 
@@ -81,6 +81,6 @@ class TestDeleteVolume(vxflexos.TestVxFlexOSDriver):
 
     def test_delete_volume(self):
         """Setting the unmap volume before delete flag for tests """
-        self.override_config('vxflexos_unmap_volume_before_deletion', True,
+        self.override_config('powerflex_unmap_volume_before_deletion', True,
                              configuration.SHARED_CONF_GROUP)
         self.driver.delete_volume(self.volume)

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_extend_volume.py

@@ -18,17 +18,17 @@ from cinder import context
 from cinder import exception
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit.fake_volume import fake_volume_obj
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
 from cinder.volume import configuration
-from cinder.volume.drivers.dell_emc.vxflexos import utils as flex_utils
+from cinder.volume.drivers.dell_emc.powerflex import utils as flex_utils
 
 
-class TestExtendVolume(vxflexos.TestVxFlexOSDriver):
+class TestExtendVolume(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.extend_volume()``"""
+    """Test cases for ``PowerFlexDriver.extend_volume()``"""
 
     """ New sizes for the volume.
-    Since VxFlex OS has a granularity of 8 GB, multiples of 8 always work.
+    Since PowerFlex has a granularity of 8 GB, multiples of 8 always work.
     The 7 size should be either rounded up to 8 or raise an exception
     based on the round_volume_capacity config setting.
     """
@@ -93,13 +93,13 @@ class TestExtendVolume(vxflexos.TestVxFlexOSDriver):
                           self.NEW_SIZE)
 
     def test_extend_volume_bad_size_no_round(self):
-        self.override_config('vxflexos_round_volume_capacity', False,
+        self.override_config('powerflex_round_volume_capacity', False,
                              configuration.SHARED_CONF_GROUP)
         self.set_https_response_mode(self.RESPONSE_MODE.Valid)
         self.driver.extend_volume(self.volume, self.BAD_SIZE)
 
     def test_extend_volume_bad_size_round(self):
-        self.override_config('vxflexos_round_volume_capacity', True,
+        self.override_config('powerflex_round_volume_capacity', True,
                              configuration.SHARED_CONF_GROUP)
         self.driver.extend_volume(self.volume, self.BAD_SIZE)
 

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_get_manageable.py

@@ -19,13 +19,13 @@ from unittest import mock
 import ddt
 
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
 
 
 VOLUME_ID = "abcdabcd-1234-abcd-1234-abcdabcdabcd"
 PROVIDER_ID = "0000000000000001"
 
-MANAGEABLE_VXFLEXOS_VOLS = [
+MANAGEABLE_FLEX_VOLS = [
     {
         "volumeType": "ThinProvisioned",
         "storagePoolId": "6c6dc54500000000",
@@ -52,7 +52,7 @@ MANAGEABLE_VXFLEXOS_VOLS = [
     }
 ]
 
-VXFLEXOS_SNAPSHOT = {
+POWERFLEX_SNAPSHOT = {
     "volumeType": "Snapshot",
     "storagePoolId": "6c6dc54500000000",
     "sizeInKb": 8388608,
@@ -61,7 +61,7 @@ VXFLEXOS_SNAPSHOT = {
     "mappedSdcInfo": [],
 }
 
-MANAGEABLE_VXFLEXOS_VOL_REFS = [
+MANAGEABLE_FLEX_VOL_REFS = [
     {
         'reference': {'source-id': PROVIDER_ID},
         'size': 8,
@@ -99,16 +99,16 @@ MANAGEABLE_VXFLEXOS_VOL_REFS = [
 
 
 @ddt.ddt
-class VxFlexOSManageableCase(vxflexos.TestVxFlexOSDriver):
+class PowerFlexManageableCase(powerflex.TestPowerFlexDriver):
 
     def setUp(self):
         """Setup a test case environment."""
-        super(VxFlexOSManageableCase, self).setUp()
+        super(PowerFlexManageableCase, self).setUp()
         self.driver.storage_pools = super().STORAGE_POOLS
 
     def _test_get_manageable_things(self,
-                                    vxflexos_objects=MANAGEABLE_VXFLEXOS_VOLS,
+                                    powerflex_objects=MANAGEABLE_FLEX_VOLS,
-                                    expected_refs=MANAGEABLE_VXFLEXOS_VOL_REFS,
+                                    expected_refs=MANAGEABLE_FLEX_VOL_REFS,
                                     cinder_objs=list()):
         marker = mock.Mock()
         limit = mock.Mock()
@@ -120,7 +120,7 @@ class VxFlexOSManageableCase(vxflexos.TestVxFlexOSDriver):
             self.RESPONSE_MODE.Valid: {
                 'instances/StoragePool::{}/relationships/Volume'.format(
                     self.STORAGE_POOL_ID
-                ): vxflexos_objects,
+                ): powerflex_objects,
                 'types/Pool/instances/getByName::{},{}'.format(
                     self.PROT_DOMAIN_ID,
                     self.STORAGE_POOL_NAME
@@ -153,7 +153,7 @@ class VxFlexOSManageableCase(vxflexos.TestVxFlexOSDriver):
     def test_get_manageable_volumes(self):
         """Default success case.
 
-        Given a list of VxFlex OS volumes from the REST API, give back a list
+        Given a list of PowerFlex volumes from the REST API, give back a list
         of volume references.
         """
 
@@ -161,12 +161,12 @@ class VxFlexOSManageableCase(vxflexos.TestVxFlexOSDriver):
 
     def test_get_manageable_volumes_connected_vol(self):
         """Make sure volumes connected to hosts are flagged as unsafe."""
-        mapped_sdc = deepcopy(MANAGEABLE_VXFLEXOS_VOLS)
+        mapped_sdc = deepcopy(MANAGEABLE_FLEX_VOLS)
         mapped_sdc[0]['mappedSdcInfo'] = ["host1"]
         mapped_sdc[1]['mappedSdcInfo'] = ["host1", "host2"]
 
         # change up the expected results
-        expected_refs = deepcopy(MANAGEABLE_VXFLEXOS_VOL_REFS)
+        expected_refs = deepcopy(MANAGEABLE_FLEX_VOL_REFS)
         for x in range(len(mapped_sdc)):
             sdc = mapped_sdc[x]['mappedSdcInfo']
             if sdc and len(sdc) > 0:
@@ -175,7 +175,7 @@ class VxFlexOSManageableCase(vxflexos.TestVxFlexOSDriver):
                     = 'Volume mapped to %d host(s).' % len(sdc)
 
         self._test_get_manageable_things(expected_refs=expected_refs,
-                                         vxflexos_objects=mapped_sdc)
+                                         powerflex_objects=mapped_sdc)
 
     def test_get_manageable_volumes_already_managed(self):
         """Make sure volumes already owned by cinder are flagged as unsafe."""
@@ -185,7 +185,7 @@ class VxFlexOSManageableCase(vxflexos.TestVxFlexOSDriver):
         cinders_vols = [cinder_vol]
 
         # change up the expected results
-        expected_refs = deepcopy(MANAGEABLE_VXFLEXOS_VOL_REFS)
+        expected_refs = deepcopy(MANAGEABLE_FLEX_VOL_REFS)
         expected_refs[0]['reference'] = {'source-id': PROVIDER_ID}
         expected_refs[0]['safe_to_manage'] = False
         expected_refs[0]['reason_not_safe'] = 'Volume already managed.'
@@ -196,12 +196,12 @@ class VxFlexOSManageableCase(vxflexos.TestVxFlexOSDriver):
 
     def test_get_manageable_volumes_no_snapshots(self):
         """Make sure refs returned do not include snapshots."""
-        volumes = deepcopy(MANAGEABLE_VXFLEXOS_VOLS)
+        volumes = deepcopy(MANAGEABLE_FLEX_VOLS)
-        volumes.append(VXFLEXOS_SNAPSHOT)
+        volumes.append(POWERFLEX_SNAPSHOT)
 
-        self._test_get_manageable_things(vxflexos_objects=volumes)
+        self._test_get_manageable_things(powerflex_objects=volumes)
 
-    def test_get_manageable_volumes_no_vxflexos_volumes(self):
+    def test_get_manageable_volumes_no_powerflex_volumes(self):
-        """Expect no refs to be found if no volumes are on VxFlex OS."""
+        """Expect no refs to be found if no volumes are on PowerFlex."""
-        self._test_get_manageable_things(vxflexos_objects=[],
+        self._test_get_manageable_things(powerflex_objects=[],
                                          expected_refs=[])

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_groups.py

@@ -22,12 +22,12 @@ from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_group
 from cinder.tests.unit import fake_snapshot
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
 
 
-class TestGroups(vxflexos.TestVxFlexOSDriver):
+class TestGroups(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver groups support``"""
+    """Test cases for ``PowerFlexDriver groups support``"""
 
     def setUp(self):
         """Setup a test case environment.

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_initialize_connection.py

@@ -17,10 +17,10 @@ from unittest import mock
 from cinder import context
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
 
 
-class TestInitializeConnection(vxflexos.TestVxFlexOSDriver):
+class TestInitializeConnection(powerflex.TestPowerFlexDriver):
     def setUp(self):
         """Setup a test case environment."""
 

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_initialize_connection_snapshot.py

@@ -19,10 +19,10 @@ from cinder import context
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_snapshot
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
 
 
-class TestInitializeConnectionSnapshot(vxflexos.TestVxFlexOSDriver):
+class TestInitializeConnectionSnapshot(powerflex.TestPowerFlexDriver):
 
     def setUp(self):
         super(TestInitializeConnectionSnapshot, self).setUp()
@@ -62,7 +62,7 @@ class TestInitializeConnectionSnapshot(vxflexos.TestVxFlexOSDriver):
     def test_initialize_connection_with_size(self):
         """Test initializing when we know the snapshot size.
 
-        VxFlex OS can determine QOS specs based upon volume/snapshot size
+        PowerFlex can determine QOS specs based upon volume/snapshot size
         The QOS keys should always be returned
         """
         snapshot = fake_snapshot.fake_snapshot_obj(

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_manage_existing.py

@@ -21,14 +21,14 @@ from cinder import context
 from cinder import exception
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
-from cinder.volume.drivers.dell_emc.vxflexos import utils as flex_utils
+from cinder.volume.drivers.dell_emc.powerflex import utils as flex_utils
 from cinder.volume import volume_types
 
 
-class TestManageExisting(vxflexos.TestVxFlexOSDriver):
+class TestManageExisting(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.manage_existing()``"""
+    """Test cases for ``PowerFlexDriver.manage_existing()``"""
 
     def setUp(self):
         """Setup a test case environment.

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_manage_existing_snapshot.py

@@ -19,13 +19,13 @@ from cinder import exception
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_snapshot
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
 from cinder.volume import volume_types
 
 
-class TestManageExistingSnapshot(vxflexos.TestVxFlexOSDriver):
+class TestManageExistingSnapshot(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.manage_existing_snapshot()``"""
+    """Test cases for ``PowerFlexDriver.manage_existing_snapshot()``"""
 
     def setUp(self):
         """Setup a test case environment.

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_migrate_volume.py

@@ -23,7 +23,7 @@ from cinder import context
 from cinder import exception
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
 
 
 MIGRATE_VOLUME_PARAMS_CASES = (
@@ -42,8 +42,8 @@ MIGRATE_VOLUME_PARAMS_CASES = (
 
 
 @ddt.ddt
-class TestMigrateVolume(vxflexos.TestVxFlexOSDriver):
+class TestMigrateVolume(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.migrate_volume()``"""
+    """Test cases for ``PowerFlexDriver.migrate_volume()``"""
 
     def setUp(self):
         """Setup a test case environment.
@@ -155,7 +155,8 @@ class TestMigrateVolume(vxflexos.TestVxFlexOSDriver):
     def test_migrate_volume_migration_in_progress(self):
         with self.custom_response_mode(
                 **{'instances/Volume::{}/action/migrateVTree'.format(
-                    self.volume.provider_id): vxflexos.mocks.MockHTTPSResponse(
+                    self.volume.provider_id):
+                        powerflex.mocks.MockHTTPSResponse(
                 {
                     'errorCode': 717,
                     'message': 'Migration in progress',
@@ -165,7 +166,7 @@ class TestMigrateVolume(vxflexos.TestVxFlexOSDriver):
             self.assertEqual(self.migration_success, ret)
 
     @mock.patch(
-        'cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver.'
+        'cinder.volume.drivers.dell_emc.powerflex.driver.PowerFlexDriver.'
         '_wait_for_volume_migration_to_complete',
         side_effect=loopingcall.LoopingCallTimeOut()
     )
@@ -176,7 +177,7 @@ class TestMigrateVolume(vxflexos.TestVxFlexOSDriver):
     def test_migrate_volume_migration_failed(self):
         with self.custom_response_mode(
                 **{'instances/VTree::{}'.format(self.fake_vtree_id):
-                    vxflexos.mocks.MockHTTPSResponse(
+                    powerflex.mocks.MockHTTPSResponse(
                         {'vtreeMigrationInfo':
                             {'migrationStatus': 'NotInMigration',
                              'migrationPauseReason': 'MigrationError'}}, 200)}

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_misc.py

@@ -22,13 +22,13 @@ from cinder import context
 from cinder import exception
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
-from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
+from cinder.tests.unit.volume.drivers.dell_emc.powerflex import mocks
 from cinder.volume import configuration
 
 
 @ddt.ddt
-class TestMisc(vxflexos.TestVxFlexOSDriver):
+class TestMisc(powerflex.TestPowerFlexDriver):
 
     DOMAIN_ID = '1'
     POOL_ID = '1'
@@ -136,7 +136,7 @@ class TestMisc(vxflexos.TestVxFlexOSDriver):
         self.driver._check_volume_size(1)
 
     def test_volume_size_round_false(self):
-        self.override_config('vxflexos_round_volume_capacity', False,
+        self.override_config('powerflex_round_volume_capacity', False,
                              configuration.SHARED_CONF_GROUP)
         self.assertRaises(exception.VolumeBackendAPIException,
                           self.driver._check_volume_size, 1)
@@ -220,7 +220,7 @@ class TestMisc(vxflexos.TestVxFlexOSDriver):
         self.driver.get_volume_stats(True)
 
     @mock.patch(
-        'cinder.volume.drivers.dell_emc.vxflexos.rest_client.RestClient.'
+        'cinder.volume.drivers.dell_emc.powerflex.rest_client.RestClient.'
         'rename_volume',
         return_value=None)
     def test_update_migrated_volume(self, mock_rename):
@@ -231,7 +231,7 @@ class TestMisc(vxflexos.TestVxFlexOSDriver):
                          test_vol)
 
     @mock.patch(
-        'cinder.volume.drivers.dell_emc.vxflexos.rest_client.RestClient.'
+        'cinder.volume.drivers.dell_emc.powerflex.rest_client.RestClient.'
         'rename_volume',
         return_value=None)
     def test_update_unavailable_migrated_volume(self, mock_rename):
@@ -243,7 +243,7 @@ class TestMisc(vxflexos.TestVxFlexOSDriver):
                          test_vol)
 
     @mock.patch(
-        'cinder.volume.drivers.dell_emc.vxflexos.rest_client.RestClient.'
+        'cinder.volume.drivers.dell_emc.powerflex.rest_client.RestClient.'
         'rename_volume',
         side_effect=exception.VolumeBackendAPIException(data='Error!'))
     def test_fail_update_migrated_volume(self, mock_rename):
@@ -290,9 +290,9 @@ class TestMisc(vxflexos.TestVxFlexOSDriver):
                                             expected_provisioning_type):
         self.override_config('san_thin_provision', config_provisioning_type,
                              configuration.SHARED_CONF_GROUP)
-        self.driver = mocks.VxFlexOSDriver(configuration=self.configuration)
+        self.driver = mocks.PowerFlexDriver(configuration=self.configuration)
         self.driver.do_setup({})
-        self.driver.primary_client = mocks.VxFlexOSClient(self.configuration)
+        self.driver.primary_client = mocks.PowerFlexClient(self.configuration)
         self.driver.primary_client.do_setup()
         empty_storage_type = {}
         provisioning, compression = (
@@ -303,7 +303,7 @@ class TestMisc(vxflexos.TestVxFlexOSDriver):
         )
         self.assertEqual(expected_provisioning_type, provisioning)
 
-    @mock.patch('cinder.volume.drivers.dell_emc.vxflexos.rest_client.'
+    @mock.patch('cinder.volume.drivers.dell_emc.powerflex.rest_client.'
                 'RestClient.query_rest_api_version',
                 return_value="3.0")
     def test_get_volume_stats_v3(self, mock_version):

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_replication.py

@@ -16,18 +16,18 @@
 import ddt
 
 from cinder import exception
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
 from cinder.volume import configuration
 
 
 @ddt.ddt
-class TestReplication(vxflexos.TestVxFlexOSDriver):
+class TestReplication(powerflex.TestPowerFlexDriver):
-    """Test cases for VxFlex OS replication support."""
+    """Test cases for PowerFlex replication support."""
 
     def setUp(self):
         super(TestReplication, self).setUp()
 
-        self.replication_backend_id = 'vxflex_repl'
+        self.replication_backend_id = 'powerflex_repl'
         replication_device = [
             {
                 'backend_id': self.replication_backend_id,
@@ -55,7 +55,7 @@ class TestReplication(vxflexos.TestVxFlexOSDriver):
         }
 
     def test_do_setup_replication_configured(self):
-        super(vxflexos.mocks.VxFlexOSDriver, self.driver).do_setup({})
+        super(powerflex.mocks.PowerFlexDriver, self.driver).do_setup({})
         self.driver.check_for_setup_error()
         self.assertTrue(self.driver.secondary_client.is_configured)
         self.assertTrue(self.driver.replication_enabled)
@@ -63,15 +63,15 @@ class TestReplication(vxflexos.TestVxFlexOSDriver):
     @ddt.data(
         [
             {
-                'backend_id': 'vxflex_repl1'
+                'backend_id': 'powerflex_repl1'
             },
             {
-                'backend_id': 'vxflex_repl2'
+                'backend_id': 'powerflex_repl2'
             }
         ],
         [
             {
-                'backend_id': 'vxflex_repl1',
+                'backend_id': 'powerflex_repl1',
                 'san_ip': '127.0.0.2'
             },
         ]
@@ -81,13 +81,13 @@ class TestReplication(vxflexos.TestVxFlexOSDriver):
                              override=replication_device,
                              group=configuration.SHARED_CONF_GROUP)
         self.assertRaises(exception.InvalidInput,
-                          super(vxflexos.mocks.VxFlexOSDriver,
+                          super(powerflex.mocks.PowerFlexDriver,
                                 self.driver).do_setup,
                           {})
 
     def test_do_setup_already_failed_over(self):
-        self.driver.active_backend_id = 'vxflex_repl'
+        self.driver.active_backend_id = 'powerflex_repl'
-        super(vxflexos.mocks.VxFlexOSDriver, self.driver).do_setup({})
+        super(powerflex.mocks.PowerFlexDriver, self.driver).do_setup({})
         self.driver.check_for_setup_error()
         self.assertFalse(self.driver.replication_enabled)
 

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_revert_volume_to_snapshot.py

@@ -20,11 +20,11 @@ from cinder import exception
 from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import fake_snapshot
 from cinder.tests.unit import fake_volume
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
 
 
-class TestRevertVolume(vxflexos.TestVxFlexOSDriver):
+class TestRevertVolume(powerflex.TestPowerFlexDriver):
-    """Test cases for ``VxFlexOSDriver.revert_to_snapshot()``"""
+    """Test cases for ``PowerFlexDriver.revert_to_snapshot()``"""
 
     def setUp(self):
         """Setup a test case environment.

cinder/tests/unit/volume/drivers/dell_emc/powerflex/test_versions.py

@@ -16,11 +16,11 @@
 import ddt
 
 from cinder import exception
-from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
+from cinder.tests.unit.volume.drivers.dell_emc import powerflex
 
 
 @ddt.ddt
-class TestMultipleVersions(vxflexos.TestVxFlexOSDriver):
+class TestMultipleVersions(powerflex.TestPowerFlexDriver):
 
     version = '1.2.3.4'
     good_versions = ['1.2.3.4',
@@ -33,7 +33,7 @@ class TestMultipleVersions(vxflexos.TestVxFlexOSDriver):
                     '.6'
                     ]
 
-    # Test cases for ``VxFlexOSDriver._get_server_api_version()``
+    # Test cases for ``PowerFlexDriver._get_server_api_version()``
     def setUp(self):
         """Setup a test case environment."""
         super(TestMultipleVersions, self).setUp()

cinder/volume/drivers/dell_emc/powerflex/driver.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Dell Inc. or its subsidiaries.
+# Copyright (c) 2017-2020 Dell Inc. or its subsidiaries.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -13,7 +13,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 """
-Driver for Dell EMC VxFlex OS (formerly named Dell EMC ScaleIO).
+Driver for Dell EMC PowerFlex (formerly named Dell EMC VxFlex OS).
 """
 
 import math
@@ -39,9 +39,9 @@ from cinder.objects import fields
 from cinder import utils
 from cinder.volume import configuration
 from cinder.volume import driver
-from cinder.volume.drivers.dell_emc.vxflexos import options
+from cinder.volume.drivers.dell_emc.powerflex import options
-from cinder.volume.drivers.dell_emc.vxflexos import rest_client
+from cinder.volume.drivers.dell_emc.powerflex import rest_client
-from cinder.volume.drivers.dell_emc.vxflexos import utils as flex_utils
+from cinder.volume.drivers.dell_emc.powerflex import utils as flex_utils
 from cinder.volume.drivers.san import san
 from cinder.volume import manager
 from cinder.volume import qos_specs
@@ -50,15 +50,15 @@ from cinder.volume import volume_utils
 
 CONF = cfg.CONF
 
-vxflexos_opts = options.deprecated_opts + options.actual_opts
+powerflex_opts = options.deprecated_opts + options.actual_opts
 
-CONF.register_opts(vxflexos_opts, group=configuration.SHARED_CONF_GROUP)
+CONF.register_opts(powerflex_opts, group=configuration.SHARED_CONF_GROUP)
 
 LOG = logging.getLogger(__name__)
 
 
 PROVISIONING_KEY = "provisioning:type"
-REPLICATION_CG_KEY = "vxflexos:replication_cg"
+REPLICATION_CG_KEY = "powerflex:replication_cg"
 QOS_IOPS_LIMIT_KEY = "maxIOPS"
 QOS_BANDWIDTH_LIMIT = "maxBWS"
 QOS_IOPS_PER_GB = "maxIOPSperGB"
@@ -66,16 +66,16 @@ QOS_BANDWIDTH_PER_GB = "maxBWSperGB"
 
 BLOCK_SIZE = 8
 VOLUME_NOT_FOUND_ERROR = 79
-# This code belongs to older versions of VxFlex OS
+# This code belongs to older versions of PowerFlex
 VOLUME_NOT_MAPPED_ERROR = 84
 VOLUME_ALREADY_MAPPED_ERROR = 81
 MIN_BWS_SCALING_SIZE = 128
-VXFLEXOS_MAX_OVERSUBSCRIPTION_RATIO = 10.0
+POWERFLEX_MAX_OVERSUBSCRIPTION_RATIO = 10.0
 
 
 @interface.volumedriver
-class VxFlexOSDriver(driver.VolumeDriver):
+class PowerFlexDriver(driver.VolumeDriver):
-    """Cinder VxFlex OS(formerly named Dell EMC ScaleIO) Driver
+    """Cinder PowerFlex(formerly named Dell EMC VxFlex OS) Driver
 
     .. code-block:: none
 
@@ -86,28 +86,29 @@ class VxFlexOSDriver(driver.VolumeDriver):
           2.0.4 - Added compatibility with os_brick>1.15.3
           2.0.5 - Change driver name, rename config file options
           3.0.0 - Add support for VxFlex OS 3.0.x and for volumes compression
-          3.5.0 - Add support for VxFlex OS 3.5.x
+          3.5.0 - Add support for PowerFlex 3.5.x
-          3.5.1 - Add volume replication v2.1 support for VxFlex OS 3.5.x
+          3.5.1 - Add volume replication v2.1 support for PowerFlex 3.5.x
           3.5.2 - Add volume migration support
           3.5.3 - Add revert volume to snapshot support
           3.5.4 - Fix for Bug #1823200. See OSSN-0086 for details.
+          3.5.5 - Rebrand VxFlex OS to PowerFlex.
     """
 
-    VERSION = "3.5.4"
+    VERSION = "3.5.5"
     # ThirdPartySystems wiki
-    CI_WIKI_NAME = "DellEMC_VxFlexOS_CI"
+    CI_WIKI_NAME = "DellEMC_PowerFlex_CI"
 
-    vxflexos_qos_keys = (QOS_IOPS_LIMIT_KEY,
+    powerflex_qos_keys = (QOS_IOPS_LIMIT_KEY,
-                         QOS_BANDWIDTH_LIMIT,
+                          QOS_BANDWIDTH_LIMIT,
-                         QOS_IOPS_PER_GB,
+                          QOS_IOPS_PER_GB,
-                         QOS_BANDWIDTH_PER_GB)
+                          QOS_BANDWIDTH_PER_GB)
 
     def __init__(self, *args, **kwargs):
-        super(VxFlexOSDriver, self).__init__(*args, **kwargs)
+        super(PowerFlexDriver, self).__init__(*args, **kwargs)
 
         self.active_backend_id = kwargs.get("active_backend_id")
         self.configuration.append_config_values(san.san_opts)
-        self.configuration.append_config_values(vxflexos_opts)
+        self.configuration.append_config_values(powerflex_opts)
         self.statisticProperties = None
         self.storage_pools = None
         self.provisioning_type = None
@@ -122,17 +123,17 @@ class VxFlexOSDriver(driver.VolumeDriver):
         properties = {}
         self._set_property(
             properties,
-            "vxflexos:replication_cg",
+            "powerflex:replication_cg",
-            "VxFlex OS Replication Consistency Group.",
+            "PowerFlex Replication Consistency Group.",
-            _("Specifies the VxFlex OS Replication Consistency group for a "
+            _("Specifies the PowerFlex Replication Consistency group for a "
               "volume type. Source and target volumes will be added to the "
               "specified RCG during creation."),
             "string")
-        return properties, "vxflexos"
+        return properties, "powerflex"
 
     @staticmethod
     def get_driver_options():
-        return vxflexos_opts
+        return powerflex_opts
 
     @staticmethod
     def _extract_domain_and_pool_from_host(host):
@@ -174,12 +175,12 @@ class VxFlexOSDriver(driver.VolumeDriver):
             self.active_backend_id = manager.VolumeManager.FAILBACK_SENTINEL
         if not self.failover_choices:
             self.failover_choices = {manager.VolumeManager.FAILBACK_SENTINEL}
-        vxflexos_storage_pools = (
+        powerflex_storage_pools = (
-            self.configuration.safe_get("vxflexos_storage_pools")
+            self.configuration.safe_get("powerflex_storage_pools")
         )
-        if vxflexos_storage_pools:
+        if powerflex_storage_pools:
             self.storage_pools = [
-                e.strip() for e in vxflexos_storage_pools.split(",")
+                e.strip() for e in powerflex_storage_pools.split(",")
             ]
         LOG.info("Storage pools names: %s.", self.storage_pools)
         self.provisioning_type = (
@@ -187,7 +188,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         )
         LOG.info("Default provisioning type: %s.", self.provisioning_type)
         self.configuration.max_over_subscription_ratio = (
-            self.configuration.vxflexos_max_over_subscription_ratio
+            self.configuration.powerflex_max_over_subscription_ratio
         )
         self.connector = initiator.connector.InitiatorConnector.factory(
             initiator.SCALEIO,
@@ -205,22 +206,22 @@ class VxFlexOSDriver(driver.VolumeDriver):
 
         # validate oversubscription ratio
         if (self.configuration.max_over_subscription_ratio >
-                VXFLEXOS_MAX_OVERSUBSCRIPTION_RATIO):
+                POWERFLEX_MAX_OVERSUBSCRIPTION_RATIO):
             msg = (_("Max over subscription is configured to %(ratio)1f "
-                     "while VxFlex OS support up to %(vxflexos_ratio)s.") %
+                     "while PowerFlex support up to %(powerflex_ratio)s.") %
                    {"ratio": self.configuration.max_over_subscription_ratio,
-                    "vxflexos_ratio": VXFLEXOS_MAX_OVERSUBSCRIPTION_RATIO})
+                    "powerflex_ratio": POWERFLEX_MAX_OVERSUBSCRIPTION_RATIO})
             raise exception.InvalidInput(reason=msg)
-        # validate that version of VxFlex OS is supported
+        # validate that version of PowerFlex is supported
         if not flex_utils.version_gte(client.query_rest_api_version(), "2.0"):
-            # we are running against a pre-2.0.0 VxFlex OS(ScaleIO) instance
+            # we are running against a pre-2.0.0 PowerFlex(ScaleIO) instance
-            msg = (_("Using VxFlex OS versions less "
+            msg = (_("Using PowerFlex versions less "
                      "than v2.0 has been deprecated and will be "
                      "removed in a future version."))
             versionutils.report_deprecated_feature(LOG, msg)
         if not self.storage_pools:
             msg = (_("Must specify storage pools. "
-                     "Option: vxflexos_storage_pools."))
+                     "Option: powerflex_storage_pools."))
             raise exception.InvalidInput(reason=msg)
         # validate the storage pools and check if zero padding is enabled
         for pool in self.storage_pools:
@@ -241,7 +242,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
                 LOG.warning("Zero padding is disabled for pool %s. "
                             "This could lead to existing data being "
                             "accessible on new provisioned volumes. "
-                            "Consult the VxFlex OS product documentation "
+                            "Consult the PowerFlex product documentation "
                             "for information on how to enable zero padding "
                             "and prevent this from occurring.", pool)
         # validate replication configuration
@@ -259,7 +260,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
                 )
                 if not (flex_utils.version_gte(primary_version, "3.5") and
                         flex_utils.version_gte(secondary_version, "3.5")):
-                    LOG.info("VxFlex OS versions less than v3.5 do not "
+                    LOG.info("PowerFlex versions less than v3.5 do not "
                              "support replication.")
                     self.replication_enabled = False
                 else:
@@ -280,10 +281,10 @@ class VxFlexOSDriver(driver.VolumeDriver):
             return []
 
     def _get_queryable_statistics(self, sio_type, sio_id):
-        """Get statistic properties that can be obtained from VxFlex OS.
+        """Get statistic properties that can be obtained from PowerFlex.
 
-        :param sio_type: VxFlex OS resource type
+        :param sio_type: PowerFlex resource type
-        :param sio_id: VxFlex OS resource id
+        :param sio_id: PowerFlex resource id
         :return: statistic properties
         """
 
@@ -291,7 +292,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         client = self._get_client()
 
         if self.statisticProperties is None:
-            # in VxFlex OS 3.5 snapCapacityInUseInKb is replaced by
+            # in PowerFlex 3.5 snapCapacityInUseInKb is replaced by
             # snapshotCapacityInKb
             if flex_utils.version_gte(client.query_rest_api_version(), "3.5"):
                 self.statisticProperties = [
@@ -303,7 +304,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
                     "snapCapacityInUseInKb",
                     "thickCapacityInUseInKb",
                 ]
-            # VxFlex OS 3.0 provide useful precomputed stats
+            # PowerFlex 3.0 provide useful precomputed stats
             if flex_utils.version_gte(client.query_rest_api_version(), "3.0"):
                 self.statisticProperties.extend([
                     "netCapacityInUseInKb",
@@ -328,7 +329,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
                         "thinCapacityAllocatedInKb",
                     ],
                 }
-                r, response = client.execute_vxflexos_post_request(
+                r, response = client.execute_powerflex_post_request(
                     url=url,
                     params=params,
                     sio_type=sio_type
@@ -348,11 +349,11 @@ class VxFlexOSDriver(driver.VolumeDriver):
     def _setup_volume_replication(self, vol_or_snap, source_provider_id):
         """Configure replication for volume or snapshot.
 
-        Create volume on secondary VxFlex OS storage backend.
+        Create volume on secondary PowerFlex storage backend.
         Pair volumes and add replication pair to replication consistency group.
 
         :param vol_or_snap: source volume/snapshot
-        :param source_provider_id: primary VxFlex OS volume id
+        :param source_provider_id: primary PowerFlex volume id
         """
         try:
             # If vol_or_snap has 'volume' attribute we are dealing
@@ -402,13 +403,13 @@ class VxFlexOSDriver(driver.VolumeDriver):
     def _teardown_volume_replication(self, provider_id):
         """Stop volume/snapshot replication.
 
-        Unpair volumes/snapshot and remove volume/snapshot from VxFlex OS
+        Unpair volumes/snapshot and remove volume/snapshot from PowerFlex
         secondary storage backend.
         """
 
         if not provider_id:
             LOG.warning("Volume or snapshot does not have provider_id thus "
-                        "does not map to VxFlex OS volume.")
+                        "does not map to PowerFlex volume.")
             return
         try:
             pair_id, remote_pair_id, vol_id, remote_vol_id = (
@@ -465,7 +466,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
     def _failover_replication_cg(self, rcg_name, is_failback):
         """Failover/failback Replication Consistency Group on storage backend.
 
-        :param rcg_name: name of VxFlex OS Replication Consistency Group
+        :param rcg_name: name of PowerFlex Replication Consistency Group
         :param is_failback: is failover or failback
         :return: failover status of Replication Consistency Group
         """
@@ -560,8 +561,8 @@ class VxFlexOSDriver(driver.VolumeDriver):
         """Get volume provisioning and compression from VolumeType extraspecs.
 
         :param storage_type: extraspecs
-        :param protection_domain_name: name of VxFlex OS Protection Domain
+        :param protection_domain_name: name of PowerFlex Protection Domain
-        :param storage_pool_name: name of VxFlex OS Storage Pool
+        :param storage_pool_name: name of PowerFlex Storage Pool
         :param secondary: primary or secondary client
         :return: volume provisioning and compression
         """
@@ -590,7 +591,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         return provisioning, compression
 
     def create_volume(self, volume):
-        """Create volume on VxFlex OS storage backend.
+        """Create volume on PowerFlex storage backend.
 
         :param volume: volume to be created
         :return: volume model updates
@@ -632,7 +633,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
             "replication_status": fields.ReplicationStatus.DISABLED,
         }
         LOG.info("Successfully created volume %(vol_id)s. "
-                 "Volume size: %(size)s. VxFlex OS volume name: %(vol_name)s, "
+                 "Volume size: %(size)s. PowerFlex volume name: %(vol_name)s, "
                  "id: %(provider_id)s.",
                  {
                      "vol_id": volume.id,
@@ -655,7 +656,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
 
         if size % 8 != 0:
             round_volume_capacity = (
-                self.configuration.vxflexos_round_volume_capacity
+                self.configuration.powerflex_round_volume_capacity
             )
             if not round_volume_capacity:
                 msg = (_("Cannot create volume of size %s: "
@@ -678,14 +679,14 @@ class VxFlexOSDriver(driver.VolumeDriver):
                       "zero padding being disabled for pool, %s:%s. "
                       "This behaviour can be changed by setting "
                       "the configuration option "
-                      "vxflexos_allow_non_padded_volumes = True.",
+                      "powerflex_allow_non_padded_volumes = True.",
                       protection_domain_name, storage_pool_name)
             msg = _("Volume creation rejected due to "
                     "unsafe backend configuration.")
             raise exception.VolumeBackendAPIException(data=msg)
 
     def create_snapshot(self, snapshot):
-        """Create volume snapshot on VxFlex OS storage backend.
+        """Create volume snapshot on PowerFlex storage backend.
 
         :param snapshot: volume snapshot to be created
         :return: snapshot model updates
@@ -699,7 +700,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
                                              snapshot.id)
         model_updates = {"provider_id": provider_id}
         LOG.info("Successfully created snapshot %(snap_id)s "
-                 "for volume %(vol_id)s. VxFlex OS volume name: %(vol_name)s, "
+                 "for volume %(vol_id)s. PowerFlex volume name: %(vol_name)s, "
                  "id: %(vol_provider_id)s, snapshot name: %(snap_name)s, "
                  "snapshot id: %(snap_provider_id)s.",
                  {
@@ -715,9 +716,9 @@ class VxFlexOSDriver(driver.VolumeDriver):
         return model_updates
 
     def _create_volume_from_source(self, volume, source):
-        """Create volume from volume or snapshot on VxFlex OS storage backend.
+        """Create volume from volume or snapshot on PowerFlex storage backend.
 
-        We interchange 'volume' and 'snapshot' because in VxFlex OS
+        We interchange 'volume' and 'snapshot' because in PowerFlex
         snapshot is a volume: once a snapshot is generated it
         becomes a new unmapped volume in the system and the user
         may manipulate it in the same manner as any other volume
@@ -736,7 +737,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
             "replication_status": fields.ReplicationStatus.DISABLED,
         }
         LOG.info("Successfully created volume %(vol_id)s "
-                 "from source %(source_id)s. VxFlex OS volume name: "
+                 "from source %(source_id)s. PowerFlex volume name: "
                  "%(vol_name)s, id: %(vol_provider_id)s, source name: "
                  "%(source_name)s, source id: %(source_provider_id)s.",
                  {
@@ -763,7 +764,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         return model_updates
 
     def create_volume_from_snapshot(self, volume, snapshot):
-        """Create volume from snapshot on VxFlex OS storage backend.
+        """Create volume from snapshot on PowerFlex storage backend.
 
         :param volume: volume to be created
         :param snapshot: snapshot from which volume will be created
@@ -775,7 +776,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         return self._create_volume_from_source(volume, snapshot)
 
     def extend_volume(self, volume, new_size):
-        """Extend size of existing and available VxFlex OS volume.
+        """Extend size of existing and available PowerFlex volume.
 
         This action will round up volume to nearest size that is
         granularity of 8 GBs.
@@ -800,7 +801,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         self._get_client().extend_volume(volume.provider_id, volume_new_size)
 
     def create_cloned_volume(self, volume, src_vref):
-        """Create cloned volume on VxFlex OS storage backend.
+        """Create cloned volume on PowerFlex storage backend.
 
         :param volume: volume to be created
         :param src_vref: source volume from which volume will be cloned
@@ -812,7 +813,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         return self._create_volume_from_source(volume, src_vref)
 
     def delete_volume(self, volume):
-        """Delete volume from VxFlex OS storage backend.
+        """Delete volume from PowerFlex storage backend.
 
         If volume is replicated, replication will be stopped first.
 
@@ -825,7 +826,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         self._get_client().remove_volume(volume.provider_id)
 
     def delete_snapshot(self, snapshot):
-        """Delete snapshot from VxFlex OS storage backend.
+        """Delete snapshot from PowerFlex storage backend.
 
         :param snapshot: snapshot to be deleted
         """
@@ -841,7 +842,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
     def _initialize_connection(self, vol_or_snap, connector, vol_size):
         """Initialize connection and return connection info.
 
-        VxFlex OS driver returns a driver_volume_type of 'scaleio'.
+        PowerFlex driver returns a driver_volume_type of 'scaleio'.
         """
 
         try:
@@ -891,7 +892,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
             LOG.info("Bandwidth per GB: %s.", bw_per_gb)
             if bw_per_gb is None:
                 return max_bandwidth
-            # Since VxFlex OS volumes size is in 8GB granularity
+            # Since PowerFlex volumes size is in 8GB granularity
             # and BWS limitation is in 1024 KBs granularity, we need to make
             # sure that scaled_bw_limit is in 128 granularity.
             scaled_bw_limit = (
@@ -934,7 +935,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
     def _terminate_connection(volume_or_snap, connector):
         """Terminate connection to volume or snapshot.
 
-        With VxFlex OS, snaps and volumes are terminated identically.
+        With PowerFlex, snaps and volumes are terminated identically.
         """
 
         try:
@@ -950,7 +951,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         stats = {}
 
         backend_name = self.configuration.safe_get("volume_backend_name")
-        stats["volume_backend_name"] = backend_name or "vxflexos"
+        stats["volume_backend_name"] = backend_name or "powerflex"
         stats["vendor_name"] = "Dell EMC"
         stats["driver_version"] = self.VERSION
         stats["storage_protocol"] = "scaleio"
@@ -1026,10 +1027,10 @@ class VxFlexOSDriver(driver.VolumeDriver):
         self._stats = stats
 
     def _query_pool_stats(self, domain_name, pool_name):
-        """Get VxFlex OS Storage Pool statistics.
+        """Get PowerFlex Storage Pool statistics.
 
-        :param domain_name: name of VxFlex OS Protection Domain
+        :param domain_name: name of PowerFlex Protection Domain
-        :param pool_name: name of VxFlex OS Storage Pool
+        :param pool_name: name of PowerFlex Storage Pool
         :return: total, free and provisioned capacity in GB
         """
 
@@ -1040,7 +1041,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         pool_id = client.get_storage_pool_id(domain_name, pool_name)
         props = self._get_queryable_statistics("StoragePool", pool_id)
         params = {"ids": [pool_id], "properties": props}
-        r, response = client.execute_vxflexos_post_request(url, params)
+        r, response = client.execute_powerflex_post_request(url, params)
         if r.status_code != http_client.OK:
             msg = (_("Failed to query stats for Storage Pool %s.") % pool_name)
             raise exception.VolumeBackendAPIException(data=msg)
@@ -1066,7 +1067,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
 
         if flex_utils.version_gte(client.query_rest_api_version(), "3.0"):
             return self._compute_pool_stats_v3(stats)
-        # Divide by two because VxFlex OS creates
+        # Divide by two because PowerFlex creates
         # a copy for each volume
         total_capacity_raw = flex_utils.convert_kb_to_gib(
             (stats["capacityLimitInKb"] - stats["spareCapacityInKb"]) / 2
@@ -1083,7 +1084,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         thin_capacity_allocated = stats.get("thinCapacityAllocatedInKm")
         if thin_capacity_allocated is None:
             thin_capacity_allocated = stats.get("thinCapacityAllocatedInKb", 0)
-        # Divide by two because VxFlex OS creates
+        # Divide by two because PowerFlex creates
         # a copy for each volume
         provisioned_capacity = flex_utils.convert_kb_to_gib(
             (stats["thickCapacityInUseInKb"] +
@@ -1094,7 +1095,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
 
     @staticmethod
     def _compute_pool_stats_v3(stats):
-        # in VxFlex OS 3.5 snapCapacityInUseInKb is replaced by
+        # in PowerFlex 3.5 snapCapacityInUseInKb is replaced by
         # snapshotCapacityInKb
         snap_capacity_allocated = stats.get("snapshotCapacityInKb")
         if snap_capacity_allocated is None:
@@ -1126,7 +1127,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
                                       domain_name,
                                       pool_name,
                                       secondary=False):
-        # thin volumes available since VxFlex OS 2.x
+        # thin volumes available since PowerFlex 2.x
         client = self._get_client(secondary)
 
         return flex_utils.version_gte(client.query_rest_api_version(), "2.0")
@@ -1177,14 +1178,14 @@ class VxFlexOSDriver(driver.VolumeDriver):
             else:
                 specs = {}
             for key, value in specs.items():
-                if key in self.vxflexos_qos_keys:
+                if key in self.powerflex_qos_keys:
                     qos[key] = value
         return qos
 
     def _sio_attach_volume(self, volume):
         """Call connector.connect_volume() and return the path."""
 
-        LOG.info("Call os-brick to attach VxFlex OS volume.")
+        LOG.info("Call os-brick to attach PowerFlex volume.")
         connection_properties = self._get_client().connection_properties
         connection_properties["scaleIO_volname"] = flex_utils.id_to_base64(
             volume.id
@@ -1198,7 +1199,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
     def _sio_detach_volume(self, volume):
         """Call the connector.disconnect()."""
 
-        LOG.info("Call os-brick to detach VxFlex OS volume.")
+        LOG.info("Call os-brick to detach PowerFlex volume.")
         connection_properties = self._get_client().connection_properties
         connection_properties["scaleIO_volname"] = flex_utils.id_to_base64(
             volume.id
@@ -1249,7 +1250,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
             self._sio_detach_volume(volume)
 
     def migrate_volume(self, ctxt, volume, host):
-        """Migrate VxFlex OS volume within the same backend."""
+        """Migrate PowerFlex volume within the same backend."""
 
         LOG.info("Migrate volume %(vol_id)s to %(host)s.",
                  {"vol_id": volume.id, "host": host["host"]})
@@ -1270,12 +1271,12 @@ class VxFlexOSDriver(driver.VolumeDriver):
         dst_backend = volume_utils.extract_host(host["host"], "backend")
         if src_backend != dst_backend:
             LOG.debug("Cross-backends migration is not supported "
-                      "by VxFlex OS.")
+                      "by PowerFlex.")
             return fall_back_to_host_assisted()
 
         # Check migration is supported by storage API
         if not flex_utils.version_gte(client.query_rest_api_version(), "3.0"):
-            LOG.debug("VxFlex OS versions less than v3.0 do not "
+            LOG.debug("PowerFlex versions less than v3.0 do not "
                       "support volume migration.")
             return fall_back_to_host_assisted()
 
@@ -1380,7 +1381,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
             "volTypeConversion": "NoConversion",
             "compressionMethod": "None",
             "allowDuringRebuild": six.text_type(
-                self.configuration.vxflexos_allow_migration_during_rebuild
+                self.configuration.powerflex_allow_migration_during_rebuild
             ),
         }
         storage_type = self._get_volumetype_extraspecs(volume)
@@ -1459,9 +1460,9 @@ class VxFlexOSDriver(driver.VolumeDriver):
                                volume,
                                new_volume,
                                original_volume_status):
-        """Update volume name of new VxFlex OS volume to match updated ID.
+        """Update volume name of new PowerFlex volume to match updated ID.
 
-        Original volume is renamed first since VxFlex OS does not allow
+        Original volume is renamed first since PowerFlex does not allow
         multiple volumes to have same name.
         """
 
@@ -1497,7 +1498,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         return {"_name_id": name_id, "provider_location": location}
 
     def revert_to_snapshot(self, context, volume, snapshot):
-        """Revert VxFlex OS volume to the specified snapshot."""
+        """Revert PowerFlex volume to the specified snapshot."""
 
         LOG.info("Revert volume %(vol_id)s to snapshot %(snap_id)s.",
                  {"vol_id": volume.id, "snap_id": snapshot.id})
@@ -1505,7 +1506,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         client = self._get_client()
 
         if not flex_utils.version_gte(client.query_rest_api_version(), "3.0"):
-            LOG.debug("VxFlex OS versions less than v3.0 do not "
+            LOG.debug("PowerFlex versions less than v3.0 do not "
                       "support reverting volume to snapshot. "
                       "Falling back to generic revert to snapshot method.")
             raise NotImplementedError
@@ -1523,7 +1524,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
 
         client.overwrite_volume_content(volume, snapshot)
 
-    def _query_vxflexos_volume(self, volume, existing_ref):
+    def _query_powerflex_volume(self, volume, existing_ref):
         type_id = volume.get("volume_type_id")
         if "source-id" not in existing_ref:
             reason = _("Reference must contain source-id.")
@@ -1538,14 +1539,14 @@ class VxFlexOSDriver(driver.VolumeDriver):
                 reason=reason
             )
         vol_id = existing_ref["source-id"]
-        LOG.info("Query volume %(vol_id)s with VxFlex OS id %(provider_id)s.",
+        LOG.info("Query volume %(vol_id)s with PowerFlex id %(provider_id)s.",
                  {"vol_id": volume.id, "provider_id": vol_id})
         response = self._get_client().query_volume(vol_id)
         self._manage_existing_check_legal_response(response, existing_ref)
         return response
 
-    def _get_all_vxflexos_volumes(self):
+    def _get_all_powerflex_volumes(self):
-        """Get all volumes in configured VxFlex OS Storage Pools."""
+        """Get all volumes in configured PowerFlex Storage Pools."""
 
         client = self._get_client()
         url = ("/instances/StoragePool::%(storage_pool_id)s"
@@ -1558,7 +1559,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
             domain_name = splitted_name[0]
             pool_name = splitted_name[1]
             sp_id = client.get_storage_pool_id(domain_name, pool_name)
-            r, volumes = client.execute_vxflexos_get_request(
+            r, volumes = client.execute_powerflex_get_request(
                 url,
                 storage_pool_id=sp_id
             )
@@ -1581,7 +1582,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         Return references of volume ids for any others.
         """
 
-        all_sio_volumes = self._get_all_vxflexos_volumes()
+        all_sio_volumes = self._get_all_powerflex_volumes()
         # Put together a map of existing cinder volumes on the array
         # so we can lookup cinder id's to SIO id
         existing_vols = {}
@@ -1633,28 +1634,28 @@ class VxFlexOSDriver(driver.VolumeDriver):
         return False
 
     def manage_existing(self, volume, existing_ref):
-        """Manage existing VxFlex OS volume.
+        """Manage existing PowerFlex volume.
 
         :param volume: volume to be managed
         :param existing_ref: dictionary of form
-                             {'source-id': 'id of VxFlex OS volume'}
+                             {'source-id': 'id of PowerFlex volume'}
         """
 
-        response = self._query_vxflexos_volume(volume, existing_ref)
+        response = self._query_powerflex_volume(volume, existing_ref)
         return {"provider_id": response["id"]}
 
     def manage_existing_get_size(self, volume, existing_ref):
         return self._get_volume_size(volume, existing_ref)
 
     def manage_existing_snapshot(self, snapshot, existing_ref):
-        """Manage existing VxFlex OS snapshot.
+        """Manage existing PowerFlex snapshot.
 
         :param snapshot: snapshot to be managed
         :param existing_ref: dictionary of form
-                             {'source-id': 'id of VxFlex OS snapshot'}
+                             {'source-id': 'id of PowerFlex snapshot'}
         """
 
-        response = self._query_vxflexos_volume(snapshot, existing_ref)
+        response = self._query_powerflex_volume(snapshot, existing_ref)
         not_real_parent = (response.get("orig_parent_overriden") or
                            response.get("is_source_deleted"))
         if not_real_parent:
@@ -1668,7 +1669,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         ancestor_id = response["ancestorVolumeId"]
         volume_id = snapshot.volume.provider_id
         if ancestor_id != volume_id:
-            reason = (_("Snapshot's parent in VxFlex OS is %(ancestor_id)s "
+            reason = (_("Snapshot's parent in PowerFlex is %(ancestor_id)s "
                         "and not %(vol_id)s.") %
                       {"ancestor_id": ancestor_id, "vol_id": volume_id})
             raise exception.ManageExistingInvalidReference(
@@ -1681,7 +1682,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
         return self._get_volume_size(snapshot, existing_ref)
 
     def _get_volume_size(self, volume, existing_ref):
-        response = self._query_vxflexos_volume(volume, existing_ref)
+        response = self._query_powerflex_volume(volume, existing_ref)
         return int(math.ceil(float(response["sizeInKb"]) / units.Mi))
 
     def _manage_existing_check_legal_response(self, response, existing_ref):
@@ -1705,7 +1706,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
     def create_group(self, context, group):
         """Create Consistency Group.
 
-        VxFlex OS won't create CG until cg-snapshot creation,
+        PowerFlex won't create CG until cg-snapshot creation,
         db will maintain the volumes and CG relationship.
         """
 
@@ -1719,7 +1720,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
     def delete_group(self, context, group, volumes):
         """Delete Consistency Group.
 
-        VxFlex OS will delete volumes of CG.
+        PowerFlex will delete volumes of CG.
         """
 
         # let generic volume group support handle non-cgsnapshots
@@ -1826,7 +1827,7 @@ class VxFlexOSDriver(driver.VolumeDriver):
                      remove_volumes=None):
         """Update Consistency Group.
 
-        VxFlex OS does not handle volume grouping.
+        PowerFlex does not handle volume grouping.
         Cinder maintains volumes and CG relationship.
         """
 

cinder/volume/drivers/dell_emc/powerflex/options.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Dell Inc. or its subsidiaries.
+# Copyright (c) 2017-2020 Dell Inc. or its subsidiaries.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -13,24 +13,13 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 """
-Configuration options for Dell EMC VxFlex OS (formerly
+Configuration options for Dell EMC PowerFlex (formerly
-named Dell EMC ScaleIO).
+named Dell EMC VxFlex OS).
 """
 
 from oslo_config import cfg
 
 # deprecated options
-SIO_REST_SERVER_PORT = "sio_rest_server_port"
-SIO_VERIFY_SERVER_CERTIFICATE = "sio_verify_server_certificate"
-SIO_SERVER_CERTIFICATE_PATH = "sio_server_certificate_path"
-SIO_ROUND_VOLUME_CAPACITY = "sio_round_volume_capacity"
-SIO_UNMAP_VOLUME_BEFORE_DELETION = "sio_unmap_volume_before_deletion"
-SIO_STORAGE_POOLS = "sio_storage_pools"
-SIO_SERVER_API_VERSION = "sio_server_api_version"
-SIO_MAX_OVER_SUBSCRIPTION_RATIO = "sio_max_over_subscription_ratio"
-SIO_ALLOW_NON_PADDED_VOLUMES = "sio_allow_non_padded_volumes"
-
-# actual options
 VXFLEXOS_REST_SERVER_PORT = "vxflexos_rest_server_port"
 VXFLEXOS_ROUND_VOLUME_CAPACITY = "vxflexos_round_volume_capacity"
 VXFLEXOS_UNMAP_VOLUME_BEFORE_DELETION = "vxflexos_unmap_volume_before_deletion"
@@ -39,113 +28,123 @@ VXFLEXOS_SERVER_API_VERSION = "vxflexos_server_api_version"
 VXFLEXOS_MAX_OVER_SUBSCRIPTION_RATIO = "vxflexos_max_over_subscription_ratio"
 VXFLEXOS_ALLOW_NON_PADDED_VOLUMES = "vxflexos_allow_non_padded_volumes"
 VXFLEXOS_ALLOW_MIGRATION_DURING_REBUILD = (
-    "vxflexos_allow_migration_during_rebuild"
+    "vxflexos_allow_migration_during_rebuild")
-)
+
+# actual options
+POWERFLEX_REST_SERVER_PORT = "powerflex_rest_server_port"
+POWERFLEX_ROUND_VOLUME_CAPACITY = "powerflex_round_volume_capacity"
+POWERFLEX_UNMAP_VOLUME_BEFORE_DELETION = (
+    "powerflex_unmap_volume_before_deletion")
+POWERFLEX_STORAGE_POOLS = "powerflex_storage_pools"
+POWERFLEX_SERVER_API_VERSION = "powerflex_server_api_version"
+POWERFLEX_MAX_OVER_SUBSCRIPTION_RATIO = "powerflex_max_over_subscription_ratio"
+POWERFLEX_ALLOW_NON_PADDED_VOLUMES = "powerflex_allow_non_padded_volumes"
+POWERFLEX_ALLOW_MIGRATION_DURING_REBUILD = (
+    "powerflex_allow_migration_during_rebuild")
 
 deprecated_opts = [
-    cfg.PortOpt(SIO_REST_SERVER_PORT,
+    cfg.PortOpt(VXFLEXOS_REST_SERVER_PORT,
                 default=443,
                 help='renamed to %s.' %
-                     VXFLEXOS_REST_SERVER_PORT,
+                     POWERFLEX_REST_SERVER_PORT,
                 deprecated_for_removal=True,
                 deprecated_reason='Replaced by %s.' %
-                                  VXFLEXOS_REST_SERVER_PORT),
+                                  POWERFLEX_REST_SERVER_PORT),
-    cfg.BoolOpt(SIO_VERIFY_SERVER_CERTIFICATE,
+    cfg.BoolOpt(VXFLEXOS_ROUND_VOLUME_CAPACITY,
-                default=False,
-                help='Deprecated, use driver_ssl_cert_verify instead.',
-                deprecated_for_removal=True,
-                deprecated_reason='Replaced by driver_ssl_cert_verify'),
-    cfg.StrOpt(SIO_SERVER_CERTIFICATE_PATH,
-               help='Deprecated, use driver_ssl_cert_path instead.',
-               deprecated_for_removal=True,
-               deprecated_reason='Replaced by driver_ssl_cert_path'),
-    cfg.BoolOpt(SIO_ROUND_VOLUME_CAPACITY,
                 default=True,
                 help='renamed to %s.' %
-                     VXFLEXOS_ROUND_VOLUME_CAPACITY,
+                     POWERFLEX_ROUND_VOLUME_CAPACITY,
                 deprecated_for_removal=True,
                 deprecated_reason='Replaced by %s.' %
-                                  VXFLEXOS_ROUND_VOLUME_CAPACITY),
+                                  POWERFLEX_ROUND_VOLUME_CAPACITY),
-    cfg.BoolOpt(SIO_UNMAP_VOLUME_BEFORE_DELETION,
+    cfg.BoolOpt(VXFLEXOS_UNMAP_VOLUME_BEFORE_DELETION,
                 default=False,
                 help='renamed to %s.' %
-                     VXFLEXOS_UNMAP_VOLUME_BEFORE_DELETION,
+                     POWERFLEX_ROUND_VOLUME_CAPACITY,
                 deprecated_for_removal=True,
                 deprecated_reason='Replaced by %s.' %
-                                  VXFLEXOS_UNMAP_VOLUME_BEFORE_DELETION),
+                                  POWERFLEX_ROUND_VOLUME_CAPACITY),
-    cfg.StrOpt(SIO_STORAGE_POOLS,
+    cfg.StrOpt(VXFLEXOS_STORAGE_POOLS,
                help='renamed to %s.' %
-                    VXFLEXOS_STORAGE_POOLS,
+                    POWERFLEX_STORAGE_POOLS,
                deprecated_for_removal=True,
                deprecated_reason='Replaced by %s.' %
-                                 VXFLEXOS_STORAGE_POOLS),
+                                 POWERFLEX_STORAGE_POOLS),
-    cfg.StrOpt(SIO_SERVER_API_VERSION,
+    cfg.StrOpt(VXFLEXOS_SERVER_API_VERSION,
                help='renamed to %s.' %
-                    VXFLEXOS_SERVER_API_VERSION,
+                    POWERFLEX_SERVER_API_VERSION,
                deprecated_for_removal=True,
                deprecated_reason='Replaced by %s.' %
-                                 VXFLEXOS_SERVER_API_VERSION),
+                                 POWERFLEX_SERVER_API_VERSION),
-    cfg.FloatOpt(SIO_MAX_OVER_SUBSCRIPTION_RATIO,
+    cfg.FloatOpt(VXFLEXOS_MAX_OVER_SUBSCRIPTION_RATIO,
                  # This option exists to provide a default value for the
-                 # VxFlex OS driver which is different than the global default.
+                 # PowerFlex driver which is different than the global default.
                  default=10.0,
                  help='renamed to %s.' %
-                      VXFLEXOS_MAX_OVER_SUBSCRIPTION_RATIO,
+                      POWERFLEX_MAX_OVER_SUBSCRIPTION_RATIO,
                  deprecated_for_removal=True,
                  deprecated_reason='Replaced by %s.' %
-                                   VXFLEXOS_MAX_OVER_SUBSCRIPTION_RATIO),
+                                   POWERFLEX_MAX_OVER_SUBSCRIPTION_RATIO),
-    cfg.BoolOpt(SIO_ALLOW_NON_PADDED_VOLUMES,
+    cfg.BoolOpt(VXFLEXOS_ALLOW_NON_PADDED_VOLUMES,
                 default=False,
                 help='renamed to %s.' %
-                     VXFLEXOS_ALLOW_NON_PADDED_VOLUMES,
+                     POWERFLEX_ALLOW_NON_PADDED_VOLUMES,
                 deprecated_for_removal=True,
                 deprecated_reason='Replaced by %s.' %
-                                  VXFLEXOS_ALLOW_NON_PADDED_VOLUMES),
+                                  POWERFLEX_ALLOW_NON_PADDED_VOLUMES),
+    cfg.BoolOpt(VXFLEXOS_ALLOW_MIGRATION_DURING_REBUILD,
+                default=False,
+                help='renamed to %s.' %
+                     POWERFLEX_ALLOW_MIGRATION_DURING_REBUILD,
+                deprecated_for_removal=True,
+                deprecated_reason='Replaced by %s.' %
+                                  POWERFLEX_ALLOW_MIGRATION_DURING_REBUILD),
 ]
 
 actual_opts = [
-    cfg.PortOpt(VXFLEXOS_REST_SERVER_PORT,
+    cfg.PortOpt(POWERFLEX_REST_SERVER_PORT,
                 default=443,
                 help='Gateway REST server port.',
-                deprecated_name=SIO_REST_SERVER_PORT),
+                deprecated_name=VXFLEXOS_REST_SERVER_PORT),
-    cfg.BoolOpt(VXFLEXOS_ROUND_VOLUME_CAPACITY,
+    cfg.BoolOpt(POWERFLEX_ROUND_VOLUME_CAPACITY,
                 default=True,
                 help='Round volume sizes up to 8GB boundaries. '
-                     'VxFlex OS/ScaleIO requires volumes to be sized '
+                     'PowerFlex/VxFlex OS requires volumes to be sized '
                      'in multiples of 8GB. If set to False, volume '
                      'creation will fail for volumes not sized properly',
-                deprecated_name=SIO_ROUND_VOLUME_CAPACITY
+                deprecated_name=VXFLEXOS_ROUND_VOLUME_CAPACITY
                 ),
-    cfg.BoolOpt(VXFLEXOS_UNMAP_VOLUME_BEFORE_DELETION,
+    cfg.BoolOpt(POWERFLEX_UNMAP_VOLUME_BEFORE_DELETION,
                 default=False,
                 help='Unmap volumes before deletion.',
-                deprecated_name=SIO_UNMAP_VOLUME_BEFORE_DELETION),
+                deprecated_name=VXFLEXOS_UNMAP_VOLUME_BEFORE_DELETION),
-    cfg.StrOpt(VXFLEXOS_STORAGE_POOLS,
+    cfg.StrOpt(POWERFLEX_STORAGE_POOLS,
                help='Storage Pools. Comma separated list of storage '
                     'pools used to provide volumes. Each pool should '
                     'be specified as a '
                     'protection_domain_name:storage_pool_name value',
-               deprecated_name=SIO_STORAGE_POOLS),
+               deprecated_name=VXFLEXOS_STORAGE_POOLS),
-    cfg.StrOpt(VXFLEXOS_SERVER_API_VERSION,
+    cfg.StrOpt(POWERFLEX_SERVER_API_VERSION,
-               help='VxFlex OS/ScaleIO API version. This value should be '
+               help='PowerFlex/ScaleIO API version. This value should be '
                     'left as the default value unless otherwise instructed '
                     'by technical support.',
-               deprecated_name=SIO_SERVER_API_VERSION),
+               deprecated_name=VXFLEXOS_SERVER_API_VERSION),
-    cfg.FloatOpt(VXFLEXOS_MAX_OVER_SUBSCRIPTION_RATIO,
+    cfg.FloatOpt(POWERFLEX_MAX_OVER_SUBSCRIPTION_RATIO,
                  # This option exists to provide a default value for the
-                 # VxFlex OS driver which is different than the global default.
+                 # PowerFlex driver which is different than the global default.
                  default=10.0,
                  help='max_over_subscription_ratio setting for the driver. '
                       'Maximum value allowed is 10.0.',
-                 deprecated_name=SIO_MAX_OVER_SUBSCRIPTION_RATIO),
+                 deprecated_name=VXFLEXOS_MAX_OVER_SUBSCRIPTION_RATIO),
-    cfg.BoolOpt(VXFLEXOS_ALLOW_NON_PADDED_VOLUMES,
+    cfg.BoolOpt(POWERFLEX_ALLOW_NON_PADDED_VOLUMES,
                 default=False,
                 help='Allow volumes to be created in Storage Pools '
                      'when zero padding is disabled. This option should '
                      'not be enabled if multiple tenants will utilize '
                      'volumes from a shared Storage Pool.',
-                deprecated_name=SIO_ALLOW_NON_PADDED_VOLUMES),
+                deprecated_name=VXFLEXOS_ALLOW_NON_PADDED_VOLUMES),
-    cfg.BoolOpt(VXFLEXOS_ALLOW_MIGRATION_DURING_REBUILD,
+    cfg.BoolOpt(POWERFLEX_ALLOW_MIGRATION_DURING_REBUILD,
                 default=False,
-                help='Allow volume migration during rebuild.'),
+                help='Allow volume migration during rebuild.',
+                deprecated_name=VXFLEXOS_ALLOW_MIGRATION_DURING_REBUILD),
 ]

cinder/volume/drivers/dell_emc/powerflex/rest_client.py

@@ -25,8 +25,8 @@ from six.moves import urllib
 from cinder import exception
 from cinder.i18n import _
 from cinder.utils import retry
-from cinder.volume.drivers.dell_emc.vxflexos import simplecache
+from cinder.volume.drivers.dell_emc.powerflex import simplecache
-from cinder.volume.drivers.dell_emc.vxflexos import utils as flex_utils
+from cinder.volume.drivers.dell_emc.powerflex import utils as flex_utils
 
 LOG = logging.getLogger(__name__)
 
@@ -84,7 +84,7 @@ class RestClient(object):
             if not replication_targets:
                 return
             elif len(replication_targets) > 1:
-                msg = _("VxFlex OS does not support more than one "
+                msg = _("PowerFlex does not support more than one "
                         "replication backend.")
                 raise exception.InvalidInput(reason=msg)
             get_config_value = replication_targets[0].get
@@ -94,7 +94,7 @@ class RestClient(object):
         )
         self.rest_ip = get_config_value("san_ip")
         self.rest_port = int(
-            get_config_value("vxflexos_rest_server_port") or
+            get_config_value("powerflex_rest_server_port") or
             get_config_value("sio_rest_server_port") or
             443
         )
@@ -136,7 +136,7 @@ class RestClient(object):
         url = "/version"
 
         if self.rest_api_version is None or fromcache is False:
-            r, unused = self.execute_vxflexos_get_request(url)
+            r, unused = self.execute_powerflex_get_request(url)
             if r.status_code == http_client.OK:
                 self.rest_api_version = r.text.replace('\"', "")
                 LOG.info("REST API Version: %(api_version)s.",
@@ -156,7 +156,7 @@ class RestClient(object):
     def query_volume(self, vol_id):
         url = "/instances/Volume::%(vol_id)s"
 
-        r, response = self.execute_vxflexos_get_request(url, vol_id=vol_id)
+        r, response = self.execute_powerflex_get_request(url, vol_id=vol_id)
         if r.status_code != http_client.OK and "errorCode" in response:
             msg = (_("Failed to query volume: %s.") % response["message"])
             LOG.error(msg)
@@ -188,7 +188,7 @@ class RestClient(object):
             "volumeSizeInKb": six.text_type(volume_size_kb),
             "compressionMethod": compression,
         }
-        r, response = self.execute_vxflexos_post_request(url, params)
+        r, response = self.execute_powerflex_post_request(url, params)
         if r.status_code != http_client.OK and "errorCode" in response:
             msg = (_("Failed to create volume: %s.") % response["message"])
             LOG.error(msg)
@@ -207,7 +207,7 @@ class RestClient(object):
                 },
             ],
         }
-        r, response = self.execute_vxflexos_post_request(url, params)
+        r, response = self.execute_powerflex_post_request(url, params)
         if r.status_code != http_client.OK and "errorCode" in response:
             msg = (_("Failed to create snapshot for volume %(vol_name)s: "
                      "%(response)s.") %
@@ -230,7 +230,7 @@ class RestClient(object):
             return cached_val
         encoded_rcg_name = urllib.parse.quote(rcg_name, "")
         params = {"name": encoded_rcg_name}
-        r, rcg_id = self.execute_vxflexos_post_request(url, params)
+        r, rcg_id = self.execute_powerflex_post_request(url, params)
         if not rcg_id:
             msg = (_("Replication CG with name %s wasn't found.") % rcg_id)
             LOG.error(msg)
@@ -249,7 +249,7 @@ class RestClient(object):
                             pair_id):
         url = "/instances/ReplicationPair::%(pair_id)s"
 
-        r, response = self.execute_vxflexos_get_request(url, pair_id=pair_id)
+        r, response = self.execute_powerflex_get_request(url, pair_id=pair_id)
         if r.status_code != http_client.OK and "errorCode" in response:
             msg = (_("Failed to query volumes pair %(pair_id)s: %(err)s.") %
                    {"pair_id": pair_id, "err": response["message"]})
@@ -260,7 +260,7 @@ class RestClient(object):
     def _query_replication_pairs(self):
         url = "/types/ReplicationPair/instances"
 
-        r, response = self.execute_vxflexos_get_request(url)
+        r, response = self.execute_powerflex_get_request(url)
         if r.status_code != http_client.OK and "errorCode" in response:
             msg = (_("Failed to query replication pairs: %s.") %
                    response["message"])
@@ -306,7 +306,7 @@ class RestClient(object):
             "sourceVolumeId": source_provider_id,
             "destinationVolumeId": dest_provider_id,
         }
-        r, response = self.execute_vxflexos_post_request(url, params, )
+        r, response = self.execute_powerflex_post_request(url, params, )
         if r.status_code != http_client.OK and "errorCode" in response:
             msg = (_("Failed to create volumes pair: %s.") %
                    response["message"])
@@ -325,7 +325,7 @@ class RestClient(object):
         url = ("/instances/ReplicationPair::%(vol_pair_id)s/action"
                "/removeReplicationPair")
 
-        r, response = self.execute_vxflexos_post_request(
+        r, response = self.execute_powerflex_post_request(
             url, vol_pair_id=vol_pair_id
         )
         if r.status_code != http_client.OK:
@@ -343,7 +343,7 @@ class RestClient(object):
             LOG.error(msg)
             raise exception.VolumeBackendAPIException(data=msg)
         encoded_domain_name = urllib.parse.quote(domain_name, "")
-        r, domain_id = self.execute_vxflexos_get_request(
+        r, domain_id = self.execute_powerflex_get_request(
             url, encoded_domain_name=encoded_domain_name
         )
         if not domain_id:
@@ -373,7 +373,7 @@ class RestClient(object):
         if cached_val is not None:
             return cached_val
         domain_id = self._get_protection_domain_id_by_name(domain_name)
-        r, response = self.execute_vxflexos_get_request(
+        r, response = self.execute_powerflex_get_request(
             url, domain_id=domain_id
         )
         if r.status_code != http_client.OK:
@@ -397,7 +397,7 @@ class RestClient(object):
             raise exception.VolumeBackendAPIException(data=msg)
         domain_id = self._get_protection_domain_id(domain_name)
         encoded_pool_name = urllib.parse.quote(pool_name, "")
-        r, pool_id = self.execute_vxflexos_get_request(
+        r, pool_id = self.execute_powerflex_get_request(
             url, domain_id=domain_id, encoded_pool_name=encoded_pool_name
         )
         if not pool_id:
@@ -423,7 +423,7 @@ class RestClient(object):
         if cached_val is not None:
             return cached_val
         pool_id = self._get_storage_pool_id_by_name(domain_name, pool_name)
-        r, response = self.execute_vxflexos_get_request(url, pool_id=pool_id)
+        r, response = self.execute_powerflex_get_request(url, pool_id=pool_id)
         if r.status_code != http_client.OK:
             msg = (_("Failed to get pool properties from id %(pool_id)s: "
                      "%(err_msg)s.") %
@@ -445,7 +445,7 @@ class RestClient(object):
             verify_cert = self.certificate_path
         return verify_cert
 
-    def execute_vxflexos_get_request(self, url, **url_params):
+    def execute_powerflex_get_request(self, url, **url_params):
         request = self.base_url + url % url_params
         r = requests.get(request,
                          auth=(self.rest_username, self.rest_token),
@@ -454,7 +454,7 @@ class RestClient(object):
         response = r.json()
         return r, response
 
-    def execute_vxflexos_post_request(self, url, params=None, **url_params):
+    def execute_powerflex_post_request(self, url, params=None, **url_params):
         if not params:
             params = {}
         request = self.base_url + url % url_params
@@ -527,16 +527,16 @@ class RestClient(object):
         url = "/instances/Volume::%(vol_id)s/action/setVolumeSize"
 
         round_volume_capacity = (
-            self.configuration.vxflexos_round_volume_capacity
+            self.configuration.powerflex_round_volume_capacity
         )
         if not round_volume_capacity and not new_size % 8 == 0:
-            LOG.warning("VxFlex OS only supports volumes with a granularity "
+            LOG.warning("PowerFlex only supports volumes with a granularity "
                         "of 8 GBs. The new volume size is: %d.",
                         new_size)
         params = {"sizeInGB": six.text_type(new_size)}
-        r, response = self.execute_vxflexos_post_request(url,
+        r, response = self.execute_powerflex_post_request(url,
-                                                         params,
+                                                          params,
-                                                         vol_id=vol_id)
+                                                          vol_id=vol_id)
         if r.status_code != http_client.OK:
             response = r.json()
             msg = (_("Failed to extend volume %(vol_id)s: %(err)s.") %
@@ -558,9 +558,9 @@ class RestClient(object):
         if volume_is_mapped:
             params = {"allSdcs": ""}
             LOG.info("Unmap volume from all sdcs before deletion.")
-            r, unused = self.execute_vxflexos_post_request(url,
+            r, unused = self.execute_powerflex_post_request(url,
-                                                           params,
+                                                            params,
-                                                           vol_id=vol_id)
+                                                            vol_id=vol_id)
 
     @retry(exception.VolumeBackendAPIException)
     def remove_volume(self, vol_id):
@@ -568,9 +568,9 @@ class RestClient(object):
 
         self._unmap_volume_before_delete(vol_id)
         params = {"removeMode": "ONLY_ME"}
-        r, response = self.execute_vxflexos_post_request(url,
+        r, response = self.execute_powerflex_post_request(url,
-                                                         params,
+                                                          params,
-                                                         vol_id=vol_id)
+                                                          vol_id=vol_id)
         if r.status_code != http_client.OK:
             error_code = response["errorCode"]
             if error_code == VOLUME_NOT_FOUND_ERROR:
@@ -578,7 +578,7 @@ class RestClient(object):
                             "Volume not found.", vol_id)
             elif vol_id is None:
                 LOG.warning("Volume does not have provider_id thus does not "
-                            "map to a VxFlex OS volume. "
+                            "map to PowerFlex volume. "
                             "Allowing deletion to proceed.")
             else:
                 msg = (_("Failed to delete volume %(vol_id)s: %(err)s.") %
@@ -594,7 +594,7 @@ class RestClient(object):
         """
 
         # if we have been told to allow unsafe volumes
-        if self.configuration.vxflexos_allow_non_padded_volumes:
+        if self.configuration.powerflex_allow_non_padded_volumes:
             # Enabled regardless of type, so safe to proceed
             return True
         try:
@@ -618,16 +618,16 @@ class RestClient(object):
         new_name = flex_utils.id_to_base64(name)
         vol_id = volume["provider_id"]
         params = {"newName": new_name}
-        r, response = self.execute_vxflexos_post_request(url,
+        r, response = self.execute_powerflex_post_request(url,
-                                                         params,
+                                                          params,
-                                                         id=vol_id)
+                                                          id=vol_id)
         if r.status_code != http_client.OK:
             error_code = response["errorCode"]
             if ((error_code == VOLUME_NOT_FOUND_ERROR or
                  error_code == OLD_VOLUME_NOT_FOUND_ERROR or
                  error_code == ILLEGAL_SYNTAX)):
                 LOG.info("Ignore renaming action because the volume "
-                         "%(vol_id)s is not a VxFlex OS volume.",
+                         "%(vol_id)s is not a PowerFlex volume.",
                          {"vol_id": vol_id})
             else:
                 msg = (_("Failed to rename volume %(vol_id)s: %(err)s.") %
@@ -635,7 +635,7 @@ class RestClient(object):
                 LOG.error(msg)
                 raise exception.VolumeBackendAPIException(data=msg)
         else:
-            LOG.info("VxFlex OS volume %(vol_id)s was renamed to "
+            LOG.info("PowerFlex volume %(vol_id)s was renamed to "
                      "%(new_name)s.", {"vol_id": vol_id, "new_name": new_name})
 
     def failover_failback_replication_cg(self, rcg_name, is_failback):
@@ -644,9 +644,9 @@ class RestClient(object):
 
         action = "restore" if is_failback else "failover"
         rcg_id = self._get_replication_cg_id_by_name(rcg_name)
-        r, response = self.execute_vxflexos_post_request(url,
+        r, response = self.execute_powerflex_post_request(url,
-                                                         rcg_id=rcg_id,
+                                                          rcg_id=rcg_id,
-                                                         action=action)
+                                                          action=action)
         if r.status_code != http_client.OK:
             msg = (_("Failed to %(action)s rcg with id %(rcg_id)s: "
                      "%(err_msg)s.") % {"action": action,
@@ -658,7 +658,8 @@ class RestClient(object):
     def query_vtree(self, vtree_id, vol_id):
         url = "/instances/VTree::%(vtree_id)s"
 
-        r, response = self.execute_vxflexos_get_request(url, vtree_id=vtree_id)
+        r, response = self.execute_powerflex_get_request(url,
+                                                         vtree_id=vtree_id)
         if r.status_code != http_client.OK:
             msg = (_("Failed to check migration status of volume %s.")
                    % vol_id)
@@ -669,7 +670,7 @@ class RestClient(object):
     def migrate_vtree(self, volume, params):
         url = "/instances/Volume::%(vol_id)s/action/migrateVTree"
 
-        r, response = self.execute_vxflexos_post_request(
+        r, response = self.execute_powerflex_post_request(
             url,
             params=params,
             vol_id=volume.provider_id
@@ -689,7 +690,7 @@ class RestClient(object):
         url = "/instances/Volume::%(vol_id)s/action/overwriteVolumeContent"
 
         params = {"srcVolumeId": snapshot.provider_id}
-        r, response = self.execute_vxflexos_post_request(
+        r, response = self.execute_powerflex_post_request(
             url,
             params=params,
             vol_id=volume.provider_id

cinder/volume/drivers/dell_emc/powerflex/simplecache.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2017-2019 Dell Inc. or its subsidiaries.
+# Copyright (c) 2017-2020 Dell Inc. or its subsidiaries.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -13,8 +13,8 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 """
-SimpleCache utility class for Dell EMC VxFlex OS (formerly
+SimpleCache utility class for Dell EMC PowerFlex (formerly
-named Dell EMC ScaleIO).
+named Dell EMC VxFlex OS).
 """
 
 import datetime

cinder/volume/drivers/dell_emc/powerflex/utils.py

@@ -33,7 +33,7 @@ def convert_kb_to_gib(size):
 
 def id_to_base64(_id):
     # Base64 encode the id to get a volume name less than 32 characters due
-    # to VxFlex OS limitation.
+    # to PowerFlex limitation.
     name = str(_id).replace("-", "")
     try:
         name = base64.b16decode(name.upper())
@@ -42,7 +42,7 @@ def id_to_base64(_id):
     if isinstance(name, str):
         name = name.encode()
     encoded_name = base64.b64encode(name).decode()
-    LOG.debug("Converted id %(id)s to VxFlex OS name %(name)s.",
+    LOG.debug("Converted id %(id)s to PowerFlex OS name %(name)s.",
               {"id": _id, "name": encoded_name})
     return encoded_name
 

cinder/volume/manager.py

@@ -177,8 +177,8 @@ MAPPING = {
     'cinder.volume.drivers.fujitsu.eternus_dx_iscsi.FJDXISCSIDriver':
         'cinder.volume.drivers.fujitsu.eternus_dx.eternus_dx_iscsi.'
         'FJDXISCSIDriver',
-    'cinder.volume.drivers.dell_emc.scaleio.driver.ScaleIODriver':
+    'cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver':
-        'cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver',
+        'cinder.volume.drivers.dell_emc.powerflex.driver.PowerFlexDriver',
 }
 
 

doc/source/configuration/block-storage/drivers/dell-emc-powerflex-driver.rst

@@ -1,38 +1,39 @@
-===========================================
+=================================
-Dell EMC VxFlex OS (ScaleIO) Storage driver
+Dell EMC PowerFlex Storage driver
-===========================================
+=================================
 
 Overview
 --------
 
-Dell EMC VxFlex OS (formerly named Dell EMC ScaleIO) is a software-only
+Dell EMC PowerFlex (formerly named Dell EMC ScaleIO/VxFlex OS) is a
-solution that uses existing servers local
+software-only solution that uses existing servers local
 disks and LAN to create a virtual SAN that has all of the benefits of
 external storage, but at a fraction of the cost and complexity. Using the
-driver, Block Storage hosts can connect to a VxFlex OS Storage
+driver, Block Storage hosts can connect to a PowerFlex Storage
 cluster.
 
-The Dell EMC VxFlex OS Cinder driver is designed and tested to work with
+The Dell EMC PowerFlex Cinder driver is designed and tested to work with
-both VxFlex OS and with ScaleIO. The
+both PowerFlex and with ScaleIO. The
-:ref:`configuration options <cg_configuration_options_emc>`
+:ref:`configuration options <cg_configuration_options_dellemc>`
-are identical for both VxFlex OS and ScaleIO.
+are identical for both PowerFlex and ScaleIO.
 
-.. _scaleio_docs:
+.. _powerflex_docs:
 
-Official VxFlex OS documentation
+Official PowerFlex documentation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-To find the VxFlex OS documentation:
+To find the PowerFlex documentation:
 
-#. Go to the `VxFlex OS product documentation page <https://support.emc.com/products/33925_ScaleIO/Documentation/?source=promotion>`_.
+#. Go to the `PowerFlex product documentation page <https://support.emc.com/products/33925_ScaleIO/Documentation/?source=promotion>`_.
 
-#. From the left-side panel, select the relevant VxFlex OS version.
+#. From the left-side panel, select the relevant PowerFlex version.
 
-Supported VxFlex OS and ScaleIO Versions
+Supported PowerFlex, VxFlex OS and ScaleIO Versions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The Dell EMC VxFlex OS Block Storage driver has been tested against the
+The Dell EMC PowerFlex Block Storage driver has been tested against the
-following versions of ScaleIO and VxFlex OS and found to be compatible:
+following versions of ScaleIO, VxFlex OS and PowerFlex and found to be
+compatible:
 
 * ScaleIO 2.0.x
 
@@ -42,27 +43,27 @@ following versions of ScaleIO and VxFlex OS and found to be compatible:
 
 * VxFlex OS 3.0.x
 
-* VxFlex OS 3.5.x
+* PowerFlex 3.5.x
 
-Please consult the :ref:`scaleio_docs`
+Please consult the :ref:`powerflex_docs`
 to determine supported operating systems for each version
-of VxFlex OS or ScaleIO.
+of PowerFlex, VxFlex OS or ScaleIO.
 
 Deployment prerequisites
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
-* The VxFlex OS Gateway must be installed and accessible in the network.
+* The PowerFlex Gateway must be installed and accessible in the network.
   For installation steps, refer to the Preparing the installation Manager
-  and the Gateway section in VxFlex OS Deployment Guide. See
+  and the Gateway section in PowerFlex Deployment Guide. See
-  :ref:`scaleio_docs`.
+  :ref:`powerflex_docs`.
 
-* VxFlex OS Storage Data Client (SDC) must be installed
+* PowerFlex Storage Data Client (SDC) must be installed
   on all OpenStack nodes.
 
-.. note:: Ubuntu users must follow the specific instructions in the VxFlex
+.. note:: Ubuntu users must follow the specific instructions in the PowerFlex
           OS Deployment Guide for Ubuntu environments. See the ``Deploying
-          on Ubuntu Servers`` section in VxFlex OS Deployment Guide. See
+          on Ubuntu Servers`` section in PowerFlex Deployment Guide. See
-          :ref:`scaleio_docs`.
+          :ref:`powerflex_docs`.
 
 Supported operations
 ~~~~~~~~~~~~~~~~~~~~
@@ -89,42 +90,42 @@ Supported operations
 
 * OpenStack replication v2.1 support
 
-VxFlex OS Block Storage driver configuration
+PowerFlex Block Storage driver configuration
 --------------------------------------------
 
 This section explains how to configure and connect the block storage
-nodes to a VxFlex OS storage cluster.
+nodes to a PowerFlex storage cluster.
 
 Edit the ``cinder.conf`` file by adding the configuration below under
-a new section (for example, ``[vxflexos]``) and change the ``enable_backends``
+a new section (for example, ``[powerflex]``) and change the ``enable_backends``
 setting (in the ``[DEFAULT]`` section) to include this new back end.
 The configuration file is usually located at
 ``/etc/cinder/cinder.conf``.
 
 For a configuration example, refer to the example
-:ref:`cinder.conf <cg_configuration_example_emc>`.
+:ref:`cinder.conf <cg_configuration_example_dellemc>`.
 
-VxFlex OS driver name
+PowerFlex driver name
 ~~~~~~~~~~~~~~~~~~~~~
 
 Configure the driver name by adding the following parameter:
 
 .. code-block:: ini
 
-   volume_driver = cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver
+   volume_driver = cinder.volume.drivers.dell_emc.powerflex.driver.PowerFlexDriver
 
-VxFlex OS Gateway server IP
+PowerFlex Gateway server IP
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The VxFlex OS Gateway provides a REST interface to VxFlex OS.
+The PowerFlex Gateway provides a REST interface to PowerFlex.
 
 Configure the Gateway server IP address by adding the following parameter:
 
 .. code-block:: ini
 
-   san_ip = <VxFlex OS GATEWAY IP>
+   san_ip = <PowerFlex GATEWAY IP>
 
-VxFlex OS Storage Pools
+PowerFlex Storage Pools
 ~~~~~~~~~~~~~~~~~~~~~~~
 
 Multiple Storage Pools and Protection Domains can be listed for use by
@@ -138,43 +139,43 @@ Configure the available Storage Pools by adding the following parameter:
 
 .. code-block:: ini
 
-   vxflexos_storage_pools = <Comma-separated list of protection domain:storage pool name>
+   powerflex_storage_pools = <Comma-separated list of protection domain:storage pool name>
 
-VxFlex OS user credentials
+PowerFlex user credentials
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Block Storage requires a VxFlex OS user with administrative
+Block Storage requires a PowerFlex user with administrative
 privileges. Dell EMC recommends creating a dedicated OpenStack user
 account that has an administrative user role.
 
-Refer to the VxFlex OS User Guide for details on user account management.
+Refer to the PowerFlex User Guide for details on user account management.
 
 Configure the user credentials by adding the following parameters:
 
 .. code-block:: ini
 
-   san_login = <SIO_USER>
+   san_login = <POWERFLEX_USER>
-   san_password = <SIO_PASSWD>
+   san_password = <POWERFLEX_PASSWD>
 
 Oversubscription
 ~~~~~~~~~~~~~~~~
 
 Configure the oversubscription ratio by adding the following parameter
-under the separate section for VxFlex OS:
+under the separate section for PowerFlex:
 
 .. code-block:: ini
 
-   vxflexos_max_over_subscription_ratio = <OVER_SUBSCRIPTION_RATIO>
+   powerflex_max_over_subscription_ratio = <OVER_SUBSCRIPTION_RATIO>
 
 .. note::
 
-   The default value for ``vxflexos_max_over_subscription_ratio``
+   The default value for ``powerflex_max_over_subscription_ratio``
    is 10.0.
 
 Oversubscription is calculated correctly by the Block Storage service
 only if the extra specification ``provisioning:type``
 appears in the volume type regardless of the default provisioning type.
-Maximum oversubscription value supported for VxFlex OS is 10.0.
+Maximum oversubscription value supported for PowerFlex is 10.0.
 
 Default provisioning type
 ~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -194,9 +195,9 @@ in the configuration file, as follows:
 The configuration file is usually located in
 ``/etc/cinder/cinder.conf``.
 For a configuration example, see:
-:ref:`cinder.conf <cg_configuration_example_emc>`.
+:ref:`cinder.conf <cg_configuration_example_dellemc>`.
 
-.. _cg_configuration_example_emc:
+.. _cg_configuration_example_dellemc:
 
 Configuration example
 ~~~~~~~~~~~~~~~~~~~~~
@@ -209,68 +210,68 @@ parameters as follows:
 .. code-block:: ini
 
    [DEFAULT]
-   enabled_backends = vxflexos
+   enabled_backends = powerflex
 
-   [vxflexos]
+   [powerflex]
-   volume_driver = cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver
+   volume_driver = cinder.volume.drivers.dell_emc.powerflex.driver.PowerFlexDriver
-   volume_backend_name = vxflexos
+   volume_backend_name = powerflex
    san_ip = GATEWAY_IP
-   vxflexos_storage_pools = Domain1:Pool1,Domain2:Pool2
+   powerflex_storage_pools = Domain1:Pool1,Domain2:Pool2
-   san_login = SIO_USER
+   san_login = POWERFLEX_USER
-   san_password = SIO_PASSWD
+   san_password = POWERFLEX_PASSWD
    san_thin_provision = false
 
 Connector configuration
 ~~~~~~~~~~~~~~~~~~~~~~~
 
-Before using attach/detach volume operations VxFlex OS connector must be
+Before using attach/detach volume operations PowerFlex connector must be
-properly configured. On each node where VxFlex OS SDC is installed do the
+properly configured. On each node where PowerFlex SDC is installed do the
 following:
 
-#. Create ``/opt/emc/scaleio/openstack/connector.conf`` if it does not
+#. Create ``/opt/dellemc/powerflex/openstack/connector.conf`` if it does not
    exist.
 
    .. code-block:: console
 
-     $ mkdir -p /opt/emc/scaleio/openstack
+     $ mkdir -p /opt/dellemc/powerflex/openstack
-     $ touch /opt/emc/scaleio/openstack/connector.conf
+     $ touch /opt/dellemc/powerflex/openstack/connector.conf
 
-#. For each VxFlex OS section in the ``cinder.conf`` create the same section in
+#. For each PowerFlex section in the ``cinder.conf`` create the same section in
-   the ``/opt/emc/scaleio/openstack/connector.conf`` and populate it with
+   the ``/opt/dellemc/powerflex/openstack/connector.conf`` and populate it with
    passwords. Example:
 
    .. code-block:: ini
 
-      [vxflexos]
+      [powerflex]
-      san_password = SIO_PASSWD
+      san_password = POWERFLEX_PASSWD
-      replicating_san_password = REPLICATION_SYSTEM_SIO_PASSWD # if applicable
+      replicating_san_password = REPLICATION_SYSTEM_POWERFLEX_PASSWD # if applicable
 
-      [vxflexos-new]
+      [powerflex-new]
       san_password = SIO2_PASSWD
       replicating_san_password = REPLICATION_SYSTEM_SIO2_PASSWD # if applicable
 
-.. _cg_configuration_options_emc:
+.. _cg_configuration_options_dellemc:
 
 Configuration options
 ~~~~~~~~~~~~~~~~~~~~~
 
-The VxFlex OS driver supports these configuration options:
+The PowerFlex driver supports these configuration options:
 
 .. config-table::
-   :config-target: VxFlex OS
+   :config-target: PowerFlex
 
-   cinder.volume.drivers.dell_emc.vxflexos.driver
+   cinder.volume.drivers.dell_emc.powerflex.driver
 
 Volume Types
 ------------
 
 Volume types can be used to specify characteristics of volumes allocated via
-the VxFlex OS Driver. These characteristics are defined as ``Extra Specs``
+the PowerFlex Driver. These characteristics are defined as ``Extra Specs``
 within ``Volume Types``.
 
-.. _vxflexos_pd_sp:
+.. _powerflex_pd_sp:
 
-VxFlex OS Protection Domain and Storage Pool
+PowerFlex Protection Domain and Storage Pool
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 When multiple storage pools are specified in the Cinder configuration,
@@ -280,11 +281,11 @@ requested protection_domain:storage_pool.
 
 .. code-block:: console
 
-   $ openstack volume type create vxflexos_type_1
+   $ openstack volume type create powerflex_type_1
-   $ openstack volume type set --property volume_backend_name=vxflexos vxflexos_type_1
+   $ openstack volume type set --property volume_backend_name=powerflex powerflex_type_1
-   $ openstack volume type set --property pool_name=Domain2:Pool2 vxflexos_type_1
+   $ openstack volume type set --property pool_name=Domain2:Pool2 powerflex_type_1
 
-VxFlex OS thin provisioning support
+PowerFlex thin provisioning support
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The Block Storage driver supports creation of thin-provisioned and
@@ -294,13 +295,13 @@ of the volume type, as follows:
 
 .. code-block:: console
 
-   $ openstack volume type create vxflexos_type_thick
+   $ openstack volume type create powerflex_type_thick
-   $ openstack volume type set --property provisioning:type=thick vxflexos_type_thick
+   $ openstack volume type set --property provisioning:type=thick powerflex_type_thick
 
-VxFlex OS QoS support
+PowerFlex QoS support
 ~~~~~~~~~~~~~~~~~~~~~
 
-QoS support for the VxFlex OS driver includes the ability to set the
+QoS support for the PowerFlex driver includes the ability to set the
 following capabilities:
 
 ``maxIOPS``
@@ -329,8 +330,8 @@ For example:
 .. code-block:: console
 
    $ openstack volume qos create qos-limit-iops --consumer back-end --property maxIOPS=5000
-   $ openstack volume type create vxflexos_limit_iops
+   $ openstack volume type create powerflex_limit_iops
-   $ openstack volume qos associate qos-limit-iops vxflexos_limit_iops
+   $ openstack volume qos associate qos-limit-iops powerflex_limit_iops
 
 The driver always chooses the minimum between the QoS keys value
 and the relevant calculated value of ``maxIOPSperGB`` or ``maxBWSperGB``.
@@ -338,56 +339,56 @@ and the relevant calculated value of ``maxIOPSperGB`` or ``maxBWSperGB``.
 Since the limits are per SDC, they will be applied after the volume
 is attached to an instance, and thus to a compute node/SDC.
 
-VxFlex OS compression support
+PowerFlex compression support
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Starting from version 3.0, VxFlex OS supports volume compression.
+Starting from version 3.0, PowerFlex supports volume compression.
 By default driver will create volumes without compression.
 In order to create a compressed volume, a volume type which enables
 compression support needs to be created first:
 
 .. code-block:: console
 
-   $ openstack volume type create vxflexos_compressed
+   $ openstack volume type create powerflex_compressed
-   $ openstack volume type set --property provisioning:type=compressed vxflexos_compressed
+   $ openstack volume type set --property provisioning:type=compressed powerflex_compressed
 
 If a volume with this type is scheduled to a storage pool which doesn't
 support compression, then ``thin`` provisioning will be used.
 See table below for details.
 
-+-------------------+---------------------------+--------------------+
++-------------------+----------------------------+--------------------+
-| provisioning:type |  storage pool supports compression             |
+| provisioning:type |  storage pool supports compression              |
-|                   +---------------------------+--------------------+
+|                   +----------------------------+--------------------+
-|                   | yes (VxFlex 3.0 FG pool)  |  no (other pools)  |
+|                   | yes (PowerFlex 3.0 FG pool)|  no (other pools)  |
-+===================+===========================+====================+
++===================+============================+====================+
-|   compressed      |     thin with compression |     thin           |
+|   compressed      |     thin with compression  |     thin           |
-+-------------------+---------------------------+--------------------+
++-------------------+----------------------------+--------------------+
-|   thin            |        thin               |     thin           |
+|   thin            |        thin                |     thin           |
-+-------------------+---------------------------+--------------------+
++-------------------+----------------------------+--------------------+
-|   thick           |        thin               |     thick          |
+|   thick           |        thin                |     thick          |
-+-------------------+---------------------------+--------------------+
++-------------------+----------------------------+--------------------+
-|   not set         |        thin               |     thin           |
+|   not set         |        thin                |     thin           |
-+-------------------+---------------------------+--------------------+
++-------------------+----------------------------+--------------------+
 
 .. note::
-    VxFlex 3.0 Fine Granularity storage pools don't support thick provisioned volumes.
+    PowerFlex 3.0 Fine Granularity storage pools don't support thick provisioned volumes.
 
 You can add property ``compression_support='<is> True'`` to volume type to
 limit volumes allocation only to data pools which supports compression.
 
 .. code-block:: console
 
-   $ openstack volume type set  --property compression_support='<is> True' vxflexos_compressed
+   $ openstack volume type set  --property compression_support='<is> True' powerflex_compressed
 
-VxFlex OS replication support
+PowerFlex replication support
 -----------------------------
 
-Starting from version 3.5, VxFlex OS supports volume replication.
+Starting from version 3.5, PowerFlex supports volume replication.
 
 Prerequisites
 ~~~~~~~~~~~~~
 
-* VxFlex OS replication components must be installed on source and destination
+* PowerFlex replication components must be installed on source and destination
   systems.
 
 * Source and destination systems must have the same configuration for
@@ -396,7 +397,7 @@ Prerequisites
 * Source and destination systems must be paired and have at least one
   Replication Consistency Group created.
 
-See :ref:`scaleio_docs` for instructions.
+See :ref:`powerflex_docs` for instructions.
 
 Configure replication
 ~~~~~~~~~~~~~~~~~~~~~
@@ -409,54 +410,54 @@ Configure replication
    .. code-block:: ini
 
      [DEFAULT]
-     enabled_backends = vxflexos
+     enabled_backends = powerflex
 
-     [vxflexos]
+     [powerflex]
-     volume_driver = cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver
+     volume_driver = cinder.volume.drivers.dell_emc.powerflex.driver.PowerFlexDriver
-     volume_backend_name = vxflexos
+     volume_backend_name = powerflex
      san_ip = GATEWAY_IP
-     vxflexos_storage_pools = Domain1:Pool1,Domain2:Pool2
+     powerflex_storage_pools = Domain1:Pool1,Domain2:Pool2
-     san_login = SIO_USER
+     san_login = POWERFLEX_USER
-     san_password = SIO_PASSWD
+     san_password = POWERFLEX_PASSWD
      san_thin_provision = false
-     replication_device = backend_id:vxflexos_repl,
+     replication_device = backend_id:powerflex_repl,
                           san_ip: REPLICATION_SYSTEM_GATEWAY_IP,
-                          san_login: REPLICATION_SYSTEM_SIO_USER,
+                          san_login: REPLICATION_SYSTEM_POWERFLEX_USER,
-                          san_password: REPLICATION_SYSTEM_SIO_PASSWD
+                          san_password: REPLICATION_SYSTEM_POWERFLEX_PASSWD
 
    * Only one replication device is supported for storage backend.
 
    * The following parameters are optional for replication device:
 
-     * REST API port - ``vxflexos_rest_server_port``.
+     * REST API port - ``powerflex_rest_server_port``.
 
      * SSL certificate verification - ``driver_ssl_cert_verify`` and
        ``driver_ssl_cert_path``.
 
-   For more information see :ref:`cg_configuration_options_emc`.
+   For more information see :ref:`cg_configuration_options_dellemc`.
 
 #. Create volume type for volumes with replication enabled.
 
    .. code-block:: console
 
-     $ openstack volume type create vxflexos_replicated
+     $ openstack volume type create powerflex_replicated
-     $ openstack volume type set --property replication_enabled='<is> True' vxflexos_replicated
+     $ openstack volume type set --property replication_enabled='<is> True' powerflex_replicated
 
-#. Set VxFlex OS Replication Consistency Group name for volume type.
+#. Set PowerFlex Replication Consistency Group name for volume type.
 
    .. code-block:: console
 
-     $ openstack volume type set --property vxflexos:replication_cg=<replication_cg name> \
+     $ openstack volume type set --property powerflex:replication_cg=<replication_cg name> \
-         vxflexos_replicated
+         powerflex_replicated
 
 #. Set Protection Domain and Storage Pool if multiple Protection Domains
    are specified.
 
-   VxFlex OS Replication Consistency Group is created between source and
+   PowerFlex Replication Consistency Group is created between source and
    destination Protection Domains. If more than one Protection Domain is
    specified in ``cinder.conf`` you should set ``pool_name`` property for
    volume type with appropriate Protection Domain and Storage Pool.
-   See :ref:`vxflexos_pd_sp`.
+   See :ref:`powerflex_pd_sp`.
 
 Failover host
 ~~~~~~~~~~~~~
@@ -466,7 +467,7 @@ administrator can issue the failover host command:
 
 .. code-block:: console
 
-   $ cinder failover-host cinder_host@vxflexos --backend_id vxflexos_repl
+   $ cinder failover-host cinder_host@powerflex --backend_id powerflex_repl
 
 After issuing Cinder failover-host command Cinder will switch to configured
 replication device, however to get existing instances to use this target and
@@ -484,12 +485,12 @@ failback operation using ``--backend_id default``:
 
 .. code-block:: console
 
-   $ cinder failover-host cinder_host@vxflexos --backend_id default
+   $ cinder failover-host cinder_host@powerflex --backend_id default
 
-VxFlex OS storage-assisted volume migration
+PowerFlex storage-assisted volume migration
 -------------------------------------------
 
-Starting from version 3.0, VxFlex OS supports storage-assisted volume
+Starting from version 3.0, PowerFlex supports storage-assisted volume
 migration.
 
 Known limitations
@@ -530,7 +531,7 @@ Volume migration is performed by issuing the following command:
              $ cinder reset-state --state available <volume>
 
 
-Using VxFlex OS Storage with a containerized overcloud
+Using PowerFlex Storage with a containerized overcloud
 ------------------------------------------------------
 
 #. Create a file with below contents:
@@ -539,14 +540,14 @@ Using VxFlex OS Storage with a containerized overcloud
 
       parameter_defaults:
         NovaComputeOptVolumes:
-          - /opt/emc/scaleio:/opt/emc/scaleio
+          - /opt/dellemc/powerflex:/opt/dellemc/powerflex
         CinderVolumeOptVolumes:
-          - /opt/emc/scaleio:/opt/emc/scaleio
+          - /opt/dellemc/powerflex:/opt/dellemc/powerflex
         GlanceApiOptVolumes:
-          - /opt/emc/scaleio:/opt/emc/scaleio
+          - /opt/dellemc/powerflex:/opt/dellemc/powerflex
 
 
-   Name it whatever you like, e.g. ``vxflexos_volumes.yml``.
+   Name it whatever you like, e.g. ``powerflex_volumes.yml``.
 
 #. Use ``-e`` to include this customization file to deploy command.
 

doc/source/reference/support-matrix.ini

@@ -27,8 +27,8 @@ title=Dell EMC PowerMax (2000, 8000) Storage Driver (iSCSI, FC)
 [driver.dell_emc_sc]
 title=Dell EMC SC Series Storage Driver (iSCSI, FC)
 
-[driver.dell_emc_vxflexos]
+[driver.dell_emc_powerflex]
-title=Dell EMC VxFlex OS (ScaleIO) Storage Driver (ScaleIO)
+title=Dell EMC PowerFlex (ScaleIO) Storage Driver (ScaleIO)
 
 [driver.dell_emc_unity]
 title=Dell EMC Unity Storage Driver (FC, iSCSI)
@@ -203,7 +203,7 @@ driver.dell_emc_unity=complete
 driver.dell_emc_vmax_af=complete
 driver.dell_emc_vmax_3=complete
 driver.dell_emc_vnx=complete
-driver.dell_emc_vxflexos=complete
+driver.dell_emc_powerflex=complete
 driver.dell_emc_xtremio=complete
 driver.fujitsu_eternus=complete
 driver.hpe_3par=complete
@@ -266,7 +266,7 @@ driver.dell_emc_unity=complete
 driver.dell_emc_vmax_af=complete
 driver.dell_emc_vmax_3=complete
 driver.dell_emc_vnx=complete
-driver.dell_emc_vxflexos=complete
+driver.dell_emc_powerflex=complete
 driver.dell_emc_xtremio=complete
 driver.fujitsu_eternus=complete
 driver.hpe_3par=complete
@@ -329,7 +329,7 @@ driver.dell_emc_unity=complete
 driver.dell_emc_vmax_af=missing
 driver.dell_emc_vmax_3=missing
 driver.dell_emc_vnx=complete
-driver.dell_emc_vxflexos=complete
+driver.dell_emc_powerflex=complete
 driver.dell_emc_xtremio=missing
 driver.fujitsu_eternus=missing
 driver.hpe_3par=missing
@@ -395,7 +395,7 @@ driver.dell_emc_unity=complete
 driver.dell_emc_vmax_af=complete
 driver.dell_emc_vmax_3=complete
 driver.dell_emc_vnx=complete
-driver.dell_emc_vxflexos=complete
+driver.dell_emc_powerflex=complete
 driver.dell_emc_xtremio=missing
 driver.fujitsu_eternus=missing
 driver.hpe_3par=complete
@@ -460,7 +460,7 @@ driver.dell_emc_unity=complete
 driver.dell_emc_vmax_af=complete
 driver.dell_emc_vmax_3=complete
 driver.dell_emc_vnx=complete
-driver.dell_emc_vxflexos=complete
+driver.dell_emc_powerflex=complete
 driver.dell_emc_xtremio=missing
 driver.fujitsu_eternus=missing
 driver.hpe_3par=complete
@@ -526,7 +526,7 @@ driver.dell_emc_unity=complete
 driver.dell_emc_vmax_af=complete
 driver.dell_emc_vmax_3=complete
 driver.dell_emc_vnx=complete
-driver.dell_emc_vxflexos=complete
+driver.dell_emc_powerflex=complete
 driver.dell_emc_xtremio=complete
 driver.fujitsu_eternus=missing
 driver.hpe_3par=complete
@@ -591,7 +591,7 @@ driver.dell_emc_unity=complete
 driver.dell_emc_vmax_af=complete
 driver.dell_emc_vmax_3=complete
 driver.dell_emc_vnx=complete
-driver.dell_emc_vxflexos=complete
+driver.dell_emc_powerflex=complete
 driver.dell_emc_xtremio=complete
 driver.fujitsu_eternus=complete
 driver.hpe_3par=complete
@@ -657,7 +657,7 @@ driver.dell_emc_unity=complete
 driver.dell_emc_vmax_af=complete
 driver.dell_emc_vmax_3=complete
 driver.dell_emc_vnx=complete
-driver.dell_emc_vxflexos=complete
+driver.dell_emc_powerflex=complete
 driver.dell_emc_xtremio=missing
 driver.fujitsu_eternus=missing
 driver.hpe_3par=missing
@@ -723,7 +723,7 @@ driver.dell_emc_unity=complete
 driver.dell_emc_vmax_af=complete
 driver.dell_emc_vmax_3=complete
 driver.dell_emc_vnx=missing
-driver.dell_emc_vxflexos=complete
+driver.dell_emc_powerflex=complete
 driver.dell_emc_xtremio=complete
 driver.fujitsu_eternus=missing
 driver.hpe_3par=complete
@@ -786,7 +786,7 @@ driver.dell_emc_unity=complete
 driver.dell_emc_vmax_af=complete
 driver.dell_emc_vmax_3=complete
 driver.dell_emc_vnx=complete
-driver.dell_emc_vxflexos=complete
+driver.dell_emc_powerflex=complete
 driver.dell_emc_xtremio=missing
 driver.fujitsu_eternus=missing
 driver.hpe_3par=complete
@@ -853,7 +853,7 @@ driver.dell_emc_unity=missing
 driver.dell_emc_vmax_af=missing
 driver.dell_emc_vmax_3=missing
 driver.dell_emc_vnx=missing
-driver.dell_emc_vxflexos=missing
+driver.dell_emc_powerflex=missing
 driver.dell_emc_xtremio=missing
 driver.fujitsu_eternus=missing
 driver.hpe_3par=missing

releasenotes/notes/vxflexos-powerflex-rebrand-37dfe2b82d35b6a2.yaml

@@ -0,0 +1,14 @@
+---
+upgrade:
+  - |
+    Dell EMC VxFlex OS has been rebranded to PowerFlex. The drivers
+    ``cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver``
+    will now be updated to
+    ``cinder.volume.drivers.dell_emc.powerflex.driver.PowerFlexDriver``
+    in cinder.conf. Driver configuration options that start with ``vxflexos``
+    should also be updated to ``powerflex``. Existing vxFlex OS configuration
+    options will continue to work but will be removed in the W release.
+    The previously deprecated driver
+    ``cinder.volume.drivers.dell_emc.scaleio.driver.ScaleIODriver``
+    and the corresponding sio options will now be removed.
+    Online documentation will also change to reflect these changes.