openstack/cinder
Code Issues Proposed changes

rename ScaleIO driver to VxFlex OS

Browse Source 
Rename ScaleIO driver to VxFlex OS and move it to
another location. Change configuration options names.

Change-Id: I9fc2ac1ea0945c7e38971db3d83dfd9fe6f6b422
Implements: blueprint scaleio-vxflexos-rebrand
This commit is contained in:
Yury Kulazhenkov 2019-01-30 18:24:09 +03:00 committed by Yury Kulazhenkov
parent 6077b33389
commit 0eaca453bc
26 changed files with 462 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cinder/opts.py
View File

@ -79,12 +79,12 @@ from cinder.volume.drivers.dell_emc import ps as \
cinder_volume_drivers_dell_emc_ps cinder_volume_drivers_dell_emc_ps
from cinder.volume.drivers.dell_emc.sc import storagecenter_common as \ from cinder.volume.drivers.dell_emc.sc import storagecenter_common as \
cinder_volume_drivers_dell_emc_sc_storagecentercommon cinder_volume_drivers_dell_emc_sc_storagecentercommon
from cinder.volume.drivers.dell_emc.scaleio import driver as \
cinder_volume_drivers_dell_emc_scaleio_driver
from cinder.volume.drivers.dell_emc.unity import driver as \ from cinder.volume.drivers.dell_emc.unity import driver as \
cinder_volume_drivers_dell_emc_unity_driver cinder_volume_drivers_dell_emc_unity_driver
from cinder.volume.drivers.dell_emc.vnx import common as \ from cinder.volume.drivers.dell_emc.vnx import common as \
cinder_volume_drivers_dell_emc_vnx_common 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 \ from cinder.volume.drivers.dell_emc import xtremio as \
cinder_volume_drivers_dell_emc_xtremio cinder_volume_drivers_dell_emc_xtremio
from cinder.volume.drivers import drbdmanagedrv as \ from cinder.volume.drivers import drbdmanagedrv as \
@ -293,9 +293,9 @@ def list_opts():
cinder_volume_drivers_dell_emc_ps.eqlx_opts, cinder_volume_drivers_dell_emc_ps.eqlx_opts,
cinder_volume_drivers_dell_emc_sc_storagecentercommon. cinder_volume_drivers_dell_emc_sc_storagecentercommon.
common_opts, common_opts,
cinder_volume_drivers_dell_emc_scaleio_driver.scaleio_opts,
cinder_volume_drivers_dell_emc_unity_driver.UNITY_OPTS, cinder_volume_drivers_dell_emc_unity_driver.UNITY_OPTS,
cinder_volume_drivers_dell_emc_vnx_common.VNX_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_dell_emc_xtremio.XTREMIO_OPTS,
cinder_volume_drivers_drbdmanagedrv.drbd_opts, cinder_volume_drivers_drbdmanagedrv.drbd_opts,
cinder_volume_drivers_fujitsu_eternus_dx_eternusdxcommon. cinder_volume_drivers_fujitsu_eternus_dx_eternusdxcommon.

22
cinder/tests/unit/volume/drivers/dell_emc/scaleio/__init__.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/__init__.py
View File

@ -17,9 +17,9 @@ import requests
import six import six
from cinder import test from cinder import test
from cinder.tests.unit.volume.drivers.dell_emc.scaleio import mocks from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
from cinder.volume import configuration as conf from cinder.volume import configuration as conf
from cinder.volume.drivers.dell_emc.scaleio import driver from cinder.volume.drivers.dell_emc.vxflexos import driver
class CustomResponseMode(object): class CustomResponseMode(object):
@ -61,8 +61,8 @@ class CustomResponseMode(object):
self.test_instance.HTTPS_MOCK_RESPONSES = self.current_responses self.test_instance.HTTPS_MOCK_RESPONSES = self.current_responses
class TestScaleIODriver(test.TestCase): class TestVxFlexOSDriver(test.TestCase):
"""Base ``TestCase`` subclass for the ``ScaleIODriver``""" """Base ``TestCase`` subclass for the ``VxFlexOSDriver``"""
RESPONSE_MODE = type(str('ResponseMode'), (object, ), dict( RESPONSE_MODE = type(str('ResponseMode'), (object, ), dict(
Valid='0', Valid='0',
Invalid='1', Invalid='1',
@ -114,15 +114,15 @@ class TestScaleIODriver(test.TestCase):
def setUp(self): def setUp(self):
"""Setup a test case environment. """Setup a test case environment.
Creates a ``ScaleIODriver`` instance Creates a ``VxFlexOSDriver`` instance
Mocks the ``requests.get/post`` methods to return Mocks the ``requests.get/post`` methods to return
``MockHTTPSResponse``'s instead. ``MockHTTPSResponse``'s instead.
""" """
super(TestScaleIODriver, self).setUp() super(TestVxFlexOSDriver, self).setUp()
self.configuration = conf.Configuration(driver.scaleio_opts, self.configuration = conf.Configuration(driver.vxflexos_opts,
conf.SHARED_CONF_GROUP) conf.SHARED_CONF_GROUP)
self._set_overrides() self._set_overrides()
self.driver = mocks.ScaleIODriver(configuration=self.configuration) self.driver = mocks.VxFlexOSDriver(configuration=self.configuration)
self.mock_object(requests, 'get', self.do_request) self.mock_object(requests, 'get', self.do_request)
self.mock_object(requests, 'post', self.do_request) self.mock_object(requests, 'post', self.do_request)
@ -131,7 +131,7 @@ class TestScaleIODriver(test.TestCase):
# Override the defaults to fake values # Override the defaults to fake values
self.override_config('san_ip', override='127.0.0.1', self.override_config('san_ip', override='127.0.0.1',
group=conf.SHARED_CONF_GROUP) group=conf.SHARED_CONF_GROUP)
self.override_config('sio_rest_server_port', override='8888', self.override_config('vxflexos_rest_server_port', override='8888',
group=conf.SHARED_CONF_GROUP) group=conf.SHARED_CONF_GROUP)
self.override_config('san_login', override='test', self.override_config('san_login', override='test',
group=conf.SHARED_CONF_GROUP) group=conf.SHARED_CONF_GROUP)
@ -143,12 +143,12 @@ class TestScaleIODriver(test.TestCase):
self.override_config('sio_protection_domain_id', self.override_config('sio_protection_domain_id',
override=self.PROT_DOMAIN_ID, override=self.PROT_DOMAIN_ID,
group=conf.SHARED_CONF_GROUP) group=conf.SHARED_CONF_GROUP)
self.override_config('sio_storage_pools', self.override_config('vxflexos_storage_pools',
override='PD1:SP1', override='PD1:SP1',
group=conf.SHARED_CONF_GROUP) group=conf.SHARED_CONF_GROUP)
self.override_config('max_over_subscription_ratio', self.override_config('max_over_subscription_ratio',
override=5.0, group=conf.SHARED_CONF_GROUP) override=5.0, group=conf.SHARED_CONF_GROUP)
self.override_config('sio_server_api_version', self.override_config('vxflexos_server_api_version',
override='2.0.0', group=conf.SHARED_CONF_GROUP) override='2.0.0', group=conf.SHARED_CONF_GROUP)
def do_request(self, url, *args, **kwargs): def do_request(self, url, *args, **kwargs):

6
cinder/tests/unit/volume/drivers/dell_emc/scaleio/mocks.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/mocks.py
View File

@ -18,13 +18,13 @@ import six
from oslo_config import cfg from oslo_config import cfg
from cinder.volume.drivers.dell_emc.scaleio import driver from cinder.volume.drivers.dell_emc.vxflexos import driver
CONF = cfg.CONF CONF = cfg.CONF
class ScaleIODriver(driver.ScaleIODriver): class VxFlexOSDriver(driver.VxFlexOSDriver):
"""Mock ScaleIO Driver class. """Mock VxFlex OS Driver class.
Provides some fake configuration options Provides some fake configuration options
""" """

4
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_attach_detach_volume.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_attach_detach_volume.py
View File

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

8
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_create_cloned_volume.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_create_cloned_volume.py
View File

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

8
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_create_snapshot.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_create_snapshot.py
View File

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

6
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_create_volume.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_create_volume.py
View File

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

8
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_create_volume_from_snapshot.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_create_volume_from_snapshot.py
View File

@ -20,12 +20,12 @@ from cinder import context
from cinder import exception from cinder import exception
from cinder.tests.unit import fake_snapshot from cinder.tests.unit import fake_snapshot
from cinder.tests.unit import fake_volume from cinder.tests.unit import fake_volume
from cinder.tests.unit.volume.drivers.dell_emc import scaleio from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
from cinder.tests.unit.volume.drivers.dell_emc.scaleio import mocks from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
class TestCreateVolumeFromSnapShot(scaleio.TestScaleIODriver): class TestCreateVolumeFromSnapShot(vxflexos.TestVxFlexOSDriver):
"""Test cases for ``ScaleIODriver.create_volume_from_snapshot()``""" """Test cases for ``VxFlexOSDriver.create_volume_from_snapshot()``"""
def setUp(self): def setUp(self):
"""Setup a test case environment. """Setup a test case environment.

10
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_delete_snapshot.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_delete_snapshot.py
View File

@ -18,13 +18,13 @@ from cinder import context
from cinder import exception from cinder import exception
from cinder.tests.unit import fake_constants as fake from cinder.tests.unit import fake_constants as fake
from cinder.tests.unit.fake_snapshot import fake_snapshot_obj from cinder.tests.unit.fake_snapshot import fake_snapshot_obj
from cinder.tests.unit.volume.drivers.dell_emc import scaleio from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
from cinder.tests.unit.volume.drivers.dell_emc.scaleio import mocks from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
from cinder.volume import configuration from cinder.volume import configuration
class TestDeleteSnapShot(scaleio.TestScaleIODriver): class TestDeleteSnapShot(vxflexos.TestVxFlexOSDriver):
"""Test cases for ``ScaleIODriver.delete_snapshot()``""" """Test cases for ``VxFlexOSDriver.delete_snapshot()``"""
def setUp(self): def setUp(self):
"""Setup a test case environment. """Setup a test case environment.
@ -89,7 +89,7 @@ class TestDeleteSnapShot(scaleio.TestScaleIODriver):
def test_delete_snapshot(self): def test_delete_snapshot(self):
"""Setting the unmap volume before delete flag for tests """ """Setting the unmap volume before delete flag for tests """
self.override_config('sio_unmap_volume_before_deletion', True, self.override_config('vxflexos_unmap_volume_before_deletion', True,
configuration.SHARED_CONF_GROUP) configuration.SHARED_CONF_GROUP)
self.set_https_response_mode(self.RESPONSE_MODE.Valid) self.set_https_response_mode(self.RESPONSE_MODE.Valid)
self.driver.delete_snapshot(self.snapshot) self.driver.delete_snapshot(self.snapshot)

10
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_delete_volume.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_delete_volume.py
View File

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

14
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_extend_volume.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_extend_volume.py
View File

@ -18,16 +18,16 @@ from cinder import context
from cinder import exception from cinder import exception
from cinder.tests.unit import fake_constants as fake from cinder.tests.unit import fake_constants as fake
from cinder.tests.unit.fake_volume import fake_volume_obj from cinder.tests.unit.fake_volume import fake_volume_obj
from cinder.tests.unit.volume.drivers.dell_emc import scaleio from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
from cinder.tests.unit.volume.drivers.dell_emc.scaleio import mocks from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
from cinder.volume import configuration from cinder.volume import configuration
class TestExtendVolume(scaleio.TestScaleIODriver): class TestExtendVolume(vxflexos.TestVxFlexOSDriver):
"""Test cases for ``ScaleIODriver.extend_volume()``""" """Test cases for ``VxFlexOSDriver.extend_volume()``"""
""" New sizes for the volume. """ New sizes for the volume.
Since ScaleIO has a granularity of 8 GB, multiples of 8 always work. Since VxFlex OS 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 The 7 size should be either rounded up to 8 or raise an exception
based on the round_volume_capacity config setting. based on the round_volume_capacity config setting.
""" """
@ -92,13 +92,13 @@ class TestExtendVolume(scaleio.TestScaleIODriver):
self.NEW_SIZE) self.NEW_SIZE)
def test_extend_volume_bad_size_no_round(self): def test_extend_volume_bad_size_no_round(self):
self.override_config('sio_round_volume_capacity', False, self.override_config('vxflexos_round_volume_capacity', False,
configuration.SHARED_CONF_GROUP) configuration.SHARED_CONF_GROUP)
self.set_https_response_mode(self.RESPONSE_MODE.Valid) self.set_https_response_mode(self.RESPONSE_MODE.Valid)
self.driver.extend_volume(self.volume, self.BAD_SIZE) self.driver.extend_volume(self.volume, self.BAD_SIZE)
def test_extend_volume_bad_size_round(self): def test_extend_volume_bad_size_round(self):
self.override_config('sio_round_volume_capacity', True, self.override_config('vxflexos_round_volume_capacity', True,
configuration.SHARED_CONF_GROUP) configuration.SHARED_CONF_GROUP)
self.driver.extend_volume(self.volume, self.BAD_SIZE) self.driver.extend_volume(self.volume, self.BAD_SIZE)

40
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_get_manageable.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_get_manageable.py
View File

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

8
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_groups.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_groups.py
View File

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

4
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_initialize_connection.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_initialize_connection.py
View File

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

6
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_initialize_connection_snapshot.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_initialize_connection_snapshot.py
View File

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

8
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_manage_existing.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_manage_existing.py
View File

@ -17,15 +17,15 @@ from cinder import context
from cinder import exception from cinder import exception
from cinder.tests.unit import fake_constants as fake from cinder.tests.unit import fake_constants as fake
from cinder.tests.unit import fake_volume from cinder.tests.unit import fake_volume
from cinder.tests.unit.volume.drivers.dell_emc import scaleio from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
from cinder.tests.unit.volume.drivers.dell_emc.scaleio import mocks from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
from cinder.volume import volume_types from cinder.volume import volume_types
from mock import patch from mock import patch
from six.moves import urllib from six.moves import urllib
class TestManageExisting(scaleio.TestScaleIODriver): class TestManageExisting(vxflexos.TestVxFlexOSDriver):
"""Test cases for ``ScaleIODriver.manage_existing()``""" """Test cases for ``VxFlexOSDriver.manage_existing()``"""
def setUp(self): def setUp(self):
"""Setup a test case environment. """Setup a test case environment.

8
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_manage_existing_snapshot.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_manage_existing_snapshot.py
View File

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

16
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_misc.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_misc.py
View File

@ -20,13 +20,13 @@ from cinder import context
from cinder import exception from cinder import exception
from cinder.tests.unit import fake_constants as fake from cinder.tests.unit import fake_constants as fake
from cinder.tests.unit import fake_volume from cinder.tests.unit import fake_volume
from cinder.tests.unit.volume.drivers.dell_emc import scaleio from cinder.tests.unit.volume.drivers.dell_emc import vxflexos
from cinder.tests.unit.volume.drivers.dell_emc.scaleio import mocks from cinder.tests.unit.volume.drivers.dell_emc.vxflexos import mocks
from cinder.volume import configuration from cinder.volume import configuration
@ddt.ddt @ddt.ddt
class TestMisc(scaleio.TestScaleIODriver): class TestMisc(vxflexos.TestVxFlexOSDriver):
DOMAIN_ID = '1' DOMAIN_ID = '1'
POOL_ID = '1' POOL_ID = '1'
@ -159,7 +159,7 @@ class TestMisc(scaleio.TestScaleIODriver):
self.driver._check_volume_size(1) self.driver._check_volume_size(1)
def test_volume_size_round_false(self): def test_volume_size_round_false(self):
self.override_config('sio_round_volume_capacity', False, self.override_config('vxflexos_round_volume_capacity', False,
configuration.SHARED_CONF_GROUP) configuration.SHARED_CONF_GROUP)
self.assertRaises(exception.VolumeBackendAPIException, self.assertRaises(exception.VolumeBackendAPIException,
self.driver._check_volume_size, 1) self.driver._check_volume_size, 1)
@ -243,7 +243,7 @@ class TestMisc(scaleio.TestScaleIODriver):
self.driver.get_volume_stats(True) self.driver.get_volume_stats(True)
@mock.patch( @mock.patch(
'cinder.volume.drivers.dell_emc.scaleio.driver.ScaleIODriver.' 'cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver.'
'_rename_volume', '_rename_volume',
return_value=None) return_value=None)
def test_update_migrated_volume(self, mock_rename): def test_update_migrated_volume(self, mock_rename):
@ -254,7 +254,7 @@ class TestMisc(scaleio.TestScaleIODriver):
test_vol) test_vol)
@mock.patch( @mock.patch(
'cinder.volume.drivers.dell_emc.scaleio.driver.ScaleIODriver.' 'cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver.'
'_rename_volume', '_rename_volume',
return_value=None) return_value=None)
def test_update_unavailable_migrated_volume(self, mock_rename): def test_update_unavailable_migrated_volume(self, mock_rename):
@ -266,7 +266,7 @@ class TestMisc(scaleio.TestScaleIODriver):
test_vol) test_vol)
@mock.patch( @mock.patch(
'cinder.volume.drivers.dell_emc.scaleio.driver.ScaleIODriver.' 'cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver.'
'_rename_volume', '_rename_volume',
side_effect=exception.VolumeBackendAPIException(data='Error!')) side_effect=exception.VolumeBackendAPIException(data='Error!'))
def test_fail_update_migrated_volume(self, mock_rename): def test_fail_update_migrated_volume(self, mock_rename):
@ -309,7 +309,7 @@ class TestMisc(scaleio.TestScaleIODriver):
expected_provisioning_type): expected_provisioning_type):
self.override_config('san_thin_provision', config_provisioning_type, self.override_config('san_thin_provision', config_provisioning_type,
configuration.SHARED_CONF_GROUP) configuration.SHARED_CONF_GROUP)
self.driver = mocks.ScaleIODriver(configuration=self.configuration) self.driver = mocks.VxFlexOSDriver(configuration=self.configuration)
empty_storage_type = {} empty_storage_type = {}
self.assertEqual( self.assertEqual(
expected_provisioning_type, expected_provisioning_type,

6
cinder/tests/unit/volume/drivers/dell_emc/scaleio/test_versions.py → cinder/tests/unit/volume/drivers/dell_emc/vxflexos/test_versions.py
View File

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

0
cinder/volume/drivers/dell_emc/scaleio/__init__.py → cinder/volume/drivers/dell_emc/vxflexos/__init__.py
View File

336
cinder/volume/drivers/dell_emc/scaleio/driver.py → cinder/volume/drivers/dell_emc/vxflexos/driver.py
View File

@ -1,4 +1,4 @@
# Copyright (c) 2017 Dell Inc. or its subsidiaries. # Copyright (c) 2017-2019 Dell Inc. or its subsidiaries.
# All Rights Reserved. # All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # 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 # License for the specific language governing permissions and limitations
# under the License. # under the License.
""" """
Driver for Dell EMC ScaleIO based on ScaleIO remote CLI. Driver for Dell EMC VxFlex OS (formerly named Dell EMC ScaleIO).
""" """
import base64 import base64
@ -43,79 +43,21 @@ from cinder.objects import fields
from cinder import utils from cinder import utils
from cinder.volume import configuration from cinder.volume import configuration
from cinder.volume import driver from cinder.volume import driver
from cinder.volume.drivers.dell_emc.scaleio import simplecache from cinder.volume.drivers.dell_emc.vxflexos import options
from cinder.volume.drivers.dell_emc.vxflexos import simplecache
from cinder.volume.drivers.san import san from cinder.volume.drivers.san import san
from cinder.volume import qos_specs from cinder.volume import qos_specs
from cinder.volume import utils as volume_utils from cinder.volume import utils as volume_utils
from cinder.volume import volume_types from cinder.volume import volume_types
CONF = cfg.CONF CONF = cfg.CONF
vxflexos_opts = options.deprecated_opts + options.actual_opts
CONF.register_opts(vxflexos_opts, group=configuration.SHARED_CONF_GROUP)
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
scaleio_opts = [
cfg.StrOpt('sio_rest_server_port',
default='443',
help='Gateway REST server port.'),
cfg.BoolOpt('sio_verify_server_certificate',
default=False,
help='Verify server certificate.'),
cfg.StrOpt('sio_server_certificate_path',
help='Server certificate path.'),
cfg.BoolOpt('sio_round_volume_capacity',
default=True,
help='Round volume sizes up to 8GB boundaries. '
'VxFlex OS/ScaleIO requires volumes to be sized '
'in multiples of 8GB. If set to False, volume '
'creation will fail for volumes not sized properly'),
cfg.BoolOpt('sio_unmap_volume_before_deletion',
default=False,
help='Unmap volumes before deletion.'),
cfg.StrOpt('sio_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'),
cfg.StrOpt('sio_protection_domain_id',
deprecated_for_removal=True,
deprecated_reason="Replaced by sio_storage_pools option",
deprecated_since="Pike",
help='DEPRECATED: Protection Domain ID.'),
cfg.StrOpt('sio_protection_domain_name',
deprecated_for_removal=True,
deprecated_reason="Replaced by sio_storage_pools option",
deprecated_since="Pike",
help='DEPRECATED: Protection Domain name.'),
cfg.StrOpt('sio_storage_pool_name',
deprecated_for_removal=True,
deprecated_reason="Replaced by sio_storage_pools option",
deprecated_since="Pike",
help='DEPRECATED: Storage Pool name.'),
cfg.StrOpt('sio_storage_pool_id',
deprecated_for_removal=True,
deprecated_reason="Replaced by sio_storage_pools option",
deprecated_since="Pike",
help='DEPRECATED: Storage Pool ID.'),
cfg.StrOpt('sio_server_api_version',
help='VxFlex OS/ScaleIO API version. This value should be '
'left as the default value unless otherwise instructed '
'by technical support.'),
cfg.FloatOpt('sio_max_over_subscription_ratio',
# This option exists to provide a default value for the
# ScaleIO 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.'),
cfg.BoolOpt('sio_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.'),
]
CONF.register_opts(scaleio_opts, group=configuration.SHARED_CONF_GROUP)
STORAGE_POOL_NAME = 'sio:sp_name' STORAGE_POOL_NAME = 'sio:sp_name'
STORAGE_POOL_ID = 'sio:sp_id' STORAGE_POOL_ID = 'sio:sp_id'
@ -132,37 +74,38 @@ QOS_BANDWIDTH_PER_GB = 'maxBWSperGB'
BLOCK_SIZE = 8 BLOCK_SIZE = 8
VOLUME_NOT_FOUND_ERROR = 79 VOLUME_NOT_FOUND_ERROR = 79
# This code belongs to older versions of ScaleIO # This code belongs to older versions of VxFlex OS
OLD_VOLUME_NOT_FOUND_ERROR = 78 OLD_VOLUME_NOT_FOUND_ERROR = 78
VOLUME_NOT_MAPPED_ERROR = 84 VOLUME_NOT_MAPPED_ERROR = 84
ILLEGAL_SYNTAX = 0 ILLEGAL_SYNTAX = 0
VOLUME_ALREADY_MAPPED_ERROR = 81 VOLUME_ALREADY_MAPPED_ERROR = 81
MIN_BWS_SCALING_SIZE = 128 MIN_BWS_SCALING_SIZE = 128
SIO_MAX_OVERSUBSCRIPTION_RATIO = 10.0 VXFLEXOS_MAX_OVERSUBSCRIPTION_RATIO = 10.0
@interface.volumedriver @interface.volumedriver
class ScaleIODriver(driver.VolumeDriver): class VxFlexOSDriver(driver.VolumeDriver):
"""Cinder ScaleIO Driver """Cinder VxFlex OS(formerly named Dell EMC ScaleIO) Driver
.. code-block:: none .. code-block:: none
ScaleIO Driver version history: Version history:
2.0.1: Added support for SIO 1.3x in addition to 2.0.x 2.0.1 - Added support for SIO 1.3x in addition to 2.0.x
2.0.2: Added consistency group support to generic volume groups 2.0.2 - Added consistency group support to generic volume groups
2.0.3: Added cache for storage pool and protection domains info 2.0.3 - Added cache for storage pool and protection domains info
2.0.4: Added compatibility with os_brick>1.15.3 2.0.4 - Added compatibility with os_brick>1.15.3
2.0.5 - Change driver name, rename config file options
""" """
VERSION = "2.0.4" VERSION = "2.0.5"
# ThirdPartySystems wiki # ThirdPartySystems wiki
CI_WIKI_NAME = "DELL_EMC_ScaleIO_CI" CI_WIKI_NAME = "DELL_EMC_ScaleIO_CI"
scaleio_qos_keys = (QOS_IOPS_LIMIT_KEY, QOS_BANDWIDTH_LIMIT, vxflexos_qos_keys = (QOS_IOPS_LIMIT_KEY, QOS_BANDWIDTH_LIMIT,
QOS_IOPS_PER_GB, QOS_BANDWIDTH_PER_GB) QOS_IOPS_PER_GB, QOS_BANDWIDTH_PER_GB)
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super(ScaleIODriver, self).__init__(*args, **kwargs) super(VxFlexOSDriver, self).__init__(*args, **kwargs)
# simple caches for PD and SP properties # simple caches for PD and SP properties
self.spCache = simplecache.SimpleCache("Storage Pool", self.spCache = simplecache.SimpleCache("Storage Pool",
@ -171,21 +114,26 @@ class ScaleIODriver(driver.VolumeDriver):
age_minutes=5) age_minutes=5)
self.configuration.append_config_values(san.san_opts) self.configuration.append_config_values(san.san_opts)
self.configuration.append_config_values(scaleio_opts) self.configuration.append_config_values(vxflexos_opts)
self.server_ip = self.configuration.san_ip self.server_ip = self.configuration.san_ip
self.server_port = self.configuration.sio_rest_server_port self.server_port = self.configuration.vxflexos_rest_server_port
self.server_username = self.configuration.san_login self.server_username = self.configuration.san_login
self.server_password = self.configuration.san_password self.server_password = self.configuration.san_password
self.server_token = None self.server_token = None
self.server_api_version = self.configuration.sio_server_api_version self.server_api_version = (
self.configuration.vxflexos_server_api_version)
# list of statistics/properties to query from SIO # list of statistics/properties to query from SIO
self.statisticProperties = None self.statisticProperties = None
self.verify_server_certificate = ( self.verify_server_certificate = (
self.configuration.sio_verify_server_certificate) self.configuration.safe_get("sio_verify_server_certificate") or
self.configuration.safe_get("driver_ssl_cert_verify"))
self.server_certificate_path = None self.server_certificate_path = None
if self.verify_server_certificate: if self.verify_server_certificate:
self.server_certificate_path = ( self.server_certificate_path = (
self.configuration.sio_server_certificate_path) self.configuration.safe_get(
"sio_server_certificate_path") or
self.configuration.safe_get(
"driver_ssl_cert_path"))
LOG.info("REST server IP: %(ip)s, port: %(port)s, username: %(" LOG.info("REST server IP: %(ip)s, port: %(port)s, username: %("
"user)s. Verify server's certificate: %(verify_cert)s.", "user)s. Verify server's certificate: %(verify_cert)s.",
{'ip': self.server_ip, {'ip': self.server_ip,
@ -195,10 +143,10 @@ class ScaleIODriver(driver.VolumeDriver):
# starting in Pike, prefer the sio_storage_pools option # starting in Pike, prefer the sio_storage_pools option
self.storage_pools = None self.storage_pools = None
if self.configuration.sio_storage_pools: if self.configuration.vxflexos_storage_pools:
self.storage_pools = [ self.storage_pools = [
e.strip() for e in e.strip() for e in
self.configuration.sio_storage_pools.split(',')] self.configuration.vxflexos_storage_pools.split(',')]
LOG.info("Storage pools names: %(pools)s.", LOG.info("Storage pools names: %(pools)s.",
{'pools': self.storage_pools}) {'pools': self.storage_pools})
@ -216,7 +164,7 @@ class ScaleIODriver(driver.VolumeDriver):
LOG.info("Default provisioning type: %(provisioning_type)s.", LOG.info("Default provisioning type: %(provisioning_type)s.",
{'provisioning_type': self.provisioning_type}) {'provisioning_type': self.provisioning_type})
self.configuration.max_over_subscription_ratio = ( self.configuration.max_over_subscription_ratio = (
self.configuration.sio_max_over_subscription_ratio) self.configuration.vxflexos_max_over_subscription_ratio)
self.connector = initiator.connector.InitiatorConnector.factory( self.connector = initiator.connector.InitiatorConnector.factory(
initiator.SCALEIO, utils.get_root_helper(), initiator.SCALEIO, utils.get_root_helper(),
self.configuration.num_volume_device_scan_tries self.configuration.num_volume_device_scan_tries
@ -236,7 +184,7 @@ class ScaleIODriver(driver.VolumeDriver):
@staticmethod @staticmethod
def get_driver_options(): def get_driver_options():
return scaleio_opts return vxflexos_opts
def check_for_setup_error(self): def check_for_setup_error(self):
# make sure both domain name and id are not specified # make sure both domain name and id are not specified
@ -281,27 +229,28 @@ class ScaleIODriver(driver.VolumeDriver):
# validate oversubscription ration # validate oversubscription ration
if (self.configuration.max_over_subscription_ratio is not None and if (self.configuration.max_over_subscription_ratio is not None and
(self.configuration.max_over_subscription_ratio - (self.configuration.max_over_subscription_ratio -
SIO_MAX_OVERSUBSCRIPTION_RATIO > 1)): VXFLEXOS_MAX_OVERSUBSCRIPTION_RATIO > 1)):
msg = (_("Max over subscription is configured to %(ratio)1f " msg = (_("Max over subscription is configured to %(ratio)1f "
"while ScaleIO support up to %(sio_ratio)s.") % "while VxFlex OS support up to %(vxflexos_ratio)s.") %
{'sio_ratio': SIO_MAX_OVERSUBSCRIPTION_RATIO, {'vxflexos_ratio': VXFLEXOS_MAX_OVERSUBSCRIPTION_RATIO,
'ratio': self.configuration.max_over_subscription_ratio}) 'ratio': self.configuration.max_over_subscription_ratio})
raise exception.InvalidInput(reason=msg) raise exception.InvalidInput(reason=msg)
# validate that version of ScaleIO is supported # validate that version of VxFlex OS is supported
server_api_version = self._get_server_api_version(fromcache=False) server_api_version = self._get_server_api_version(fromcache=False)
if not self._version_greater_than_or_equal( if not self._version_greater_than_or_equal(
server_api_version, "2.0.0"): server_api_version, "2.0.0"):
# we are running against a pre-2.0.0 ScaleIO instance # we are running against a pre-2.0.0 VxFlex OS(ScaleIO) instance
msg = (_("Using ScaleIO versions less than v2.0.0 has been " msg = (_("Using VxFlex OS(ScaleIO) versions less "
"deprecated and will be removed in a future version")) "than v2.0.0 has been deprecated and will be "
"removed in a future version"))
versionutils.report_deprecated_feature(LOG, msg) versionutils.report_deprecated_feature(LOG, msg)
# we have enough information now to validate pools # we have enough information now to validate pools
self.storage_pools = self._build_storage_pool_list() self.storage_pools = self._build_storage_pool_list()
if not self.storage_pools: if not self.storage_pools:
msg = (_("Must specify storage pools. Option: " msg = (_("Must specify storage pools. Option: "
"sio_storage_pools.")) "vxflexos_storage_pools."))
raise exception.InvalidInput(reason=msg) raise exception.InvalidInput(reason=msg)
# validate the storage pools and check if zero padding is enabled # validate the storage pools and check if zero padding is enabled
@ -327,7 +276,7 @@ class ScaleIODriver(driver.VolumeDriver):
LOG.warning("Zero padding is disabled for pool, %s. " LOG.warning("Zero padding is disabled for pool, %s. "
"This could lead to existing data being " "This could lead to existing data being "
"accessible on new provisioned volumes. " "accessible on new provisioned volumes. "
"Consult the ScaleIO product documentation " "Consult the VxFlex OS product documentation "
"for information on how to enable zero padding " "for information on how to enable zero padding "
"and prevent this from occurring.", "and prevent this from occurring.",
pool) pool)
@ -388,8 +337,8 @@ class ScaleIODriver(driver.VolumeDriver):
"querySelectedStatistics") % req_vars "querySelectedStatistics") % req_vars
params = {'ids': [sio_id], params = {'ids': [sio_id],
'properties': ["thinCapacityAllocatedInKb"]} 'properties': ["thinCapacityAllocatedInKb"]}
r, response = self._execute_scaleio_post_request(params, r, response = self._execute_vxflexos_post_request(params,
request) request)
if r.status_code == http_client.OK: if r.status_code == http_client.OK:
# is it valid, use it # is it valid, use it
self.statisticProperties.append( self.statisticProperties.append(
@ -482,7 +431,7 @@ class ScaleIODriver(driver.VolumeDriver):
@staticmethod @staticmethod
def _id_to_base64(id): def _id_to_base64(id):
# Base64 encode the id to get a volume name less than 32 characters due # Base64 encode the id to get a volume name less than 32 characters due
# to ScaleIO limitation. # to VxFlex OS limitation.
name = six.text_type(id).replace("-", "") name = six.text_type(id).replace("-", "")
try: try:
name = base64.b16decode(name.upper()) name = base64.b16decode(name.upper())
@ -494,7 +443,7 @@ class ScaleIODriver(driver.VolumeDriver):
encoded_name = base64.b64encode(encoded_name) encoded_name = base64.b64encode(encoded_name)
if six.PY3: if six.PY3:
encoded_name = encoded_name.decode('ascii') encoded_name = encoded_name.decode('ascii')
LOG.debug("Converted id %(id)s to scaleio name %(name)s.", LOG.debug("Converted id %(id)s to VxFlex OS name %(name)s.",
{'id': id, 'name': encoded_name}) {'id': id, 'name': encoded_name})
return encoded_name return encoded_name
@ -507,7 +456,7 @@ class ScaleIODriver(driver.VolumeDriver):
being read off of a newly created volume. being read off of a newly created volume.
""" """
# if we have been told to allow unsafe volumes # if we have been told to allow unsafe volumes
if self.configuration.sio_allow_non_padded_volumes: if self.configuration.vxflexos_allow_non_padded_volumes:
# Enabled regardless of type, so safe to proceed # Enabled regardless of type, so safe to proceed
return True return True
@ -527,7 +476,7 @@ class ScaleIODriver(driver.VolumeDriver):
return False return False
def create_volume(self, volume): def create_volume(self, volume):
"""Creates a scaleIO volume.""" """Creates a VxFlex OS volume."""
self._check_volume_size(volume.size) self._check_volume_size(volume.size)
volname = self._id_to_base64(volume.id) volname = self._id_to_base64(volume.id)
@ -614,7 +563,7 @@ class ScaleIODriver(driver.VolumeDriver):
"zero padding being disabled for pool, %s:%s. " "zero padding being disabled for pool, %s:%s. "
"This behaviour can be changed by setting " "This behaviour can be changed by setting "
"the configuration option " "the configuration option "
"sio_allow_non_padded_volumes = True.", "vxflexos_allow_non_padded_volumes = True.",
protection_domain_name, protection_domain_name,
storage_pool_name) storage_pool_name)
msg = _("Volume creation rejected due to " msg = _("Volume creation rejected due to "
@ -634,7 +583,7 @@ class ScaleIODriver(driver.VolumeDriver):
'server_port': self.server_port} 'server_port': self.server_port}
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/types/Volume/instances") % req_vars "/api/types/Volume/instances") % req_vars
r, response = self._execute_scaleio_post_request(params, request) r, response = self._execute_vxflexos_post_request(params, request)
if r.status_code != http_client.OK and "errorCode" in response: if r.status_code != http_client.OK and "errorCode" in response:
msg = (_("Error creating volume: %s.") % response['message']) msg = (_("Error creating volume: %s.") % response['message'])
@ -651,7 +600,7 @@ class ScaleIODriver(driver.VolumeDriver):
def _check_volume_size(self, size): def _check_volume_size(self, size):
if size % 8 != 0: if size % 8 != 0:
round_volume_capacity = ( round_volume_capacity = (
self.configuration.sio_round_volume_capacity) self.configuration.vxflexos_round_volume_capacity)
if not round_volume_capacity: if not round_volume_capacity:
exception_msg = (_( exception_msg = (_(
"Cannot create volume of size %s: " "Cannot create volume of size %s: "
@ -660,7 +609,7 @@ class ScaleIODriver(driver.VolumeDriver):
raise exception.VolumeBackendAPIException(data=exception_msg) raise exception.VolumeBackendAPIException(data=exception_msg)
def create_snapshot(self, snapshot): def create_snapshot(self, snapshot):
"""Creates a scaleio snapshot.""" """Creates a VxFlex OS snapshot."""
volume_id = snapshot.volume.provider_id volume_id = snapshot.volume.provider_id
snapname = self._id_to_base64(snapshot.id) snapname = self._id_to_base64(snapshot.id)
return self._snapshot_volume(volume_id, snapname) return self._snapshot_volume(volume_id, snapname)
@ -674,7 +623,7 @@ class ScaleIODriver(driver.VolumeDriver):
'server_port': self.server_port} 'server_port': self.server_port}
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/instances/System/action/snapshotVolumes") % req_vars "/api/instances/System/action/snapshotVolumes") % req_vars
r, response = self._execute_scaleio_post_request(params, request) r, response = self._execute_vxflexos_post_request(params, request)
if r.status_code != http_client.OK and "errorCode" in response: if r.status_code != http_client.OK and "errorCode" in response:
msg = (_("Failed creating snapshot for volume %(volname)s: " msg = (_("Failed creating snapshot for volume %(volname)s: "
"%(response)s.") % "%(response)s.") %
@ -685,7 +634,7 @@ class ScaleIODriver(driver.VolumeDriver):
return {'provider_id': response['volumeIdList'][0]} return {'provider_id': response['volumeIdList'][0]}
def _execute_scaleio_post_request(self, params, request): def _execute_vxflexos_post_request(self, params, request):
r = requests.post( r = requests.post(
request, request,
data=json.dumps(params), data=json.dumps(params),
@ -709,8 +658,9 @@ class ScaleIODriver(driver.VolumeDriver):
LOG.info("Token is invalid, going to re-login and get " LOG.info("Token is invalid, going to re-login and get "
"a new one.") "a new one.")
login_request = ( login_request = (
"https://" + self.server_ip + "https://%(server_ip)s:%(server_port)s/api/login" % {
":" + self.server_port + "/api/login") "server_ip": self.server_ip,
"server_port": self.server_port})
verify_cert = self._get_verify_cert() verify_cert = self._get_verify_cert()
r = requests.get( r = requests.get(
login_request, login_request,
@ -753,9 +703,10 @@ class ScaleIODriver(driver.VolumeDriver):
def _get_server_api_version(self, fromcache=True): def _get_server_api_version(self, fromcache=True):
if self.server_api_version is None or fromcache is False: if self.server_api_version is None or fromcache is False:
request = ( request = (
"https://" + self.server_ip + "https://%(server_ip)s:%(server_port)s/api/version" % {
":" + self.server_port + "/api/version") "server_ip": self.server_ip,
r, unused = self._execute_scaleio_get_request(request) "server_port": self.server_port})
r, unused = self._execute_vxflexos_get_request(request)
if r.status_code == http_client.OK: if r.status_code == http_client.OK:
self.server_api_version = r.text.replace('\"', '') self.server_api_version = r.text.replace('\"', '')
@ -777,15 +728,15 @@ class ScaleIODriver(driver.VolumeDriver):
def create_volume_from_snapshot(self, volume, snapshot): def create_volume_from_snapshot(self, volume, snapshot):
"""Creates a volume from a snapshot.""" """Creates a volume from a snapshot."""
# We interchange 'volume' and 'snapshot' because in ScaleIO # We interchange 'volume' and 'snapshot' because in VxFlex OS
# snapshot is a volume: once a snapshot is generated it # snapshot is a volume: once a snapshot is generated it
# becomes a new unmapped volume in the system and the user # becomes a new unmapped volume in the system and the user
# may manipulate it in the same manner as any other volume # may manipulate it in the same manner as any other volume
# exposed by the system # exposed by the system
volume_id = snapshot.provider_id volume_id = snapshot.provider_id
snapname = self._id_to_base64(volume.id) snapname = self._id_to_base64(volume.id)
LOG.info("ScaleIO create volume from snapshot: snapshot %(snapname)s " LOG.info("VxFlex OS create volume from snapshot: "
"to volume %(volname)s.", "snapshot %(snapname)s to volume %(volname)s.",
{'volname': volume_id, {'volname': volume_id,
'snapname': snapname}) 'snapname': snapname})
@ -810,7 +761,7 @@ class ScaleIODriver(driver.VolumeDriver):
return verify_cert return verify_cert
def extend_volume(self, volume, new_size): def extend_volume(self, volume, new_size):
"""Extends the size of an existing available ScaleIO volume. """Extends the size of an existing available VxFlex OS volume.
This action will round up the volume to the nearest size that is This action will round up the volume to the nearest size that is
a granularity of 8 GBs. a granularity of 8 GBs.
@ -821,7 +772,8 @@ class ScaleIODriver(driver.VolumeDriver):
def _extend_volume(self, volume_id, old_size, new_size): def _extend_volume(self, volume_id, old_size, new_size):
vol_id = volume_id vol_id = volume_id
LOG.info( LOG.info(
"ScaleIO extend volume: volume %(volname)s to size %(new_size)s.", "VxFlex OS extend volume: "
"volume %(volname)s to size %(new_size)s.",
{'volname': vol_id, {'volname': vol_id,
'new_size': new_size}) 'new_size': new_size})
@ -834,20 +786,21 @@ class ScaleIODriver(driver.VolumeDriver):
LOG.info("Change volume capacity request: %s.", request) LOG.info("Change volume capacity request: %s.", request)
# Round up the volume size so that it is a granularity of 8 GBs # Round up the volume size so that it is a granularity of 8 GBs
# because ScaleIO only supports volumes with a granularity of 8 GBs. # because VxFlex OS only supports volumes with a granularity of 8 GBs.
volume_new_size = self._round_to_num_gran(new_size) volume_new_size = self._round_to_num_gran(new_size)
volume_real_old_size = self._round_to_num_gran(old_size) volume_real_old_size = self._round_to_num_gran(old_size)
if volume_real_old_size == volume_new_size: if volume_real_old_size == volume_new_size:
return return
round_volume_capacity = self.configuration.sio_round_volume_capacity round_volume_capacity = (
self.configuration.vxflexos_round_volume_capacity)
if not round_volume_capacity and not new_size % 8 == 0: if not round_volume_capacity and not new_size % 8 == 0:
LOG.warning("ScaleIO only supports volumes with a granularity " LOG.warning("VxFlex OS only supports volumes with a granularity "
"of 8 GBs. The new volume size is: %d.", "of 8 GBs. The new volume size is: %d.",
volume_new_size) volume_new_size)
params = {'sizeInGB': six.text_type(volume_new_size)} params = {'sizeInGB': six.text_type(volume_new_size)}
r, response = self._execute_scaleio_post_request(params, request) r, response = self._execute_vxflexos_post_request(params, request)
if r.status_code != http_client.OK: if r.status_code != http_client.OK:
response = r.json() response = r.json()
msg = (_("Error extending volume %(vol)s: %(err)s.") msg = (_("Error extending volume %(vol)s: %(err)s.")
@ -870,7 +823,7 @@ class ScaleIODriver(driver.VolumeDriver):
"""Creates a cloned volume.""" """Creates a cloned volume."""
volume_id = src_vref['provider_id'] volume_id = src_vref['provider_id']
snapname = self._id_to_base64(volume.id) snapname = self._id_to_base64(volume.id)
LOG.info("ScaleIO create cloned volume: source volume %(src)s to " LOG.info("VxFlex OS create cloned volume: source volume %(src)s to "
"target volume %(tgt)s.", "target volume %(tgt)s.",
{'src': volume_id, {'src': volume_id,
'tgt': snapname}) 'tgt': snapname})
@ -892,7 +845,7 @@ class ScaleIODriver(driver.VolumeDriver):
'vol_id': six.text_type(vol_id)} 'vol_id': six.text_type(vol_id)}
unmap_before_delete = ( unmap_before_delete = (
self.configuration.sio_unmap_volume_before_deletion) self.configuration.vxflexos_unmap_volume_before_deletion)
# Ensure that the volume is not mapped to any SDC before deletion in # Ensure that the volume is not mapped to any SDC before deletion in
# case unmap_before_deletion is enabled. # case unmap_before_deletion is enabled.
if unmap_before_delete: if unmap_before_delete:
@ -903,13 +856,13 @@ class ScaleIODriver(driver.VolumeDriver):
LOG.info("Trying to unmap volume from all sdcs" LOG.info("Trying to unmap volume from all sdcs"
" before deletion: %s.", " before deletion: %s.",
request) request)
r, unused = self._execute_scaleio_post_request(params, request) r, unused = self._execute_vxflexos_post_request(params, request)
params = {'removeMode': 'ONLY_ME'} params = {'removeMode': 'ONLY_ME'}
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/instances/Volume::%(vol_id)s" "/api/instances/Volume::%(vol_id)s"
"/action/removeVolume") % req_vars "/action/removeVolume") % req_vars
r, response = self._execute_scaleio_post_request(params, request) r, response = self._execute_vxflexos_post_request(params, request)
if r.status_code != http_client.OK: if r.status_code != http_client.OK:
error_code = response['errorCode'] error_code = response['errorCode']
@ -918,7 +871,7 @@ class ScaleIODriver(driver.VolumeDriver):
" Volume not found.", vol_id) " Volume not found.", vol_id)
elif vol_id is None: elif vol_id is None:
LOG.warning("Volume does not have provider_id thus does not " LOG.warning("Volume does not have provider_id thus does not "
"map to a ScaleIO volume. " "map to a VxFlex OS volume. "
"Allowing deletion to proceed.") "Allowing deletion to proceed.")
else: else:
msg = (_("Error deleting volume %(vol)s: %(err)s.") % msg = (_("Error deleting volume %(vol)s: %(err)s.") %
@ -928,9 +881,9 @@ class ScaleIODriver(driver.VolumeDriver):
raise exception.VolumeBackendAPIException(data=msg) raise exception.VolumeBackendAPIException(data=msg)
def delete_snapshot(self, snapshot): def delete_snapshot(self, snapshot):
"""Deletes a ScaleIO snapshot.""" """Deletes a VxFlex OS snapshot."""
snap_id = snapshot.provider_id snap_id = snapshot.provider_id
LOG.info("ScaleIO delete snapshot.") LOG.info("VxFlex OS delete snapshot.")
return self._delete_volume(snap_id) return self._delete_volume(snap_id)
def initialize_connection(self, volume, connector, **kwargs): def initialize_connection(self, volume, connector, **kwargs):
@ -939,7 +892,7 @@ class ScaleIODriver(driver.VolumeDriver):
def _initialize_connection(self, vol_or_snap, connector, vol_size): def _initialize_connection(self, vol_or_snap, connector, vol_size):
"""Initializes a connection and returns connection info. """Initializes a connection and returns connection info.
The scaleio driver returns a driver_volume_type of 'scaleio'. The VxFlex OS driver returns a driver_volume_type of 'scaleio'.
""" """
try: try:
@ -989,7 +942,7 @@ class ScaleIODriver(driver.VolumeDriver):
LOG.info("bandwidth per gb is: %s", bw_per_gb) LOG.info("bandwidth per gb is: %s", bw_per_gb)
if bw_per_gb is None: if bw_per_gb is None:
return max_bandwidth return max_bandwidth
# Since ScaleIO volumes size is in 8GB granularity # Since VxFlex OS volumes size is in 8GB granularity
# and BWS limitation is in 1024 KBs granularity, we need to make # and BWS limitation is in 1024 KBs granularity, we need to make
# sure that scaled_bw_limit is in 128 granularity. # sure that scaled_bw_limit is in 128 granularity.
scaled_bw_limit = (size * scaled_bw_limit = (size *
@ -1030,7 +983,7 @@ class ScaleIODriver(driver.VolumeDriver):
def _terminate_connection(self, volume_or_snap, connector): def _terminate_connection(self, volume_or_snap, connector):
"""Terminate connection to a volume or snapshot """Terminate connection to a volume or snapshot
With ScaleIO, snaps and volumes are terminated identically With VxFlex OS, snaps and volumes are terminated identically
""" """
try: try:
ip = connector['ip'] ip = connector['ip']
@ -1046,7 +999,7 @@ class ScaleIODriver(driver.VolumeDriver):
stats = {} stats = {}
backend_name = self.configuration.safe_get('volume_backend_name') backend_name = self.configuration.safe_get('volume_backend_name')
stats['volume_backend_name'] = backend_name or 'scaleio' stats['volume_backend_name'] = backend_name or 'vxflexos'
stats['vendor_name'] = 'Dell EMC' stats['vendor_name'] = 'Dell EMC'
stats['driver_version'] = self.VERSION stats['driver_version'] = self.VERSION
stats['storage_protocol'] = 'scaleio' stats['storage_protocol'] = 'scaleio'
@ -1079,10 +1032,11 @@ class ScaleIODriver(driver.VolumeDriver):
props = self._get_queryable_statistics("StoragePool", pool_id) props = self._get_queryable_statistics("StoragePool", pool_id)
params = {'ids': [pool_id], 'properties': props} params = {'ids': [pool_id], 'properties': props}
r, response = self._execute_scaleio_post_request(params, request) r, response = self._execute_vxflexos_post_request(params, request)
LOG.info("Query capacity stats response: %s.", response) LOG.info("Query capacity stats response: %s.", response)
for res in response.values(): for res in response.values():
# Divide by two because ScaleIO creates a copy for each volume # Divide by two because VxFlex OS creates
# a copy for each volume
total_capacity_kb = ( total_capacity_kb = (
(res['capacityLimitInKb'] - res['spareCapacityInKb']) / 2) (res['capacityLimitInKb'] - res['spareCapacityInKb']) / 2)
total_capacity_gb = (self._round_down_to_num_gran total_capacity_gb = (self._round_down_to_num_gran
@ -1103,7 +1057,8 @@ class ScaleIODriver(driver.VolumeDriver):
except (TypeError, KeyError): except (TypeError, KeyError):
pass pass
# Divide by two because ScaleIO creates a copy for each volume # Divide by two because VxFlex OS creates
# a copy for each volume
provisioned_capacity = ( provisioned_capacity = (
((res['thickCapacityInUseInKb'] + ((res['thickCapacityInUseInKb'] +
res['snapCapacityInUseInKb'] + res['snapCapacityInUseInKb'] +
@ -1181,13 +1136,13 @@ class ScaleIODriver(driver.VolumeDriver):
else: else:
specs = {} specs = {}
for key, value in specs.items(): for key, value in specs.items():
if key in self.scaleio_qos_keys: if key in self.vxflexos_qos_keys:
qos[key] = value qos[key] = value
return qos return qos
def _sio_attach_volume(self, volume): def _sio_attach_volume(self, volume):
"""Call connector.connect_volume() and return the path. """ """Call connector.connect_volume() and return the path. """
LOG.debug("Calling os-brick to attach ScaleIO volume.") LOG.debug("Calling os-brick to attach VxFlex OS volume.")
connection_properties = dict(self.connection_properties) connection_properties = dict(self.connection_properties)
connection_properties['scaleIO_volname'] = self._id_to_base64( connection_properties['scaleIO_volname'] = self._id_to_base64(
volume.id) volume.id)
@ -1197,7 +1152,7 @@ class ScaleIODriver(driver.VolumeDriver):
def _sio_detach_volume(self, volume): def _sio_detach_volume(self, volume):
"""Call the connector.disconnect() """ """Call the connector.disconnect() """
LOG.info("Calling os-brick to detach ScaleIO volume.") LOG.info("Calling os-brick to detach VxFlex OS volume.")
connection_properties = dict(self.connection_properties) connection_properties = dict(self.connection_properties)
connection_properties['scaleIO_volname'] = self._id_to_base64( connection_properties['scaleIO_volname'] = self._id_to_base64(
volume.id) volume.id)
@ -1206,8 +1161,8 @@ class ScaleIODriver(driver.VolumeDriver):
def copy_image_to_volume(self, context, volume, image_service, image_id): def copy_image_to_volume(self, context, volume, image_service, image_id):
"""Fetch the image from image_service and write it to the volume.""" """Fetch the image from image_service and write it to the volume."""
LOG.info("ScaleIO copy_image_to_volume volume: %(vol)s image service: " LOG.info("VxFlex OS copy_image_to_volume volume: "
"%(service)s image id: %(id)s.", "%(vol)s image service: %(service)s image id: %(id)s.",
{'vol': volume, {'vol': volume,
'service': six.text_type(image_service), 'service': six.text_type(image_service),
'id': six.text_type(image_id)}) 'id': six.text_type(image_id)})
@ -1225,8 +1180,8 @@ class ScaleIODriver(driver.VolumeDriver):
def copy_volume_to_image(self, context, volume, image_service, image_meta): def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image.""" """Copy the volume to the specified image."""
LOG.info("ScaleIO copy_volume_to_image volume: %(vol)s image service: " LOG.info("VxFlex OS copy_volume_to_image volume: "
"%(service)s image meta: %(meta)s.", "%(vol)s image service: %(service)s image meta: %(meta)s.",
{'vol': volume, {'vol': volume,
'service': six.text_type(image_service), 'service': six.text_type(image_service),
'meta': six.text_type(image_meta)}) 'meta': six.text_type(image_meta)})
@ -1240,11 +1195,11 @@ class ScaleIODriver(driver.VolumeDriver):
def update_migrated_volume(self, ctxt, volume, new_volume, def update_migrated_volume(self, ctxt, volume, new_volume,
original_volume_status): original_volume_status):
"""Return the update from ScaleIO migrated volume. """Return the update from VxFlex OS migrated volume.
This method updates the volume name of the new ScaleIO volume to This method updates the volume name of the new VxFlex OS volume to
match the updated volume ID. match the updated volume ID.
The original volume is renamed first since ScaleIO does not allow The original volume is renamed first since VxFlex OS does not allow
multiple volumes to have the same name. multiple volumes to have the same name.
""" """
name_id = None name_id = None
@ -1283,10 +1238,10 @@ class ScaleIODriver(driver.VolumeDriver):
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/instances/Volume::%(id)s/action/setVolumeName" % "/api/instances/Volume::%(id)s/action/setVolumeName" %
req_vars) req_vars)
LOG.info("ScaleIO rename volume request: %s.", request) LOG.info("VxFlex OS rename volume request: %s.", request)
params = {'newName': new_name} params = {'newName': new_name}
r, response = self._execute_scaleio_post_request(params, request) r, response = self._execute_vxflexos_post_request(params, request)
if r.status_code != http_client.OK: if r.status_code != http_client.OK:
error_code = response['errorCode'] error_code = response['errorCode']
@ -1294,7 +1249,7 @@ class ScaleIODriver(driver.VolumeDriver):
error_code == OLD_VOLUME_NOT_FOUND_ERROR or error_code == OLD_VOLUME_NOT_FOUND_ERROR or
error_code == ILLEGAL_SYNTAX)): error_code == ILLEGAL_SYNTAX)):
LOG.info("Ignoring renaming action because the volume " LOG.info("Ignoring renaming action because the volume "
"%(vol)s is not a ScaleIO volume.", "%(vol)s is not a VxFlex OS volume.",
{'vol': vol_id}) {'vol': vol_id})
else: else:
msg = (_("Error renaming volume %(vol)s: %(err)s.") % msg = (_("Error renaming volume %(vol)s: %(err)s.") %
@ -1302,13 +1257,14 @@ class ScaleIODriver(driver.VolumeDriver):
LOG.error(msg) LOG.error(msg)
raise exception.VolumeBackendAPIException(data=msg) raise exception.VolumeBackendAPIException(data=msg)
else: else:
LOG.info("ScaleIO volume %(vol)s was renamed to " LOG.info("VxFlex OS volume %(vol)s was renamed to "
"%(new_name)s.", "%(new_name)s.",
{'vol': vol_id, 'new_name': new_name}) {'vol': vol_id, 'new_name': new_name})
def _query_scaleio_volume(self, volume, existing_ref): def _query_vxflexos_volume(self, volume, existing_ref):
request = self._create_scaleio_get_volume_request(volume, existing_ref) request = self._create_vxflexos_get_volume_request(volume,
r, response = self._execute_scaleio_get_request(request) existing_ref)
r, response = self._execute_vxflexos_get_request(request)
self._manage_existing_check_legal_response(r, existing_ref) self._manage_existing_check_legal_response(r, existing_ref)
return response return response
@ -1332,7 +1288,7 @@ class ScaleIODriver(driver.VolumeDriver):
'pool_id': pool_id} 'pool_id': pool_id}
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/instances/StoragePool::%(pool_id)s") % req_vars "/api/instances/StoragePool::%(pool_id)s") % req_vars
r, response = self._execute_scaleio_get_request(request) r, response = self._execute_vxflexos_get_request(request)
if r.status_code != http_client.OK: if r.status_code != http_client.OK:
msg = (_("Error getting pool name from id %(pool_id)s: " msg = (_("Error getting pool name from id %(pool_id)s: "
@ -1359,7 +1315,7 @@ class ScaleIODriver(driver.VolumeDriver):
'domain_id': domain_id} 'domain_id': domain_id}
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/instances/ProtectionDomain::%(domain_id)s") % req_vars "/api/instances/ProtectionDomain::%(domain_id)s") % req_vars
r, response = self._execute_scaleio_get_request(request) r, response = self._execute_vxflexos_get_request(request)
if r.status_code != http_client.OK: if r.status_code != http_client.OK:
msg = (_("Error getting domain name from id %(domain_id)s: " msg = (_("Error getting domain name from id %(domain_id)s: "
@ -1392,7 +1348,7 @@ class ScaleIODriver(driver.VolumeDriver):
"/api/types/Domain/instances/getByName::" "/api/types/Domain/instances/getByName::"
"%(encoded_domain_name)s") % req_vars "%(encoded_domain_name)s") % req_vars
r, domain_id = self._execute_scaleio_get_request(request) r, domain_id = self._execute_vxflexos_get_request(request)
if not domain_id: if not domain_id:
msg = (_("Domain with name %s wasn't found.") msg = (_("Domain with name %s wasn't found.")
@ -1413,7 +1369,7 @@ class ScaleIODriver(driver.VolumeDriver):
'domain_id': domain_id} 'domain_id': domain_id}
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/instances/ProtectionDomain::%(domain_id)s") % req_vars "/api/instances/ProtectionDomain::%(domain_id)s") % req_vars
r, response = self._execute_scaleio_get_request(request) r, response = self._execute_vxflexos_get_request(request)
if r.status_code != http_client.OK: if r.status_code != http_client.OK:
msg = (_("Error getting domain properties from id %(domain_id)s: " msg = (_("Error getting domain properties from id %(domain_id)s: "
@ -1451,8 +1407,8 @@ class ScaleIODriver(driver.VolumeDriver):
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/types/Pool/instances/getByName::" "/api/types/Pool/instances/getByName::"
"%(domain_id)s,%(encoded_pool_name)s") % req_vars "%(domain_id)s,%(encoded_pool_name)s") % req_vars
LOG.debug("ScaleIO get pool id by name request: %s.", request) LOG.debug("VxFlex OS get pool id by name request: %s.", request)
r, pool_id = self._execute_scaleio_get_request(request) r, pool_id = self._execute_vxflexos_get_request(request)
if not pool_id: if not pool_id:
msg = (_("Pool with name %(pool_name)s wasn't found in " msg = (_("Pool with name %(pool_name)s wasn't found in "
@ -1476,7 +1432,7 @@ class ScaleIODriver(driver.VolumeDriver):
'pool_id': pool_id} 'pool_id': pool_id}
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/instances/StoragePool::%(pool_id)s") % req_vars "/api/instances/StoragePool::%(pool_id)s") % req_vars
r, response = self._execute_scaleio_get_request(request) r, response = self._execute_vxflexos_get_request(request)
if r.status_code != http_client.OK: if r.status_code != http_client.OK:
msg = (_("Error getting pool properties from id %(pool_id)s: " msg = (_("Error getting pool properties from id %(pool_id)s: "
@ -1498,8 +1454,8 @@ class ScaleIODriver(driver.VolumeDriver):
return response['id'] return response['id']
def _get_all_scaleio_volumes(self): def _get_all_vxflexos_volumes(self):
"""Gets list of all SIO volumes in PD and SP""" """Gets list of all VxFlex OS volumes in PD and SP"""
all_volumes = [] all_volumes = []
# check for every storage pool configured # check for every storage pool configured
@ -1516,7 +1472,7 @@ class ScaleIODriver(driver.VolumeDriver):
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/instances/StoragePool::%(storage_pool_id)s" "/api/instances/StoragePool::%(storage_pool_id)s"
"/relationships/Volume") % req_vars "/relationships/Volume") % req_vars
r, volumes = self._execute_scaleio_get_request(request) r, volumes = self._execute_vxflexos_get_request(request)
if r.status_code != http_client.OK: if r.status_code != http_client.OK:
msg = (_("Error calling api " msg = (_("Error calling api "
@ -1536,7 +1492,7 @@ class ScaleIODriver(driver.VolumeDriver):
Return references of the volume ids for any others. Return references of the volume ids for any others.
""" """
all_sio_volumes = self._get_all_scaleio_volumes() all_sio_volumes = self._get_all_vxflexos_volumes()
# Put together a map of existing cinder volumes on the array # Put together a map of existing cinder volumes on the array
# so we can lookup cinder id's to SIO id # so we can lookup cinder id's to SIO id
@ -1583,25 +1539,25 @@ class ScaleIODriver(driver.VolumeDriver):
return False return False
def manage_existing(self, volume, existing_ref): def manage_existing(self, volume, existing_ref):
"""Manage an existing ScaleIO volume. """Manage an existing VxFlex OS volume.
existing_ref is a dictionary of the form: existing_ref is a dictionary of the form:
{'source-id': <id of ScaleIO volume>} {'source-id': <id of VxFlex OS volume>}
""" """
response = self._query_scaleio_volume(volume, existing_ref) response = self._query_vxflexos_volume(volume, existing_ref)
return {'provider_id': response['id']} return {'provider_id': response['id']}
def manage_existing_get_size(self, volume, existing_ref): def manage_existing_get_size(self, volume, existing_ref):
return self._get_volume_size(volume, existing_ref) return self._get_volume_size(volume, existing_ref)
def manage_existing_snapshot(self, snapshot, existing_ref): def manage_existing_snapshot(self, snapshot, existing_ref):
"""Manage an existing ScaleIO snapshot. """Manage an existing VxFlex OS snapshot.
:param snapshot: the snapshot to manage :param snapshot: the snapshot to manage
:param existing_ref: dictionary of the form: :param existing_ref: dictionary of the form:
{'source-id': <id of ScaleIO snapshot>} {'source-id': <id of VxFlex OS snapshot>}
""" """
response = self._query_scaleio_volume(snapshot, existing_ref) response = self._query_vxflexos_volume(snapshot, existing_ref)
not_real_parent = (response.get('orig_parent_overriden') or not_real_parent = (response.get('orig_parent_overriden') or
response.get('is_source_deleted')) response.get('is_source_deleted'))
if not_real_parent: if not_real_parent:
@ -1615,7 +1571,7 @@ class ScaleIODriver(driver.VolumeDriver):
ancestor_id = response['ancestorVolumeId'] ancestor_id = response['ancestorVolumeId']
volume_id = snapshot.volume.provider_id volume_id = snapshot.volume.provider_id
if ancestor_id != volume_id: if ancestor_id != volume_id:
reason = (_("The snapshot's parent in ScaleIO is %(ancestor)s " reason = (_("The snapshot's parent in VxFlex OS is %(ancestor)s "
"and not %(volume)s.") % "and not %(volume)s.") %
{'ancestor': ancestor_id, 'volume': volume_id}) {'ancestor': ancestor_id, 'volume': volume_id})
raise exception.ManageExistingInvalidReference( raise exception.ManageExistingInvalidReference(
@ -1628,10 +1584,10 @@ class ScaleIODriver(driver.VolumeDriver):
return self._get_volume_size(snapshot, existing_ref) return self._get_volume_size(snapshot, existing_ref)
def _get_volume_size(self, volume, existing_ref): def _get_volume_size(self, volume, existing_ref):
response = self._query_scaleio_volume(volume, existing_ref) response = self._query_vxflexos_volume(volume, existing_ref)
return int(math.ceil(float(response['sizeInKb']) / units.Mi)) return int(math.ceil(float(response['sizeInKb']) / units.Mi))
def _execute_scaleio_get_request(self, request): def _execute_vxflexos_get_request(self, request):
r = requests.get( r = requests.get(
request, request,
auth=( auth=(
@ -1642,7 +1598,7 @@ class ScaleIODriver(driver.VolumeDriver):
response = r.json() response = r.json()
return r, response return r, response
def _create_scaleio_get_volume_request(self, volume, existing_ref): def _create_vxflexos_get_volume_request(self, volume, existing_ref):
"""Throws an exception if the input is invalid for manage existing. """Throws an exception if the input is invalid for manage existing.
if the input is valid - return a request. if the input is valid - return a request.
@ -1666,7 +1622,7 @@ class ScaleIODriver(driver.VolumeDriver):
'id': vol_id} 'id': vol_id}
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/instances/Volume::%(id)s" % req_vars) "/api/instances/Volume::%(id)s" % req_vars)
LOG.info("ScaleIO get volume by id request: %s.", request) LOG.info("VxFlex OS get volume by id request: %s.", request)
return request return request
def _manage_existing_check_legal_response(self, response, existing_ref): def _manage_existing_check_legal_response(self, response, existing_ref):
@ -1703,7 +1659,7 @@ class ScaleIODriver(driver.VolumeDriver):
:param group: the group object. :param group: the group object.
:returns: model_update :returns: model_update
ScaleIO won't create CG until cg-snapshot creation, VxFlex OS won't create CG until cg-snapshot creation,
db will maintain the volumes and CG relationship. db will maintain the volumes and CG relationship.
""" """
@ -1723,7 +1679,7 @@ class ScaleIODriver(driver.VolumeDriver):
:param volumes: a list of volume objects in the group. :param volumes: a list of volume objects in the group.
:returns: model_update, volumes_model_update :returns: model_update, volumes_model_update
ScaleIO will delete the volumes of the CG. VxFlex OS will delete the volumes of the CG.
""" """
# let generic volume group support handle non-cgsnapshots # let generic volume group support handle non-cgsnapshots
@ -1765,13 +1721,13 @@ class ScaleIODriver(driver.VolumeDriver):
if not volume_utils.is_group_a_cg_snapshot_type(group_snapshot): if not volume_utils.is_group_a_cg_snapshot_type(group_snapshot):
raise NotImplementedError() raise NotImplementedError()
def get_scaleio_snapshot_params(snapshot): def get_vxflexos_snapshot_params(snapshot):
return { return {
'volumeId': snapshot.volume['provider_id'], 'volumeId': snapshot.volume['provider_id'],
'snapshotName': self._id_to_base64(snapshot['id']) 'snapshotName': self._id_to_base64(snapshot['id'])
} }
snapshot_defs = list(map(get_scaleio_snapshot_params, snapshots)) snapshot_defs = list(map(get_vxflexos_snapshot_params, snapshots))
r, response = self._snapshot_volume_group(snapshot_defs) r, response = self._snapshot_volume_group(snapshot_defs)
if r.status_code != http_client.OK and "errorCode" in response: if r.status_code != http_client.OK and "errorCode" in response:
msg = (_("Failed creating snapshot for group: " msg = (_("Failed creating snapshot for group: "
@ -1780,10 +1736,10 @@ class ScaleIODriver(driver.VolumeDriver):
LOG.error(msg) LOG.error(msg)
raise exception.VolumeBackendAPIException(data=msg) raise exception.VolumeBackendAPIException(data=msg)
snapshot_model_update = [] snapshot_model_update = []
for snapshot, scaleio_id in zip(snapshots, response['volumeIdList']): for snapshot, vxflexos_id in zip(snapshots, response['volumeIdList']):
update_item = {'id': snapshot['id'], update_item = {'id': snapshot['id'],
'status': fields.SnapshotStatus.AVAILABLE, 'status': fields.SnapshotStatus.AVAILABLE,
'provider_id': scaleio_id} 'provider_id': vxflexos_id}
snapshot_model_update.append(update_item) snapshot_model_update.append(update_item)
model_update = {'status': fields.GroupStatus.AVAILABLE} model_update = {'status': fields.GroupStatus.AVAILABLE}
return model_update, snapshot_model_update return model_update, snapshot_model_update
@ -1846,18 +1802,18 @@ class ScaleIODriver(driver.VolumeDriver):
if not volume_utils.is_group_a_cg_snapshot_type(group): if not volume_utils.is_group_a_cg_snapshot_type(group):
raise NotImplementedError() raise NotImplementedError()
def get_scaleio_snapshot_params(src_volume, trg_volume): def get_vxflexos_snapshot_params(src_volume, trg_volume):
return { return {
'volumeId': src_volume['provider_id'], 'volumeId': src_volume['provider_id'],
'snapshotName': self._id_to_base64(trg_volume['id']) 'snapshotName': self._id_to_base64(trg_volume['id'])
} }
if group_snapshot and snapshots: if group_snapshot and snapshots:
snapshot_defs = map(get_scaleio_snapshot_params, snapshot_defs = map(get_vxflexos_snapshot_params,
snapshots, snapshots,
volumes) volumes)
else: else:
snapshot_defs = map(get_scaleio_snapshot_params, snapshot_defs = map(get_vxflexos_snapshot_params,
source_vols, source_vols,
volumes) volumes)
r, response = self._snapshot_volume_group(list(snapshot_defs)) r, response = self._snapshot_volume_group(list(snapshot_defs))
@ -1868,10 +1824,10 @@ class ScaleIODriver(driver.VolumeDriver):
LOG.error(msg) LOG.error(msg)
raise exception.VolumeBackendAPIException(data=msg) raise exception.VolumeBackendAPIException(data=msg)
volumes_model_update = [] volumes_model_update = []
for volume, scaleio_id in zip(volumes, response['volumeIdList']): for volume, vxflexos_id in zip(volumes, response['volumeIdList']):
update_item = {'id': volume['id'], update_item = {'id': volume['id'],
'status': 'available', 'status': 'available',
'provider_id': scaleio_id} 'provider_id': vxflexos_id}
volumes_model_update.append(update_item) volumes_model_update.append(update_item)
model_update = {'status': fields.GroupStatus.AVAILABLE} model_update = {'status': fields.GroupStatus.AVAILABLE}
return model_update, volumes_model_update return model_update, volumes_model_update
@ -1886,7 +1842,7 @@ class ScaleIODriver(driver.VolumeDriver):
:param remove_volumes: a list of volume objects to be removed. :param remove_volumes: a list of volume objects to be removed.
:returns: model_update, add_volumes_update, remove_volumes_update :returns: model_update, add_volumes_update, remove_volumes_update
ScaleIO does not handle volume grouping. VxFlex OS does not handle volume grouping.
Cinder maintains volumes and CG relationship. Cinder maintains volumes and CG relationship.
""" """
@ -1898,13 +1854,13 @@ class ScaleIODriver(driver.VolumeDriver):
raise NotImplementedError() raise NotImplementedError()
def _snapshot_volume_group(self, snapshot_defs): def _snapshot_volume_group(self, snapshot_defs):
LOG.info("ScaleIO snapshot group of volumes") LOG.info("VxFlex OS snapshot group of volumes")
params = {'snapshotDefs': snapshot_defs} params = {'snapshotDefs': snapshot_defs}
req_vars = {'server_ip': self.server_ip, req_vars = {'server_ip': self.server_ip,
'server_port': self.server_port} 'server_port': self.server_port}
request = ("https://%(server_ip)s:%(server_port)s" request = ("https://%(server_ip)s:%(server_port)s"
"/api/instances/System/action/snapshotVolumes") % req_vars "/api/instances/System/action/snapshotVolumes") % req_vars
return self._execute_scaleio_post_request(params, request) return self._execute_vxflexos_post_request(params, request)
def ensure_export(self, context, volume): def ensure_export(self, context, volume):
"""Driver entry point to get the export info for an existing volume.""" """Driver entry point to get the export info for an existing volume."""

177
cinder/volume/drivers/dell_emc/vxflexos/options.py Normal file
View File

@ -0,0 +1,177 @@
# Copyright (c) 2017-2019 Dell Inc. or its subsidiaries.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""
Configuration options for Dell EMC VxFlex OS (formerly
named Dell EMC ScaleIO).
"""
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_PROTECTION_DOMAIN_ID = "sio_protection_domain_id"
SIO_PROTECTION_DOMAIN_NAME = "sio_protection_domain_name"
SIO_STORAGE_POOL_NAME = "sio_storage_pool_name"
SIO_STORAGE_POOL_ID = "sio_storage_pool_id"
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"
VXFLEXOS_STORAGE_POOLS = "vxflexos_storage_pools"
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"
deprecated_opts = [
cfg.PortOpt(SIO_REST_SERVER_PORT,
default=443,
help='renamed to %s.' %
VXFLEXOS_REST_SERVER_PORT,
deprecated_for_removal=True,
deprecated_reason='Replaced by %s.' %
VXFLEXOS_REST_SERVER_PORT),
cfg.BoolOpt(SIO_VERIFY_SERVER_CERTIFICATE,
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,
deprecated_for_removal=True,
deprecated_reason='Replaced by %s.' %
VXFLEXOS_ROUND_VOLUME_CAPACITY),
cfg.BoolOpt(SIO_UNMAP_VOLUME_BEFORE_DELETION,
default=False,
help='renamed to %s.' %
VXFLEXOS_UNMAP_VOLUME_BEFORE_DELETION,
deprecated_for_removal=True,
deprecated_reason='Replaced by %s.' %
VXFLEXOS_UNMAP_VOLUME_BEFORE_DELETION),
cfg.StrOpt(SIO_STORAGE_POOLS,
help='renamed to %s.' %
VXFLEXOS_STORAGE_POOLS,
deprecated_for_removal=True,
deprecated_reason='Replaced by %s.' %
VXFLEXOS_STORAGE_POOLS),
cfg.StrOpt(SIO_PROTECTION_DOMAIN_ID,
deprecated_for_removal=True,
deprecated_reason="Replaced by %s option" %
VXFLEXOS_STORAGE_POOLS,
deprecated_since="Pike",
help='Protection Domain ID. '
'Deprecated, use %s instead. ' % VXFLEXOS_STORAGE_POOLS),
cfg.StrOpt(SIO_PROTECTION_DOMAIN_NAME,
deprecated_for_removal=True,
deprecated_reason="Replaced by %s option" %
VXFLEXOS_STORAGE_POOLS,
deprecated_since="Pike",
help='Protection Domain Name. '
'Deprecated, use %s instead. ' % VXFLEXOS_STORAGE_POOLS),
cfg.StrOpt(SIO_STORAGE_POOL_NAME,
deprecated_for_removal=True,
deprecated_reason="Replaced by %s option" %
VXFLEXOS_STORAGE_POOLS,
deprecated_since="Pike",
help='Storage Pool name. '
'Deprecated, use %s instead. ' % VXFLEXOS_STORAGE_POOLS),
cfg.StrOpt(SIO_STORAGE_POOL_ID,
deprecated_for_removal=True,
deprecated_reason="Replaced by %s option" %
VXFLEXOS_STORAGE_POOLS,
deprecated_since="Pike",
help='Storage Pool ID.'
'Deprecated, use %s instead. ' % VXFLEXOS_STORAGE_POOLS),
cfg.StrOpt(SIO_SERVER_API_VERSION,
help='renamed to %s.' %
VXFLEXOS_SERVER_API_VERSION,
deprecated_for_removal=True,
deprecated_reason='Replaced by %s.' %
VXFLEXOS_SERVER_API_VERSION),
cfg.FloatOpt(SIO_MAX_OVER_SUBSCRIPTION_RATIO,
# This option exists to provide a default value for the
# VxFlex OS driver which is different than the global default.
default=10.0,
help='renamed to %s.' %
VXFLEXOS_MAX_OVER_SUBSCRIPTION_RATIO,
deprecated_for_removal=True,
deprecated_reason='Replaced by %s.' %
VXFLEXOS_MAX_OVER_SUBSCRIPTION_RATIO),
cfg.BoolOpt(SIO_ALLOW_NON_PADDED_VOLUMES,
default=False,
help='renamed to %s.' %
VXFLEXOS_ALLOW_NON_PADDED_VOLUMES,
deprecated_for_removal=True,
deprecated_reason='Replaced by %s.' %
VXFLEXOS_ALLOW_NON_PADDED_VOLUMES),
]
actual_opts = [
cfg.PortOpt(VXFLEXOS_REST_SERVER_PORT,
default=443,
help='Gateway REST server port.',
deprecated_name=SIO_REST_SERVER_PORT),
cfg.BoolOpt(VXFLEXOS_ROUND_VOLUME_CAPACITY,
default=True,
help='Round volume sizes up to 8GB boundaries. '
'VxFlex OS/ScaleIO 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
),
cfg.BoolOpt(VXFLEXOS_UNMAP_VOLUME_BEFORE_DELETION,
default=False,
help='Unmap volumes before deletion.',
deprecated_name=SIO_UNMAP_VOLUME_BEFORE_DELETION),
cfg.StrOpt(VXFLEXOS_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),
cfg.StrOpt(VXFLEXOS_SERVER_API_VERSION,
help='VxFlex OS/ScaleIO API version. This value should be '
'left as the default value unless otherwise instructed '
'by technical support.',
deprecated_name=SIO_SERVER_API_VERSION),
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.
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),
cfg.BoolOpt(VXFLEXOS_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),
]

5
cinder/volume/drivers/dell_emc/scaleio/simplecache.py → cinder/volume/drivers/dell_emc/vxflexos/simplecache.py
View File

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

11
cinder/volume/manager.py
View File

@ -181,13 +181,16 @@ CONF.register_opts(volume_backend_opts, group=config.SHARED_CONF_GROUP)
# to transition. # to transition.
MAPPING = { MAPPING = {
'cinder.volume.drivers.dell_emc.vmax.iscsi.VMAXISCSIDriver': 'cinder.volume.drivers.dell_emc.vmax.iscsi.VMAXISCSIDriver':
'cinder.volume.drivers.dell_emc.powermax.iscsi.PowerMaxISCSIDriver', 'cinder.volume.drivers.dell_emc.powermax.iscsi.PowerMaxISCSIDriver',
'cinder.volume.drivers.dell_emc.vmax.fc.VMAXFCDriver': 'cinder.volume.drivers.dell_emc.vmax.fc.VMAXFCDriver':
'cinder.volume.drivers.dell_emc.powermax.fc.PowerMaxFCDriver', 'cinder.volume.drivers.dell_emc.powermax.fc.PowerMaxFCDriver',
'cinder.volume.drivers.fujitsu.eternus_dx_fc.FJDXFCDriver': 'cinder.volume.drivers.fujitsu.eternus_dx_fc.FJDXFCDriver':
'cinder.volume.drivers.fujitsu.eternus_dx.eternus_dx_fc.FJDXFCDriver', 'cinder.volume.drivers.fujitsu.eternus_dx.eternus_dx_fc.FJDXFCDriver',
'cinder.volume.drivers.fujitsu.eternus_dx_iscsi.FJDXISCSIDriver': 'cinder.volume.drivers.fujitsu.eternus_dx_iscsi.FJDXISCSIDriver':
'cinder.volume.drivers.fujitsu.eternus_dx.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',
} }

38
doc/source/configuration/block-storage/drivers/dell-emc-vxflex-driver.rst
View File

@ -87,7 +87,7 @@ This section explains how to configure and connect the block storage
nodes to a VxFlex OS storage cluster. nodes to a VxFlex OS storage cluster.
Edit the ``cinder.conf`` file by adding the configuration below under Edit the ``cinder.conf`` file by adding the configuration below under
a new section (for example, ``[scaleio]``) and change the ``enable_backends`` a new section (for example, ``[vxflexos]``) and change the ``enable_backends``
setting (in the ``[DEFAULT]`` section) to include this new back end. setting (in the ``[DEFAULT]`` section) to include this new back end.
The configuration file is usually located at The configuration file is usually located at
``/etc/cinder/cinder.conf``. ``/etc/cinder/cinder.conf``.
@ -102,7 +102,7 @@ Configure the driver name by adding the following parameter:
.. code-block:: ini .. code-block:: ini
volume_driver = cinder.volume.drivers.dell_emc.scaleio.driver.ScaleIODriver volume_driver = cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver
VxFlex OS Gateway server IP VxFlex OS Gateway server IP
~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -129,7 +129,7 @@ Configure the available Storage Pools by adding the following parameter:
.. code-block:: ini .. code-block:: ini
sio_storage_pools = <Comma-separated list of protection domain:storage pool name> vxflexos_storage_pools = <Comma-separated list of protection domain:storage pool name>
VxFlex OS user credentials VxFlex OS user credentials
~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -155,11 +155,11 @@ under the separate section for VxFlex OS:
.. code-block:: ini .. code-block:: ini
sio_max_over_subscription_ratio = <OVER_SUBSCRIPTION_RATIO> vxflexos_max_over_subscription_ratio = <OVER_SUBSCRIPTION_RATIO>
.. note:: .. note::
The default value for ``sio_max_over_subscription_ratio`` The default value for ``vxflexos_max_over_subscription_ratio``
is 10.0. is 10.0.
Oversubscription is calculated correctly by the Block Storage service Oversubscription is calculated correctly by the Block Storage service
@ -200,13 +200,13 @@ parameters as follows:
.. code-block:: ini .. code-block:: ini
[DEFAULT] [DEFAULT]
enabled_backends = scaleio enabled_backends = vxflexos
[scaleio] [vxflexos]
volume_driver = cinder.volume.drivers.dell_emc.scaleio.driver.ScaleIODriver volume_driver = cinder.volume.drivers.dell_emc.vxflexos.driver.VxFlexOSDriver
volume_backend_name = scaleio volume_backend_name = vxflexos
san_ip = GATEWAY_IP san_ip = GATEWAY_IP
sio_storage_pools = Domain1:Pool1,Domain2:Pool2 vxflexos_storage_pools = Domain1:Pool1,Domain2:Pool2
san_login = SIO_USER san_login = SIO_USER
san_password = SIO_PASSWD san_password = SIO_PASSWD
san_thin_provision = false san_thin_provision = false
@ -219,9 +219,9 @@ Configuration options
The VxFlex OS driver supports these configuration options: The VxFlex OS driver supports these configuration options:
.. config-table:: .. config-table::
:config-target: ScaleIO :config-target: VxFlex OS
cinder.volume.drivers.dell_emc.scaleio.driver cinder.volume.drivers.dell_emc.vxflexos.driver
Volume Types Volume Types
------------ ------------
@ -240,9 +240,9 @@ requested protection_domain:storage_pool.
.. code-block:: console .. code-block:: console
$ openstack volume type create sio_type_1 $ openstack volume type create vxflexos_type_1
$ openstack volume type set --property volume_backend_name=scaleio sio_type_1 $ openstack volume type set --property volume_backend_name=vxflexos vxflexos_type_1
$ openstack volume type set --property pool_name=Domain2:Pool2 sio_type_1 $ openstack volume type set --property pool_name=Domain2:Pool2 vxflexos_type_1
VxFlex OS thin provisioning support VxFlex OS thin provisioning support
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -254,8 +254,8 @@ of the volume type, as follows:
.. code-block:: console .. code-block:: console
$ openstack volume type create sio_type_thick $ openstack volume type create vxflexos_type_thick
$ openstack volume type set --property provisioning:type=thick sio_type_thick $ openstack volume type set --property provisioning:type=thick vxflexos_type_thick
VxFlex OS QoS support VxFlex OS QoS support
~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~
@ -289,8 +289,8 @@ For example:
.. code-block:: console .. code-block:: console
$ openstack volume qos create qos-limit-iops --consumer back-end --property maxIOPS=5000 $ openstack volume qos create qos-limit-iops --consumer back-end --property maxIOPS=5000
$ openstack volume type create sio_limit_iops $ openstack volume type create vxflexos_limit_iops
$ openstack volume qos associate qos-limit-iops sio_limit_iops $ openstack volume qos associate qos-limit-iops vxflexos_limit_iops
The driver always chooses the minimum between the QoS keys value The driver always chooses the minimum between the QoS keys value
and the relevant calculated value of ``maxIOPSperGB`` or ``maxBWSperGB``. and the relevant calculated value of ``maxIOPSperGB`` or ``maxBWSperGB``.

11
releasenotes/notes/scaleio-vxflexos-rebrand-27dfe2b82d35b6a2.yaml Normal file
View File

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