Adds Unity Cinder Driver
This driver supports both FC and iSCSI protocols and supports below operations: - Create / Delete volume - Extend volume - Attach / Detach volume - Create / Delete snapshot - Copy Image to Volume - Copy Volume to Image - Clone volume - Create volume from snapshot - Manage / Unmanage volume DocImpact Co-Authored-By: Cedric Zhuang <cedric.zhuang@emc.com> Co-Authored-By: Ryan Liang <ryan.liang@emc.com> Implements: blueprint emc-unity-driver Change-Id: I9573a9704342d77e6e5ce5746b8f29c6246af527
This commit is contained in:
Tina
Tina Tang
parent
a6b5a19e0d
commit
5a8f26eb62
|
|
@ -74,6 +74,8 @@ from cinder.volume.drivers.coprhd import scaleio as \
|
|||
from cinder.volume.drivers import datera as cinder_volume_drivers_datera
|
||||
from cinder.volume.drivers.dell import dell_storagecenter_common as \
|
||||
cinder_volume_drivers_dell_dellstoragecentercommon
|
||||
from cinder.volume.drivers.dell_emc.unity import driver as \
|
||||
cinder_volume_drivers_dell_emc_unity_driver
|
||||
from cinder.volume.drivers.disco import disco as \
|
||||
cinder_volume_drivers_disco_disco
|
||||
from cinder.volume.drivers.dothill import dothill_common as \
|
||||
|
|
@ -264,6 +266,7 @@ def list_opts():
|
|||
cinder_volume_drivers_datera.d_opts,
|
||||
cinder_volume_drivers_dell_dellstoragecentercommon.
|
||||
common_opts,
|
||||
cinder_volume_drivers_dell_emc_unity_driver.UNITY_OPTS,
|
||||
cinder_volume_drivers_disco_disco.disco_opts,
|
||||
cinder_volume_drivers_dothill_dothillcommon.common_opts,
|
||||
cinder_volume_drivers_dothill_dothillcommon.iscsi_opts,
|
||||
|
|
|
|||
|
|
@ -0,0 +1,70 @@
|
|||
# Copyright (c) 2016 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.
|
||||
|
||||
|
||||
class StoropsException(Exception):
|
||||
message = 'Storops Error.'
|
||||
|
||||
|
||||
class UnityLunNameInUseError(StoropsException):
|
||||
pass
|
||||
|
||||
|
||||
class UnityResourceNotFoundError(StoropsException):
|
||||
pass
|
||||
|
||||
|
||||
class UnitySnapNameInUseError(StoropsException):
|
||||
pass
|
||||
|
||||
|
||||
class UnityDeleteAttachedSnapError(StoropsException):
|
||||
pass
|
||||
|
||||
|
||||
class UnityResourceAlreadyAttachedError(StoropsException):
|
||||
pass
|
||||
|
||||
|
||||
class UnityPolicyNameInUseError(StoropsException):
|
||||
pass
|
||||
|
||||
|
||||
class UnityNothingToModifyError(StoropsException):
|
||||
pass
|
||||
|
||||
|
||||
class ExtendLunError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class DetachIsCalled(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class LunDeleteIsCalled(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class SnapDeleteIsCalled(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class UnexpectedLunDeletion(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class AdapterSetupError(Exception):
|
||||
pass
|
||||
|
|
@ -0,0 +1,516 @@
|
|||
# Copyright (c) 2016 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.
|
||||
|
||||
import functools
|
||||
import unittest
|
||||
|
||||
import mock
|
||||
|
||||
from cinder import exception
|
||||
from cinder.tests.unit.volume.drivers.dell_emc.unity \
|
||||
import fake_exception as ex
|
||||
from cinder.tests.unit.volume.drivers.dell_emc.unity import test_client
|
||||
from cinder.volume.drivers.dell_emc.unity import adapter
|
||||
|
||||
|
||||
########################
|
||||
#
|
||||
# Start of Mocks
|
||||
#
|
||||
########################
|
||||
class MockConfig(object):
|
||||
def __init__(self):
|
||||
self.unity_storage_pool_names = ['pool1', 'pool2']
|
||||
self.reserved_percentage = 5
|
||||
self.max_over_subscription_ratio = 300
|
||||
self.volume_backend_name = 'backend'
|
||||
self.san_ip = '1.2.3.4'
|
||||
self.san_login = 'user'
|
||||
self.san_password = 'pass'
|
||||
self.driver_ssl_cert_verify = False
|
||||
self.driver_ssl_cert_path = None
|
||||
|
||||
def safe_get(self, name):
|
||||
return getattr(self, name)
|
||||
|
||||
|
||||
class MockConnector(object):
|
||||
@staticmethod
|
||||
def disconnect_volume(data, device):
|
||||
pass
|
||||
|
||||
|
||||
class MockDriver(object):
|
||||
def __init__(self):
|
||||
self.configuration = mock.Mock(volume_dd_blocksize='1M')
|
||||
|
||||
@staticmethod
|
||||
def _connect_device(conn):
|
||||
return {'connector': MockConnector(),
|
||||
'device': {'path': 'dev'},
|
||||
'conn': {'data': {}}}
|
||||
|
||||
|
||||
class MockClient(object):
|
||||
@staticmethod
|
||||
def get_pools():
|
||||
return test_client.MockResourceList(['pool0', 'pool1'])
|
||||
|
||||
@staticmethod
|
||||
def create_lun(name, size, pool, description=None, io_limit_policy=None):
|
||||
return test_client.MockResource(_id='lun_3')
|
||||
|
||||
@staticmethod
|
||||
def get_lun(name=None, lun_id=None):
|
||||
if lun_id is None:
|
||||
lun_id = 'lun_4'
|
||||
if name == 'not_exists':
|
||||
ret = test_client.MockResource(name=lun_id)
|
||||
ret.existed = False
|
||||
else:
|
||||
ret = test_client.MockResource(_id=lun_id)
|
||||
return ret
|
||||
|
||||
@staticmethod
|
||||
def delete_lun(lun_id):
|
||||
if lun_id != 'lun_4':
|
||||
raise ex.UnexpectedLunDeletion()
|
||||
|
||||
@staticmethod
|
||||
def get_serial():
|
||||
return 'CLIENT_SERIAL'
|
||||
|
||||
@staticmethod
|
||||
def create_snap(src_lun_id, name=None):
|
||||
return test_client.MockResource(name=name, _id=src_lun_id)
|
||||
|
||||
@staticmethod
|
||||
def get_snap(name=None):
|
||||
snap = test_client.MockResource(name=name)
|
||||
if name is not None:
|
||||
ret = snap
|
||||
else:
|
||||
ret = [snap]
|
||||
return ret
|
||||
|
||||
@staticmethod
|
||||
def delete_snap(snap):
|
||||
if snap.name in ('abc-def_snap',):
|
||||
raise ex.SnapDeleteIsCalled()
|
||||
|
||||
@staticmethod
|
||||
def create_host(name, uids):
|
||||
return test_client.MockResource(name=name)
|
||||
|
||||
@staticmethod
|
||||
def get_host(name):
|
||||
return test_client.MockResource(name=name)
|
||||
|
||||
@staticmethod
|
||||
def attach(host, lun_or_snap):
|
||||
return 10
|
||||
|
||||
@staticmethod
|
||||
def detach(host, lun_or_snap):
|
||||
error_ids = ['lun_43', 'snap_0']
|
||||
if host.name == 'host1' and lun_or_snap.get_id() in error_ids:
|
||||
raise ex.DetachIsCalled()
|
||||
|
||||
@staticmethod
|
||||
def get_iscsi_target_info():
|
||||
return [{'portal': '1.2.3.4:1234', 'iqn': 'iqn.1-1.com.e:c.a.a0'},
|
||||
{'portal': '1.2.3.5:1234', 'iqn': 'iqn.1-1.com.e:c.a.a1'}]
|
||||
|
||||
@staticmethod
|
||||
def get_fc_target_info(host=None, logged_in_only=False):
|
||||
if host and host.name == 'no_target':
|
||||
ret = []
|
||||
else:
|
||||
ret = ['8899AABBCCDDEEFF', '8899AABBCCDDFFEE']
|
||||
return ret
|
||||
|
||||
@staticmethod
|
||||
def create_lookup_service():
|
||||
return {}
|
||||
|
||||
@staticmethod
|
||||
def get_io_limit_policy(specs):
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def extend_lun(lun_id, size_gib):
|
||||
if size_gib <= 0:
|
||||
raise ex.ExtendLunError
|
||||
|
||||
|
||||
class MockLookupService(object):
|
||||
@staticmethod
|
||||
def get_device_mapping_from_network(initiator_wwns, target_wwns):
|
||||
return {
|
||||
'san_1': {
|
||||
'initiator_port_wwn_list':
|
||||
('200000051e55a100', '200000051e55a121'),
|
||||
'target_port_wwn_list':
|
||||
('100000051e55a100', '100000051e55a121')
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
def mock_adapter(driver_clz):
|
||||
ret = driver_clz()
|
||||
ret._client = MockClient()
|
||||
ret.do_setup(MockDriver(), MockConfig())
|
||||
ret.lookup_service = MockLookupService()
|
||||
return ret
|
||||
|
||||
|
||||
def get_backend_qos_specs(volume):
|
||||
return None
|
||||
|
||||
|
||||
def get_connector_properties():
|
||||
return {'host': 'host1', 'wwpns': 'abcdefg'}
|
||||
|
||||
|
||||
def copy_volume(from_path, to_path, size_in_m, block_size, sparse=True):
|
||||
pass
|
||||
|
||||
|
||||
def get_lun_pl(name):
|
||||
return 'id^%s|system^CLIENT_SERIAL|type^lun|version^None' % name
|
||||
|
||||
|
||||
def patch_for_unity_adapter(func):
|
||||
@functools.wraps(func)
|
||||
@mock.patch('cinder.volume.drivers.dell_emc.unity.utils.'
|
||||
'get_backend_qos_specs',
|
||||
new=get_backend_qos_specs)
|
||||
@mock.patch('cinder.utils.brick_get_connector_properties',
|
||||
new=get_connector_properties)
|
||||
@mock.patch('cinder.volume.utils.copy_volume', new=copy_volume)
|
||||
def func_wrapper(*args, **kwargs):
|
||||
return func(*args, **kwargs)
|
||||
|
||||
return func_wrapper
|
||||
|
||||
|
||||
########################
|
||||
#
|
||||
# Start of Tests
|
||||
#
|
||||
########################
|
||||
class CommonAdapterTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.adapter = mock_adapter(adapter.CommonAdapter)
|
||||
|
||||
def test_get_managed_pools(self):
|
||||
ret = self.adapter.get_managed_pools()
|
||||
self.assertIn('pool1', ret)
|
||||
self.assertNotIn('pool0', ret)
|
||||
self.assertNotIn('pool2', ret)
|
||||
|
||||
@patch_for_unity_adapter
|
||||
def test_create_volume(self):
|
||||
volume = mock.Mock(size=5, host='unity#pool1')
|
||||
ret = self.adapter.create_volume(volume)
|
||||
expected = get_lun_pl('lun_3')
|
||||
self.assertEqual(expected, ret['provider_location'])
|
||||
|
||||
def test_create_snapshot(self):
|
||||
volume = mock.Mock(provider_location='id^lun_43')
|
||||
snap = mock.Mock(volume=volume)
|
||||
snap.name = 'abc-def_snap'
|
||||
result = self.adapter.create_snapshot(snap)
|
||||
self.assertEqual('abc-def_snap', result.name)
|
||||
self.assertEqual('lun_43', result.get_id())
|
||||
|
||||
def test_delete_snap(self):
|
||||
def f():
|
||||
snap = mock.Mock()
|
||||
snap.name = 'abc-def_snap'
|
||||
|
||||
self.adapter.delete_snapshot(snap)
|
||||
|
||||
self.assertRaises(ex.SnapDeleteIsCalled, f)
|
||||
|
||||
def test_get_lun_id_has_location(self):
|
||||
volume = mock.Mock(provider_location='id^lun_43')
|
||||
self.assertEqual('lun_43', self.adapter.get_lun_id(volume))
|
||||
|
||||
def test_get_lun_id_no_location(self):
|
||||
volume = mock.Mock(provider_location=None)
|
||||
self.assertEqual('lun_4', self.adapter.get_lun_id(volume))
|
||||
|
||||
def test_delete_volume(self):
|
||||
volume = mock.Mock(provider_location='id^lun_4')
|
||||
self.adapter.delete_volume(volume)
|
||||
|
||||
def test_get_pool_stats(self):
|
||||
stats_list = self.adapter.get_pools_stats()
|
||||
self.assertEqual(1, len(stats_list))
|
||||
|
||||
stats = stats_list[0]
|
||||
self.assertEqual('pool1', stats['pool_name'])
|
||||
self.assertEqual(5, stats['total_capacity_gb'])
|
||||
self.assertEqual('pool1|CLIENT_SERIAL', stats['location_info'])
|
||||
self.assertEqual(6, stats['provisioned_capacity_gb'])
|
||||
self.assertEqual(2, stats['free_capacity_gb'])
|
||||
self.assertEqual(300, stats['max_over_subscription_ratio'])
|
||||
self.assertEqual(5, stats['reserved_percentage'])
|
||||
self.assertFalse(stats['thick_provisioning_support'])
|
||||
self.assertTrue(stats['thin_provisioning_support'])
|
||||
|
||||
def test_update_volume_stats(self):
|
||||
stats = self.adapter.update_volume_stats()
|
||||
self.assertEqual('backend', stats['volume_backend_name'])
|
||||
self.assertEqual('unknown', stats['storage_protocol'])
|
||||
self.assertTrue(stats['thin_provisioning_support'])
|
||||
self.assertFalse(stats['thick_provisioning_support'])
|
||||
self.assertEqual(1, len(stats['pools']))
|
||||
|
||||
def test_serial_number(self):
|
||||
self.assertEqual('CLIENT_SERIAL', self.adapter.serial_number)
|
||||
|
||||
def test_do_setup(self):
|
||||
self.assertEqual('1.2.3.4', self.adapter.ip)
|
||||
self.assertEqual('user', self.adapter.username)
|
||||
self.assertEqual('pass', self.adapter.password)
|
||||
self.assertFalse(self.adapter.array_cert_verify)
|
||||
self.assertIsNone(self.adapter.array_ca_cert_path)
|
||||
|
||||
def test_verify_cert_false_path_none(self):
|
||||
self.adapter.array_cert_verify = False
|
||||
self.adapter.array_ca_cert_path = None
|
||||
self.assertFalse(self.adapter.verify_cert)
|
||||
|
||||
def test_verify_cert_false_path_not_none(self):
|
||||
self.adapter.array_cert_verify = False
|
||||
self.adapter.array_ca_cert_path = '/tmp/array_ca.crt'
|
||||
self.assertFalse(self.adapter.verify_cert)
|
||||
|
||||
def test_verify_cert_true_path_none(self):
|
||||
self.adapter.array_cert_verify = True
|
||||
self.adapter.array_ca_cert_path = None
|
||||
self.assertTrue(self.adapter.verify_cert)
|
||||
|
||||
def test_verify_cert_true_path_valide(self):
|
||||
self.adapter.array_cert_verify = True
|
||||
self.adapter.array_ca_cert_path = '/tmp/array_ca.crt'
|
||||
self.assertEqual(self.adapter.array_ca_cert_path,
|
||||
self.adapter.verify_cert)
|
||||
|
||||
def test_initialize_connection_common(self):
|
||||
volume = mock.Mock(provider_location='id^lun_43', id='id_43')
|
||||
connector = {'host': 'host1'}
|
||||
data = self.adapter.initialize_connection(volume, connector)['data']
|
||||
self.assertTrue(data['target_discovered'])
|
||||
self.assertEqual('id_43', data['volume_id'])
|
||||
|
||||
def test_initialize_connection_for_resource(self):
|
||||
snap = test_client.MockResource(_id='snap_1')
|
||||
connector = {'host': 'host1'}
|
||||
data = self.adapter._initialize_connection(
|
||||
snap, connector, 'snap_1')['data']
|
||||
self.assertTrue(data['target_discovered'])
|
||||
self.assertEqual('snap_1', data['volume_id'])
|
||||
|
||||
def test_terminate_connection_common(self):
|
||||
def f():
|
||||
volume = mock.Mock(provider_location='id^lun_43', id='id_43')
|
||||
connector = {'host': 'host1'}
|
||||
self.adapter.terminate_connection(volume, connector)
|
||||
|
||||
self.assertRaises(ex.DetachIsCalled, f)
|
||||
|
||||
def test_terminate_connection_snap(self):
|
||||
def f():
|
||||
connector = {'host': 'host1'}
|
||||
snap = test_client.MockResource(_id='snap_0')
|
||||
self.adapter._terminate_connection(snap, connector)
|
||||
|
||||
self.assertRaises(ex.DetachIsCalled, f)
|
||||
|
||||
def test_manage_existing_by_name(self):
|
||||
ref = {'source-id': 12}
|
||||
volume = mock.Mock(name='lun1')
|
||||
ret = self.adapter.manage_existing(volume, ref)
|
||||
expected = get_lun_pl('12')
|
||||
self.assertEqual(expected, ret['provider_location'])
|
||||
|
||||
def test_manage_existing_by_id(self):
|
||||
ref = {'source-name': 'lunx'}
|
||||
volume = mock.Mock(name='lun1')
|
||||
ret = self.adapter.manage_existing(volume, ref)
|
||||
expected = get_lun_pl('lun_4')
|
||||
self.assertEqual(expected, ret['provider_location'])
|
||||
|
||||
def test_manage_existing_invalid_ref(self):
|
||||
def f():
|
||||
ref = {}
|
||||
volume = mock.Mock(name='lun1')
|
||||
self.adapter.manage_existing(volume, ref)
|
||||
|
||||
self.assertRaises(exception.ManageExistingInvalidReference, f)
|
||||
|
||||
def test_manage_existing_lun_not_found(self):
|
||||
def f():
|
||||
ref = {'source-name': 'not_exists'}
|
||||
volume = mock.Mock(name='lun1')
|
||||
self.adapter.manage_existing(volume, ref)
|
||||
|
||||
self.assertRaises(exception.ManageExistingInvalidReference, f)
|
||||
|
||||
@patch_for_unity_adapter
|
||||
def test_manage_existing_get_size_invalid_backend(self):
|
||||
def f():
|
||||
volume = mock.Mock(volume_type_id='thin',
|
||||
host='host@backend#pool1')
|
||||
ref = {'source-id': 12}
|
||||
self.adapter.manage_existing_get_size(volume, ref)
|
||||
|
||||
self.assertRaises(exception.ManageExistingInvalidReference, f)
|
||||
|
||||
@patch_for_unity_adapter
|
||||
def test_manage_existing_get_size_success(self):
|
||||
volume = mock.Mock(volume_type_id='thin', host='host@backend#pool0')
|
||||
ref = {'source-id': 12}
|
||||
volume_size = self.adapter.manage_existing_get_size(volume, ref)
|
||||
self.assertEqual(5, volume_size)
|
||||
|
||||
@patch_for_unity_adapter
|
||||
def test_create_volume_from_snapshot(self):
|
||||
volume = mock.Mock(id='id_44', host='unity#pool1',
|
||||
provider_location=get_lun_pl('12'))
|
||||
snap = mock.Mock(name='snap_44')
|
||||
ret = self.adapter.create_volume_from_snapshot(volume, snap)
|
||||
self.assertEqual(get_lun_pl('lun_3'), ret['provider_location'])
|
||||
|
||||
@patch_for_unity_adapter
|
||||
def test_create_cloned_volume(self):
|
||||
volume = mock.Mock(id='id_55', host='unity#pool1', size=3,
|
||||
provider_location=get_lun_pl('lun55'))
|
||||
src_vref = mock.Mock(id='id_66', name='LUN 66',
|
||||
provider_location=get_lun_pl('lun66'))
|
||||
ret = self.adapter.create_cloned_volume(volume, src_vref)
|
||||
self.assertEqual(get_lun_pl('lun_3'), ret['provider_location'])
|
||||
|
||||
def test_extend_volume_error(self):
|
||||
def f():
|
||||
volume = mock.Mock(id='l56', provider_location=get_lun_pl('lun56'))
|
||||
self.adapter.extend_volume(volume, -1)
|
||||
|
||||
self.assertRaises(ex.ExtendLunError, f)
|
||||
|
||||
def test_extend_volume_no_id(self):
|
||||
def f():
|
||||
volume = mock.Mock(provider_location='type^lun')
|
||||
self.adapter.extend_volume(volume, 5)
|
||||
|
||||
self.assertRaises(exception.VolumeBackendAPIException, f)
|
||||
|
||||
|
||||
class FCAdapterTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.adapter = mock_adapter(adapter.FCAdapter)
|
||||
|
||||
def test_setup(self):
|
||||
self.assertIsNotNone(self.adapter.lookup_service)
|
||||
|
||||
def test_auto_zone_enabled(self):
|
||||
self.assertTrue(self.adapter.auto_zone_enabled)
|
||||
|
||||
def test_fc_protocol(self):
|
||||
stats = mock_adapter(adapter.FCAdapter).update_volume_stats()
|
||||
self.assertEqual('FC', stats['storage_protocol'])
|
||||
|
||||
def test_get_connector_uids(self):
|
||||
connector = {'host': 'fake_host',
|
||||
'wwnns': ['1111111111111111',
|
||||
'2222222222222222'],
|
||||
'wwpns': ['3333333333333333',
|
||||
'4444444444444444']
|
||||
}
|
||||
expected = ['11:11:11:11:11:11:11:11:33:33:33:33:33:33:33:33',
|
||||
'22:22:22:22:22:22:22:22:44:44:44:44:44:44:44:44']
|
||||
ret = self.adapter.get_connector_uids(connector)
|
||||
self.assertListEqual(expected, ret)
|
||||
|
||||
def test_get_connection_info_no_targets(self):
|
||||
def f():
|
||||
host = test_client.MockResource('no_target')
|
||||
self.adapter.get_connection_info(12, host, {})
|
||||
|
||||
self.assertRaises(exception.VolumeBackendAPIException, f)
|
||||
|
||||
def test_get_connection_info_auto_zone_enabled(self):
|
||||
host = test_client.MockResource('host1')
|
||||
connector = {'wwpns': 'abcdefg'}
|
||||
ret = self.adapter.get_connection_info(10, host, connector)
|
||||
target_wwns = ['100000051e55a100', '100000051e55a121']
|
||||
self.assertListEqual(target_wwns, ret['target_wwn'])
|
||||
init_target_map = {
|
||||
'200000051e55a100': ('100000051e55a100', '100000051e55a121'),
|
||||
'200000051e55a121': ('100000051e55a100', '100000051e55a121')}
|
||||
self.assertDictEqual(init_target_map, ret['initiator_target_map'])
|
||||
self.assertEqual(10, ret['target_lun'])
|
||||
|
||||
def test_get_connection_info_auto_zone_disabled(self):
|
||||
self.adapter.lookup_service = None
|
||||
host = test_client.MockResource('host1')
|
||||
connector = {'wwpns': 'abcdefg'}
|
||||
ret = self.adapter.get_connection_info(10, host, connector)
|
||||
self.assertEqual(10, ret['target_lun'])
|
||||
wwns = ['8899AABBCCDDEEFF', '8899AABBCCDDFFEE']
|
||||
self.assertListEqual(wwns, ret['target_wwn'])
|
||||
|
||||
def test_terminate_connection_auto_zone_enabled(self):
|
||||
connector = {'host': 'host1', 'wwpns': 'abcdefg'}
|
||||
volume = mock.Mock(provider_location='id^lun_41', id='id_41')
|
||||
ret = self.adapter.terminate_connection(volume, connector)
|
||||
self.assertEqual('fibre_channel', ret['driver_volume_type'])
|
||||
data = ret['data']
|
||||
target_map = {
|
||||
'200000051e55a100': ('100000051e55a100', '100000051e55a121'),
|
||||
'200000051e55a121': ('100000051e55a100', '100000051e55a121')}
|
||||
self.assertDictEqual(target_map, data['initiator_target_map'])
|
||||
target_wwn = ['100000051e55a100', '100000051e55a121']
|
||||
self.assertListEqual(target_wwn, data['target_wwn'])
|
||||
|
||||
|
||||
class ISCSIAdapterTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.adapter = mock_adapter(adapter.ISCSIAdapter)
|
||||
|
||||
def test_iscsi_protocol(self):
|
||||
stats = self.adapter.update_volume_stats()
|
||||
self.assertEqual('iSCSI', stats['storage_protocol'])
|
||||
|
||||
def test_get_connector_uids(self):
|
||||
connector = {'host': 'fake_host', 'initiator': 'fake_iqn'}
|
||||
ret = self.adapter.get_connector_uids(connector)
|
||||
self.assertListEqual(['fake_iqn'], ret)
|
||||
|
||||
def test_get_connection_info(self):
|
||||
connector = {'host': 'fake_host', 'initiator': 'fake_iqn'}
|
||||
hlu = 10
|
||||
info = self.adapter.get_connection_info(hlu, None, connector)
|
||||
target_iqns = ['iqn.1-1.com.e:c.a.a0', 'iqn.1-1.com.e:c.a.a1']
|
||||
target_portals = ['1.2.3.4:1234', '1.2.3.5:1234']
|
||||
self.assertListEqual(target_iqns, info['target_iqns'])
|
||||
self.assertListEqual([hlu, hlu], info['target_luns'])
|
||||
self.assertListEqual(target_portals, info['target_portals'])
|
||||
self.assertEqual(hlu, info['target_lun'])
|
||||
self.assertTrue(info['target_portal'] in target_portals)
|
||||
self.assertTrue(info['target_iqn'] in target_iqns)
|
||||
|
|
@ -0,0 +1,433 @@
|
|||
# Copyright (c) 2016 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.
|
||||
|
||||
import unittest
|
||||
|
||||
from mock import mock
|
||||
from oslo_utils import units
|
||||
|
||||
from cinder.tests.unit.volume.drivers.dell_emc.unity \
|
||||
import fake_exception as ex
|
||||
from cinder.volume.drivers.dell_emc.unity import client
|
||||
|
||||
|
||||
########################
|
||||
#
|
||||
# Start of Mocks
|
||||
#
|
||||
########################
|
||||
|
||||
|
||||
class MockResource(object):
|
||||
def __init__(self, name=None, _id=None):
|
||||
self.name = name
|
||||
self._id = _id
|
||||
self.existed = True
|
||||
self.size_total = 5 * units.Gi
|
||||
self.size_subscribed = 6 * units.Gi
|
||||
self.size_free = 2 * units.Gi
|
||||
self.is_auto_delete = None
|
||||
self.initiator_id = []
|
||||
self.alu_hlu_map = {'already_attached': 99}
|
||||
self.ip_address = None
|
||||
self.is_logged_in = None
|
||||
self.wwn = None
|
||||
self.max_iops = None
|
||||
self.max_kbps = None
|
||||
self.pool_name = 'Pool0'
|
||||
|
||||
def get_id(self):
|
||||
return self._id
|
||||
|
||||
def delete(self):
|
||||
if self.get_id() in ['snap_2']:
|
||||
raise ex.SnapDeleteIsCalled()
|
||||
elif self.get_id() == 'not_found':
|
||||
raise ex.UnityResourceNotFoundError()
|
||||
elif self.get_id() == 'snap_in_use':
|
||||
raise ex.UnityDeleteAttachedSnapError()
|
||||
|
||||
@property
|
||||
def pool(self):
|
||||
return MockResource('pool0')
|
||||
|
||||
@property
|
||||
def iscsi_host_initiators(self):
|
||||
iscsi_initiator = MockResource('iscsi_initiator')
|
||||
iscsi_initiator.initiator_id = ['iqn.1-1.com.e:c.host.0',
|
||||
'iqn.1-1.com.e:c.host.1']
|
||||
return iscsi_initiator
|
||||
|
||||
@property
|
||||
def total_size_gb(self):
|
||||
return self.size_total / units.Gi
|
||||
|
||||
@total_size_gb.setter
|
||||
def total_size_gb(self, value):
|
||||
if value == self.total_size_gb:
|
||||
raise ex.UnityNothingToModifyError()
|
||||
else:
|
||||
self.size_total = value * units.Gi
|
||||
|
||||
def add_initiator(self, uid, force_create=None):
|
||||
self.initiator_id.append(uid)
|
||||
|
||||
def attach(self, lun_or_snap, skip_hlu_0=True):
|
||||
if lun_or_snap.get_id() == 'already_attached':
|
||||
raise ex.UnityResourceAlreadyAttachedError()
|
||||
self.alu_hlu_map[lun_or_snap.get_id()] = len(self.alu_hlu_map)
|
||||
return self.get_hlu(lun_or_snap)
|
||||
|
||||
@staticmethod
|
||||
def detach(lun_or_snap):
|
||||
if lun_or_snap.name == 'detach_failure':
|
||||
raise ex.DetachIsCalled()
|
||||
|
||||
def get_hlu(self, lun):
|
||||
return self.alu_hlu_map.get(lun.get_id(), None)
|
||||
|
||||
@staticmethod
|
||||
def create_lun(lun_name, size_gb, description=None, io_limit_policy=None):
|
||||
if lun_name == 'in_use':
|
||||
raise ex.UnityLunNameInUseError()
|
||||
ret = MockResource(lun_name, 'lun_2')
|
||||
if io_limit_policy is not None:
|
||||
ret.max_iops = io_limit_policy.max_iops
|
||||
ret.max_kbps = io_limit_policy.max_kbps
|
||||
return ret
|
||||
|
||||
@staticmethod
|
||||
def create_snap(name, is_auto_delete=False):
|
||||
if name == 'in_use':
|
||||
raise ex.UnitySnapNameInUseError()
|
||||
ret = MockResource(name)
|
||||
ret.is_auto_delete = is_auto_delete
|
||||
return ret
|
||||
|
||||
@staticmethod
|
||||
def update(data=None):
|
||||
pass
|
||||
|
||||
@property
|
||||
def iscsi_node(self):
|
||||
name = 'iqn.1-1.com.e:c.%s.0' % self.name
|
||||
return MockResource(name)
|
||||
|
||||
@property
|
||||
def fc_host_initiators(self):
|
||||
init0 = MockResource('fhi_0')
|
||||
init0.initiator_id = '00:11:22:33:44:55:66:77:88:99:AA:BB:CC:CD:EE:FF'
|
||||
init1 = MockResource('fhi_1')
|
||||
init1.initiator_id = '00:11:22:33:44:55:66:77:88:99:AA:BB:BC:CD:EE:FF'
|
||||
return MockResourceList.create(init0, init1)
|
||||
|
||||
@property
|
||||
def paths(self):
|
||||
path0 = MockResource('%s_path_0' % self.name)
|
||||
path0.is_logged_in = True
|
||||
path1 = MockResource('%s_path_1' % self.name)
|
||||
path1.is_logged_in = False
|
||||
path2 = MockResource('%s_path_2' % self.name)
|
||||
path2.is_logged_in = True
|
||||
return [path0, path1]
|
||||
|
||||
@property
|
||||
def fc_port(self):
|
||||
ret = MockResource()
|
||||
ret.wwn = '00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF'
|
||||
return ret
|
||||
|
||||
@property
|
||||
def host_luns(self):
|
||||
return []
|
||||
|
||||
@property
|
||||
def storage_resource(self):
|
||||
return MockResource(_id='sr_%s' % self._id,
|
||||
name='sr_%s' % self.name)
|
||||
|
||||
def modify(self, name=None):
|
||||
self.name = name
|
||||
|
||||
|
||||
class MockResourceList(object):
|
||||
def __init__(self, names):
|
||||
self.resources = [MockResource(name) for name in names]
|
||||
|
||||
@staticmethod
|
||||
def create(*rsc_list):
|
||||
ret = MockResourceList([])
|
||||
ret.resources = rsc_list
|
||||
return ret
|
||||
|
||||
@property
|
||||
def name(self):
|
||||
return map(lambda i: i.name, self.resources)
|
||||
|
||||
def __iter__(self):
|
||||
return self.resources.__iter__()
|
||||
|
||||
def __len__(self):
|
||||
return len(self.resources)
|
||||
|
||||
def __getattr__(self, item):
|
||||
return [getattr(i, item) for i in self.resources]
|
||||
|
||||
|
||||
class MockSystem(object):
|
||||
def __init__(self):
|
||||
self.serial_number = 'SYSTEM_SERIAL'
|
||||
|
||||
@staticmethod
|
||||
def get_lun(_id=None, name=None):
|
||||
if _id == 'not_found':
|
||||
raise ex.UnityResourceNotFoundError()
|
||||
return MockResource(name, _id)
|
||||
|
||||
@staticmethod
|
||||
def get_pool():
|
||||
return MockResourceList(['Pool 1', 'Pool 2'])
|
||||
|
||||
@staticmethod
|
||||
def get_snap(name):
|
||||
if name == 'not_found':
|
||||
raise ex.UnityResourceNotFoundError()
|
||||
return MockResource(name)
|
||||
|
||||
@staticmethod
|
||||
def create_host(name):
|
||||
return MockResource(name)
|
||||
|
||||
@staticmethod
|
||||
def get_host(name):
|
||||
if name == 'not_found':
|
||||
raise ex.UnityResourceNotFoundError()
|
||||
return MockResource(name)
|
||||
|
||||
@staticmethod
|
||||
def get_iscsi_portal():
|
||||
portal0 = MockResource('p0')
|
||||
portal0.ip_address = '1.1.1.1'
|
||||
portal1 = MockResource('p1')
|
||||
portal1.ip_address = '1.1.1.2'
|
||||
return [portal0, portal1]
|
||||
|
||||
@staticmethod
|
||||
def get_fc_port():
|
||||
port0 = MockResource('fcp0')
|
||||
port0.wwn = '00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF'
|
||||
port1 = MockResource('fcp1')
|
||||
port1.wwn = '00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:FF:EE'
|
||||
return [port0, port1]
|
||||
|
||||
@staticmethod
|
||||
def create_io_limit_policy(name, max_iops=None, max_kbps=None):
|
||||
if name == 'in_use':
|
||||
raise ex.UnityPolicyNameInUseError()
|
||||
ret = MockResource(name)
|
||||
ret.max_iops = max_iops
|
||||
ret.max_kbps = max_kbps
|
||||
return ret
|
||||
|
||||
@staticmethod
|
||||
def get_io_limit_policy(name):
|
||||
return MockResource(name=name)
|
||||
|
||||
|
||||
@mock.patch.object(client, 'storops', new='True')
|
||||
def get_client():
|
||||
ret = client.UnityClient('1.2.3.4', 'user', 'pass')
|
||||
ret._system = MockSystem()
|
||||
return ret
|
||||
|
||||
|
||||
########################
|
||||
#
|
||||
# Start of Tests
|
||||
#
|
||||
########################
|
||||
@mock.patch.object(client, 'storops_ex', new=ex)
|
||||
class ClientTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.client = get_client()
|
||||
|
||||
def test_get_serial(self):
|
||||
self.assertEqual('SYSTEM_SERIAL', self.client.get_serial())
|
||||
|
||||
def test_create_lun_success(self):
|
||||
name = 'LUN 3'
|
||||
pool = MockResource('Pool 0')
|
||||
lun = self.client.create_lun(name, 5, pool)
|
||||
self.assertEqual(name, lun.name)
|
||||
|
||||
def test_create_lun_name_in_use(self):
|
||||
name = 'in_use'
|
||||
pool = MockResource('Pool 0')
|
||||
lun = self.client.create_lun(name, 6, pool)
|
||||
self.assertEqual('in_use', lun.name)
|
||||
|
||||
def test_create_lun_with_io_limit(self):
|
||||
pool = MockResource('Pool 0')
|
||||
limit = MockResource('limit')
|
||||
limit.max_kbps = 100
|
||||
lun = self.client.create_lun('LUN 4', 6, pool, io_limit_policy=limit)
|
||||
self.assertEqual(100, lun.max_kbps)
|
||||
|
||||
def test_delete_lun_normal(self):
|
||||
self.assertIsNone(self.client.delete_lun('lun3'))
|
||||
|
||||
def test_delete_lun_not_found(self):
|
||||
try:
|
||||
self.client.delete_lun('not_found')
|
||||
except ex.StoropsException:
|
||||
self.fail('not found error should be dealt with silently.')
|
||||
|
||||
def test_get_lun_with_id(self):
|
||||
lun = self.client.get_lun('lun4')
|
||||
self.assertEqual('lun4', lun.get_id())
|
||||
|
||||
def test_get_lun_with_name(self):
|
||||
lun = self.client.get_lun(name='LUN 4')
|
||||
self.assertEqual('LUN 4', lun.name)
|
||||
|
||||
def test_get_lun_not_found(self):
|
||||
ret = self.client.get_lun(lun_id='not_found')
|
||||
self.assertIsNone(ret)
|
||||
|
||||
def test_get_pools(self):
|
||||
pools = self.client.get_pools()
|
||||
self.assertEqual(2, len(pools))
|
||||
|
||||
def test_create_snap_normal(self):
|
||||
snap = self.client.create_snap('lun_1', 'snap_1')
|
||||
self.assertEqual('snap_1', snap.name)
|
||||
|
||||
def test_create_snap_in_use(self):
|
||||
snap = self.client.create_snap('lun_1', 'in_use')
|
||||
self.assertEqual('in_use', snap.name)
|
||||
|
||||
def test_delete_snap_error(self):
|
||||
def f():
|
||||
snap = MockResource(_id='snap_2')
|
||||
self.client.delete_snap(snap)
|
||||
|
||||
self.assertRaises(ex.SnapDeleteIsCalled, f)
|
||||
|
||||
def test_delete_snap_not_found(self):
|
||||
try:
|
||||
snap = MockResource(_id='not_found')
|
||||
self.client.delete_snap(snap)
|
||||
except ex.StoropsException:
|
||||
self.fail('snap not found should not raise exception.')
|
||||
|
||||
def test_delete_snap_none(self):
|
||||
try:
|
||||
ret = self.client.delete_snap(None)
|
||||
self.assertIsNone(ret)
|
||||
except ex.StoropsException:
|
||||
self.fail('delete none should not raise exception.')
|
||||
|
||||
def test_delete_snap_in_use(self):
|
||||
def f():
|
||||
snap = MockResource(_id='snap_in_use')
|
||||
self.client.delete_snap(snap)
|
||||
|
||||
self.assertRaises(ex.UnityDeleteAttachedSnapError, f)
|
||||
|
||||
def test_get_snap_found(self):
|
||||
snap = self.client.get_snap('snap_2')
|
||||
self.assertEqual('snap_2', snap.name)
|
||||
|
||||
def test_get_snap_not_found(self):
|
||||
ret = self.client.get_snap('not_found')
|
||||
self.assertIsNone(ret)
|
||||
|
||||
def test_create_host_found(self):
|
||||
iqns = ['iqn.1-1.com.e:c.a.a0']
|
||||
host = self.client.create_host('host1', iqns)
|
||||
|
||||
self.assertEqual('host1', host.name)
|
||||
self.assertLessEqual(['iqn.1-1.com.e:c.a.a0'], host.initiator_id)
|
||||
|
||||
def test_create_host_not_found(self):
|
||||
host = self.client.create_host('not_found', [])
|
||||
self.assertEqual('not_found', host.name)
|
||||
|
||||
def test_attach_lun(self):
|
||||
lun = MockResource(_id='lun1', name='l1')
|
||||
host = MockResource('host1')
|
||||
self.assertEqual(1, self.client.attach(host, lun))
|
||||
|
||||
def test_attach_already_attached(self):
|
||||
lun = MockResource(_id='already_attached')
|
||||
host = MockResource('host1')
|
||||
hlu = self.client.attach(host, lun)
|
||||
self.assertEqual(99, hlu)
|
||||
|
||||
def test_detach_lun(self):
|
||||
def f():
|
||||
lun = MockResource('detach_failure')
|
||||
host = MockResource('host1')
|
||||
self.client.detach(host, lun)
|
||||
|
||||
self.assertRaises(ex.DetachIsCalled, f)
|
||||
|
||||
def test_get_host(self):
|
||||
self.assertEqual('host2', self.client.get_host('host2').name)
|
||||
|
||||
def test_get_iscsi_target_info(self):
|
||||
ret = self.client.get_iscsi_target_info()
|
||||
expected = [{'iqn': 'iqn.1-1.com.e:c.p0.0', 'portal': '1.1.1.1:3260'},
|
||||
{'iqn': 'iqn.1-1.com.e:c.p1.0', 'portal': '1.1.1.2:3260'}]
|
||||
self.assertListEqual(expected, ret)
|
||||
|
||||
def test_get_fc_target_info_without_host(self):
|
||||
ret = self.client.get_fc_target_info()
|
||||
self.assertListEqual(['8899AABBCCDDEEFF', '8899AABBCCDDFFEE'], ret)
|
||||
|
||||
def test_get_fc_target_info_with_host(self):
|
||||
host = MockResource('host0')
|
||||
ret = self.client.get_fc_target_info(host, True)
|
||||
self.assertListEqual(['8899AABBCCDDEEFF', '8899AABBCCDDEEFF'], ret)
|
||||
|
||||
def test_get_io_limit_policy_none(self):
|
||||
ret = self.client.get_io_limit_policy(None)
|
||||
self.assertIsNone(ret)
|
||||
|
||||
def test_get_io_limit_policy_create_new(self):
|
||||
specs = {'maxBWS': 2, 'id': 'max_2_mbps', 'maxIOPS': None}
|
||||
limit = self.client.get_io_limit_policy(specs)
|
||||
self.assertEqual('max_2_mbps', limit.name)
|
||||
self.assertEqual(2, limit.max_kbps)
|
||||
|
||||
def test_create_io_limit_policy_success(self):
|
||||
limit = self.client.create_io_limit_policy('3kiops', max_iops=3000)
|
||||
self.assertEqual('3kiops', limit.name)
|
||||
self.assertEqual(3000, limit.max_iops)
|
||||
|
||||
def test_create_io_limit_policy_in_use(self):
|
||||
limit = self.client.create_io_limit_policy('in_use', max_iops=100)
|
||||
self.assertEqual('in_use', limit.name)
|
||||
|
||||
def test_expand_lun_success(self):
|
||||
lun = self.client.extend_lun('ev_3', 6)
|
||||
self.assertEqual(6, lun.total_size_gb)
|
||||
|
||||
def test_expand_lun_nothing_to_modify(self):
|
||||
lun = self.client.extend_lun('ev_4', 5)
|
||||
self.assertEqual(5, lun.total_size_gb)
|
||||
|
||||
def test_get_pool_name(self):
|
||||
self.assertEqual('Pool0', self.client.get_pool_name('lun_0'))
|
||||
|
|
@ -0,0 +1,234 @@
|
|||
# Copyright (c) 2016 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.
|
||||
|
||||
import unittest
|
||||
|
||||
import mock
|
||||
|
||||
from cinder.tests.unit.volume.drivers.dell_emc.unity \
|
||||
import fake_exception as ex
|
||||
from cinder.volume import configuration as conf
|
||||
from cinder.volume.drivers.dell_emc.unity import driver
|
||||
|
||||
|
||||
########################
|
||||
#
|
||||
# Start of Mocks
|
||||
#
|
||||
########################
|
||||
|
||||
class MockAdapter(object):
|
||||
def do_setup(self, driver_object, configuration):
|
||||
raise ex.AdapterSetupError()
|
||||
|
||||
@staticmethod
|
||||
def create_volume(volume):
|
||||
return volume
|
||||
|
||||
@staticmethod
|
||||
def create_volume_from_snapshot(volume, snapshot):
|
||||
return volume
|
||||
|
||||
@staticmethod
|
||||
def create_cloned_volume(volume, src_vref):
|
||||
return volume
|
||||
|
||||
@staticmethod
|
||||
def extend_volume(volume, new_size):
|
||||
volume.size = new_size
|
||||
|
||||
@staticmethod
|
||||
def delete_volume(volume):
|
||||
volume.exists = False
|
||||
|
||||
@staticmethod
|
||||
def create_snapshot(snapshot):
|
||||
snapshot.exists = True
|
||||
|
||||
@staticmethod
|
||||
def delete_snapshot(snapshot):
|
||||
snapshot.exists = False
|
||||
|
||||
@staticmethod
|
||||
def initialize_connection(volume, connector):
|
||||
return {'volume': volume, 'connector': connector}
|
||||
|
||||
@staticmethod
|
||||
def terminate_connection(volume, connector):
|
||||
return {'volume': volume, 'connector': connector}
|
||||
|
||||
@staticmethod
|
||||
def update_volume_stats():
|
||||
return {'stats': 123}
|
||||
|
||||
@staticmethod
|
||||
def manage_existing(volume, existing_ref):
|
||||
volume.managed = True
|
||||
return volume
|
||||
|
||||
@staticmethod
|
||||
def manage_existing_get_size(volume, existing_ref):
|
||||
volume.managed = True
|
||||
volume.size = 7
|
||||
return volume
|
||||
|
||||
@staticmethod
|
||||
def get_pool_name(volume):
|
||||
return 'pool_0'
|
||||
|
||||
|
||||
########################
|
||||
#
|
||||
# Start of Tests
|
||||
#
|
||||
########################
|
||||
|
||||
class UnityDriverTest(unittest.TestCase):
|
||||
@staticmethod
|
||||
def get_volume():
|
||||
return mock.Mock(provider_location='id^lun_43', id='id_43')
|
||||
|
||||
@classmethod
|
||||
def get_snapshot(cls):
|
||||
return mock.Mock(volume=cls.get_volume())
|
||||
|
||||
@staticmethod
|
||||
def get_context():
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def get_connector():
|
||||
return {'host': 'host1'}
|
||||
|
||||
def setUp(self):
|
||||
self.config = conf.Configuration(None)
|
||||
self.driver = driver.UnityDriver(configuration=self.config)
|
||||
self.driver.adapter = MockAdapter()
|
||||
|
||||
def test_default_initialize(self):
|
||||
config = conf.Configuration(None)
|
||||
iscsi_driver = driver.UnityDriver(configuration=config)
|
||||
self.assertIsNone(config.unity_storage_pool_names)
|
||||
self.assertTrue(config.san_thin_provision)
|
||||
self.assertEqual('', config.san_ip)
|
||||
self.assertEqual('admin', config.san_login)
|
||||
self.assertEqual('', config.san_password)
|
||||
self.assertEqual('', config.san_private_key)
|
||||
self.assertEqual('', config.san_clustername)
|
||||
self.assertEqual(22, config.san_ssh_port)
|
||||
self.assertEqual(False, config.san_is_local)
|
||||
self.assertEqual(30, config.ssh_conn_timeout)
|
||||
self.assertEqual(1, config.ssh_min_pool_conn)
|
||||
self.assertEqual(5, config.ssh_max_pool_conn)
|
||||
self.assertEqual('iSCSI', iscsi_driver.protocol)
|
||||
|
||||
def test_fc_initialize(self):
|
||||
config = conf.Configuration(None)
|
||||
config.storage_protocol = 'fc'
|
||||
fc_driver = driver.UnityDriver(configuration=config)
|
||||
self.assertEqual('FC', fc_driver.protocol)
|
||||
|
||||
def test_do_setup(self):
|
||||
def f():
|
||||
self.driver.do_setup(None)
|
||||
|
||||
self.assertRaises(ex.AdapterSetupError, f)
|
||||
|
||||
def test_create_volume(self):
|
||||
volume = self.get_volume()
|
||||
self.assertEqual(volume, self.driver.create_volume(volume))
|
||||
|
||||
def test_create_volume_from_snapshot(self):
|
||||
volume = self.get_volume()
|
||||
snap = self.get_snapshot()
|
||||
self.assertEqual(
|
||||
volume, self.driver.create_volume_from_snapshot(volume, snap))
|
||||
|
||||
def test_create_cloned_volume(self):
|
||||
volume = self.get_volume()
|
||||
self.assertEqual(
|
||||
volume, self.driver.create_cloned_volume(volume, None))
|
||||
|
||||
def test_extend_volume(self):
|
||||
volume = self.get_volume()
|
||||
self.driver.extend_volume(volume, 6)
|
||||
self.assertEqual(6, volume.size)
|
||||
|
||||
def test_delete_volume(self):
|
||||
volume = self.get_volume()
|
||||
self.driver.delete_volume(volume)
|
||||
self.assertFalse(volume.exists)
|
||||
|
||||
def test_create_snapshot(self):
|
||||
snapshot = self.get_snapshot()
|
||||
self.driver.create_snapshot(snapshot)
|
||||
self.assertTrue(snapshot.exists)
|
||||
|
||||
def test_delete_snapshot(self):
|
||||
snapshot = self.get_snapshot()
|
||||
self.driver.delete_snapshot(snapshot)
|
||||
self.assertFalse(snapshot.exists)
|
||||
|
||||
def test_ensure_export(self):
|
||||
self.assertIsNone(self.driver.ensure_export(
|
||||
self.get_context(), self.get_volume()))
|
||||
|
||||
def test_create_export(self):
|
||||
self.assertIsNone(self.driver.create_export(
|
||||
self.get_context(), self.get_volume(), self.get_connector()))
|
||||
|
||||
def test_remove_export(self):
|
||||
self.assertIsNone(self.driver.remove_export(
|
||||
self.get_context(), self.get_volume()))
|
||||
|
||||
def test_check_for_export(self):
|
||||
self.assertIsNone(self.driver.check_for_export(
|
||||
self.get_context(), self.get_volume()))
|
||||
|
||||
def test_initialize_connection(self):
|
||||
volume = self.get_volume()
|
||||
connector = self.get_connector()
|
||||
conn_info = self.driver.initialize_connection(volume, connector)
|
||||
self.assertEqual(volume, conn_info['volume'])
|
||||
self.assertEqual(connector, conn_info['connector'])
|
||||
|
||||
def test_terminate_connection(self):
|
||||
volume = self.get_volume()
|
||||
connector = self.get_connector()
|
||||
conn_info = self.driver.terminate_connection(volume, connector)
|
||||
self.assertEqual(volume, conn_info['volume'])
|
||||
self.assertEqual(connector, conn_info['connector'])
|
||||
|
||||
def test_update_volume_stats(self):
|
||||
stats = self.driver.get_volume_stats(True)
|
||||
self.assertEqual(123, stats['stats'])
|
||||
self.assertEqual(self.driver.VERSION, stats['driver_version'])
|
||||
self.assertEqual(self.driver.VENDOR, stats['vendor_name'])
|
||||
|
||||
def test_manage_existing(self):
|
||||
volume = self.driver.manage_existing(self.get_volume(), None)
|
||||
self.assertTrue(volume.managed)
|
||||
|
||||
def test_manage_existing_get_size(self):
|
||||
volume = self.driver.manage_existing_get_size(self.get_volume(), None)
|
||||
self.assertTrue(volume.managed)
|
||||
self.assertEqual(7, volume.size)
|
||||
|
||||
def test_get_pool(self):
|
||||
self.assertEqual('pool_0', self.driver.get_pool(self.get_volume()))
|
||||
|
||||
def test_unmanage(self):
|
||||
ret = self.driver.unmanage(None)
|
||||
self.assertIsNone(ret)
|
||||
|
|
@ -0,0 +1,254 @@
|
|||
# Copyright (c) 2016 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.
|
||||
|
||||
import functools
|
||||
import unittest
|
||||
|
||||
import mock
|
||||
from oslo_utils import units
|
||||
|
||||
from cinder import exception
|
||||
from cinder.volume.drivers.dell_emc.unity import utils
|
||||
|
||||
|
||||
def get_volume_type_extra_specs(volume_type):
|
||||
return {'provisioning:type': volume_type}
|
||||
|
||||
|
||||
def get_volume_type_qos_specs(type_id):
|
||||
if type_id == 'invalid_backend_qos_consumer':
|
||||
ret = {'qos_specs': {'consumer': 'invalid'}}
|
||||
elif type_id == 'both_none':
|
||||
ret = {'qos_specs': {'consumer': 'back-end', 'specs': {}}}
|
||||
elif type_id == 'max_1000_iops':
|
||||
ret = {
|
||||
'qos_specs': {
|
||||
'id': 'max_1000_iops',
|
||||
'consumer': 'both',
|
||||
'specs': {
|
||||
'maxIOPS': 1000
|
||||
}
|
||||
}
|
||||
}
|
||||
elif type_id == 'max_2_mbps':
|
||||
ret = {
|
||||
'qos_specs': {
|
||||
'id': 'max_2_mbps',
|
||||
'consumer': 'back-end',
|
||||
'specs': {
|
||||
'maxBWS': 2
|
||||
}
|
||||
}
|
||||
}
|
||||
else:
|
||||
ret = None
|
||||
return ret
|
||||
|
||||
|
||||
def patch_volume_types(func):
|
||||
@functools.wraps(func)
|
||||
@mock.patch(target=('cinder.volume.volume_types'
|
||||
'.get_volume_type_extra_specs'),
|
||||
new=get_volume_type_extra_specs)
|
||||
@mock.patch(target=('cinder.volume.volume_types'
|
||||
'.get_volume_type_qos_specs'),
|
||||
new=get_volume_type_qos_specs)
|
||||
def func_wrapper(*args, **kwargs):
|
||||
return func(*args, **kwargs)
|
||||
|
||||
return func_wrapper
|
||||
|
||||
|
||||
class UnityUtilsTest(unittest.TestCase):
|
||||
def test_validate_pool_names_filter(self):
|
||||
all_pools = list('acd')
|
||||
pool_names = utils.validate_pool_names(list('abc'), all_pools)
|
||||
self.assertIn('a', pool_names)
|
||||
self.assertIn('c', pool_names)
|
||||
self.assertNotIn('b', pool_names)
|
||||
self.assertNotIn('d', pool_names)
|
||||
|
||||
def test_validate_pool_names_non_exists(self):
|
||||
def f():
|
||||
all_pools = list('abc')
|
||||
utils.validate_pool_names(list('efg'), all_pools)
|
||||
|
||||
self.assertRaises(exception.VolumeBackendAPIException, f)
|
||||
|
||||
def test_validate_pool_names_default(self):
|
||||
all_pools = list('ab')
|
||||
pool_names = utils.validate_pool_names([], all_pools)
|
||||
self.assertEqual(2, len(pool_names))
|
||||
|
||||
pool_names = utils.validate_pool_names(None, all_pools)
|
||||
self.assertEqual(2, len(pool_names))
|
||||
|
||||
def test_build_provider_location(self):
|
||||
location = utils.build_provider_location('unity', 'thin', 'ev_1', '3')
|
||||
expected = 'id^ev_1|system^unity|type^thin|version^3'
|
||||
self.assertEqual(expected, location)
|
||||
|
||||
def test_extract_provider_location_version(self):
|
||||
location = 'id^ev_1|system^unity|type^thin|version^3'
|
||||
self.assertEqual('3',
|
||||
utils.extract_provider_location(location, 'version'))
|
||||
|
||||
def test_extract_provider_location_type(self):
|
||||
location = 'id^ev_1|system^unity|type^thin|version^3'
|
||||
self.assertEqual('thin',
|
||||
utils.extract_provider_location(location, 'type'))
|
||||
|
||||
def test_extract_provider_location_system(self):
|
||||
location = 'id^ev_1|system^unity|type^thin|version^3'
|
||||
self.assertEqual('unity',
|
||||
utils.extract_provider_location(location, 'system'))
|
||||
|
||||
def test_extract_provider_location_id(self):
|
||||
location = 'id^ev_1|system^unity|type^thin|version^3'
|
||||
self.assertEqual('ev_1',
|
||||
utils.extract_provider_location(location, 'id'))
|
||||
|
||||
def test_extract_provider_location_not_found(self):
|
||||
location = 'id^ev_1|system^unity|type^thin|version^3'
|
||||
self.assertIsNone(utils.extract_provider_location(location, 'na'))
|
||||
|
||||
def test_extract_provider_location_none(self):
|
||||
self.assertIsNone(utils.extract_provider_location(None, 'abc'))
|
||||
|
||||
def test_extract_iscsi_uids(self):
|
||||
connector = {'host': 'fake_host',
|
||||
'initiator': 'fake_iqn'}
|
||||
self.assertEqual(['fake_iqn'],
|
||||
utils.extract_iscsi_uids(connector))
|
||||
|
||||
def test_extract_iscsi_uids_not_found(self):
|
||||
connector = {'host': 'fake_host'}
|
||||
self.assertRaises(exception.VolumeBackendAPIException,
|
||||
utils.extract_iscsi_uids,
|
||||
connector)
|
||||
|
||||
def test_extract_fc_uids(self):
|
||||
connector = {'host': 'fake_host',
|
||||
'wwnns': ['1111111111111111',
|
||||
'2222222222222222'],
|
||||
'wwpns': ['3333333333333333',
|
||||
'4444444444444444']
|
||||
}
|
||||
self.assertEqual(['11:11:11:11:11:11:11:11:33:33:33:33:33:33:33:33',
|
||||
'22:22:22:22:22:22:22:22:44:44:44:44:44:44:44:44', ],
|
||||
utils.extract_fc_uids(connector))
|
||||
|
||||
def test_extract_fc_uids_not_found(self):
|
||||
connector = {'host': 'fake_host'}
|
||||
self.assertRaises(exception.VolumeBackendAPIException,
|
||||
utils.extract_iscsi_uids,
|
||||
connector)
|
||||
|
||||
def test_byte_to_gib(self):
|
||||
self.assertEqual(5, utils.byte_to_gib(5 * units.Gi))
|
||||
|
||||
def test_byte_to_mib(self):
|
||||
self.assertEqual(5, utils.byte_to_mib(5 * units.Mi))
|
||||
|
||||
def test_gib_to_mib(self):
|
||||
self.assertEqual(5 * units.Gi / units.Mi, utils.gib_to_mib(5))
|
||||
|
||||
def test_convert_ip_to_portal(self):
|
||||
self.assertEqual('1.2.3.4:3260', utils.convert_ip_to_portal('1.2.3.4'))
|
||||
|
||||
def test_convert_to_itor_tgt_map(self):
|
||||
zone_mapping = {
|
||||
'san_1': {
|
||||
'initiator_port_wwn_list':
|
||||
('200000051e55a100', '200000051e55a121'),
|
||||
'target_port_wwn_list':
|
||||
('100000051e55a100', '100000051e55a121')
|
||||
}
|
||||
}
|
||||
ret = utils.convert_to_itor_tgt_map(zone_mapping)
|
||||
self.assertEqual(['100000051e55a100', '100000051e55a121'], ret[0])
|
||||
mapping = ret[1]
|
||||
targets = ('100000051e55a100', '100000051e55a121')
|
||||
self.assertEqual(targets, mapping['200000051e55a100'])
|
||||
self.assertEqual(targets, mapping['200000051e55a121'])
|
||||
|
||||
def test_get_pool_name(self):
|
||||
volume = mock.Mock(host='host@backend#pool_name')
|
||||
self.assertEqual('pool_name', utils.get_pool_name(volume))
|
||||
|
||||
def test_ignore_exception(self):
|
||||
class IgnoredException(Exception):
|
||||
pass
|
||||
|
||||
def f():
|
||||
raise IgnoredException('any exception')
|
||||
|
||||
try:
|
||||
utils.ignore_exception(f)
|
||||
except IgnoredException:
|
||||
self.fail('should not raise any exception.')
|
||||
|
||||
def test_assure_cleanup(self):
|
||||
data = [0]
|
||||
|
||||
def _enter():
|
||||
data[0] += 10
|
||||
return data[0]
|
||||
|
||||
def _exit(x):
|
||||
data[0] = x - 1
|
||||
|
||||
ctx = utils.assure_cleanup(_enter, _exit, True)
|
||||
with ctx as r:
|
||||
self.assertEqual(10, r)
|
||||
|
||||
self.assertEqual(9, data[0])
|
||||
|
||||
def test_get_backend_qos_specs_type_none(self):
|
||||
volume = mock.Mock(volume_type_id=None)
|
||||
ret = utils.get_backend_qos_specs(volume)
|
||||
self.assertIsNone(ret)
|
||||
|
||||
@patch_volume_types
|
||||
def test_get_backend_qos_specs_none(self):
|
||||
volume = mock.Mock(volume_type_id='no_qos')
|
||||
ret = utils.get_backend_qos_specs(volume)
|
||||
self.assertIsNone(ret)
|
||||
|
||||
@patch_volume_types
|
||||
def test_get_backend_qos_invalid_consumer(self):
|
||||
volume = mock.Mock(volume_type_id='invalid_backend_qos_consumer')
|
||||
ret = utils.get_backend_qos_specs(volume)
|
||||
self.assertIsNone(ret)
|
||||
|
||||
@patch_volume_types
|
||||
def test_get_backend_qos_both_none(self):
|
||||
volume = mock.Mock(volume_type_id='both_none')
|
||||
ret = utils.get_backend_qos_specs(volume)
|
||||
self.assertIsNone(ret)
|
||||
|
||||
@patch_volume_types
|
||||
def test_get_backend_qos_iops(self):
|
||||
volume = mock.Mock(volume_type_id='max_1000_iops')
|
||||
ret = utils.get_backend_qos_specs(volume)
|
||||
expected = {'maxBWS': None, 'id': 'max_1000_iops', 'maxIOPS': 1000}
|
||||
self.assertEqual(expected, ret)
|
||||
|
||||
@patch_volume_types
|
||||
def test_get_backend_qos_mbps(self):
|
||||
volume = mock.Mock(volume_type_id='max_2_mbps')
|
||||
ret = utils.get_backend_qos_specs(volume)
|
||||
expected = {'maxBWS': 2, 'id': 'max_2_mbps', 'maxIOPS': None}
|
||||
self.assertEqual(expected, ret)
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
# Copyright (c) 2016 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.
|
||||
|
||||
from cinder.volume.drivers.dell_emc.unity import driver
|
||||
|
||||
Driver = driver.UnityDriver
|
||||
|
|
@ -0,0 +1,523 @@
|
|||
# Copyright (c) 2016 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.
|
||||
|
||||
import contextlib
|
||||
import functools
|
||||
import random
|
||||
|
||||
from oslo_log import log as logging
|
||||
from oslo_utils import excutils
|
||||
|
||||
from cinder import exception
|
||||
from cinder import utils as cinder_utils
|
||||
from cinder.i18n import _, _LE, _LI
|
||||
from cinder.volume.drivers.dell_emc.unity import client
|
||||
from cinder.volume.drivers.dell_emc.unity import utils
|
||||
from cinder.volume import utils as vol_utils
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
||||
PROTOCOL_FC = 'FC'
|
||||
PROTOCOL_ISCSI = 'iSCSI'
|
||||
|
||||
|
||||
class CommonAdapter(object):
|
||||
protocol = 'unknown'
|
||||
driver_name = 'UnityAbstractDriver'
|
||||
driver_volume_type = 'unknown'
|
||||
|
||||
def __init__(self, version=None):
|
||||
self.version = version
|
||||
self.driver = None
|
||||
self.configured_pool_names = None
|
||||
self.reserved_percentage = None
|
||||
self.max_over_subscription_ratio = None
|
||||
self.volume_backend_name = None
|
||||
self.ip = None
|
||||
self.username = None
|
||||
self.password = None
|
||||
self.array_cert_verify = None
|
||||
self.array_ca_cert_path = None
|
||||
|
||||
self._serial_number = None
|
||||
self.storage_pools_map = None
|
||||
self._client = None
|
||||
|
||||
def do_setup(self, driver, conf):
|
||||
self.driver = driver
|
||||
self.configured_pool_names = conf.unity_storage_pool_names
|
||||
self.reserved_percentage = conf.reserved_percentage
|
||||
self.max_over_subscription_ratio = conf.max_over_subscription_ratio
|
||||
self.volume_backend_name = (conf.safe_get('volume_backend_name') or
|
||||
self.driver_name)
|
||||
self.ip = conf.san_ip
|
||||
self.username = conf.san_login
|
||||
self.password = conf.san_password
|
||||
# Unity currently not support to upload certificate.
|
||||
# Once it supports, enable the verify.
|
||||
self.array_cert_verify = False
|
||||
self.array_ca_cert_path = conf.driver_ssl_cert_path
|
||||
|
||||
self.storage_pools_map = self.get_managed_pools()
|
||||
|
||||
@property
|
||||
def verify_cert(self):
|
||||
verify_cert = self.array_cert_verify
|
||||
if verify_cert and self.array_ca_cert_path is not None:
|
||||
verify_cert = self.array_ca_cert_path
|
||||
return verify_cert
|
||||
|
||||
@property
|
||||
def client(self):
|
||||
if self._client is None:
|
||||
self._client = client.UnityClient(
|
||||
self.ip,
|
||||
self.username,
|
||||
self.password,
|
||||
verify_cert=self.verify_cert)
|
||||
return self._client
|
||||
|
||||
@property
|
||||
def serial_number(self):
|
||||
if self._serial_number is None:
|
||||
self._serial_number = self.client.get_serial()
|
||||
return self._serial_number
|
||||
|
||||
def get_managed_pools(self):
|
||||
names = self.configured_pool_names
|
||||
array_pools = self.client.get_pools()
|
||||
valid_names = utils.validate_pool_names(names, array_pools.name)
|
||||
return {p.name: p for p in array_pools if p.name in valid_names}
|
||||
|
||||
def create_volume(self, volume):
|
||||
"""Creates a volume.
|
||||
|
||||
:param volume: volume information
|
||||
"""
|
||||
volume_size = volume.size
|
||||
volume_name = volume.name
|
||||
volume_description = (volume.display_description
|
||||
if volume.display_description
|
||||
else volume.display_name)
|
||||
|
||||
pool = self._get_target_pool(volume)
|
||||
qos_specs = utils.get_backend_qos_specs(volume)
|
||||
limit_policy = self.client.get_io_limit_policy(qos_specs)
|
||||
|
||||
LOG.info(_LI('Create Volume: %(volume)s Size: %(size)s '
|
||||
'Pool: %(pool)s Qos: %(qos)s.'),
|
||||
{'volume': volume_name,
|
||||
'size': volume_size,
|
||||
'pool': pool.name,
|
||||
'qos': qos_specs})
|
||||
|
||||
lun = self.client.create_lun(
|
||||
volume_name, volume_size, pool, description=volume_description,
|
||||
io_limit_policy=limit_policy)
|
||||
location = self._build_provider_location(
|
||||
lun_type='lun',
|
||||
lun_id=lun.get_id())
|
||||
model_update = {'provider_location': location}
|
||||
return model_update
|
||||
|
||||
def delete_volume(self, volume):
|
||||
lun_id = self.get_lun_id(volume)
|
||||
if lun_id is None:
|
||||
LOG.info(_LI('Backend LUN not found, skipping the deletion. '
|
||||
'Volume: %(volume_name)s.'),
|
||||
{'volume_name': volume.name})
|
||||
else:
|
||||
self.client.delete_lun(lun_id)
|
||||
|
||||
def _initialize_connection(self, lun_or_snap, connector, vol_id):
|
||||
host = self.client.create_host(connector['host'],
|
||||
self.get_connector_uids(connector))
|
||||
hlu = self.client.attach(host, lun_or_snap)
|
||||
data = self.get_connection_info(hlu, host, connector)
|
||||
data['target_discovered'] = True
|
||||
if vol_id is not None:
|
||||
data['volume_id'] = vol_id
|
||||
conn_info = {
|
||||
'driver_volume_type': self.driver_volume_type,
|
||||
'data': data,
|
||||
}
|
||||
LOG.debug('Initialized connection info: %s', conn_info)
|
||||
return conn_info
|
||||
|
||||
def initialize_connection(self, volume, connector):
|
||||
lun = self.client.get_lun(lun_id=self.get_lun_id(volume))
|
||||
return self._initialize_connection(lun, connector, volume.id)
|
||||
|
||||
def _terminate_connection(self, lun_or_snap, connector):
|
||||
host = self.client.get_host(connector['host'])
|
||||
self.client.detach(host, lun_or_snap)
|
||||
|
||||
def terminate_connection(self, volume, connector):
|
||||
lun = self.client.get_lun(lun_id=self.get_lun_id(volume))
|
||||
self._terminate_connection(lun, connector)
|
||||
|
||||
def get_connector_uids(self, connector):
|
||||
return None
|
||||
|
||||
def get_connection_info(self, hlu, host, connector):
|
||||
return {}
|
||||
|
||||
def extend_volume(self, volume, new_size):
|
||||
lun_id = self.get_lun_id(volume)
|
||||
if lun_id is None:
|
||||
msg = (_('Backend LUN not found for Volume: %(volume_name)s.') %
|
||||
{'volume_name': volume.name})
|
||||
raise exception.VolumeBackendAPIException(data=msg)
|
||||
else:
|
||||
self.client.extend_lun(lun_id, new_size)
|
||||
|
||||
def _get_target_pool(self, volume):
|
||||
return self.storage_pools_map[utils.get_pool_name(volume)]
|
||||
|
||||
def _build_provider_location(self, lun_id=None, lun_type=None):
|
||||
return utils.build_provider_location(
|
||||
system=self.serial_number,
|
||||
lun_type=lun_type,
|
||||
lun_id=lun_id,
|
||||
version=self.version)
|
||||
|
||||
def update_volume_stats(self):
|
||||
return {
|
||||
'volume_backend_name': self.volume_backend_name,
|
||||
'storage_protocol': self.protocol,
|
||||
'thin_provisioning_support': True,
|
||||
'thick_provisioning_support': False,
|
||||
'pools': self.get_pools_stats(),
|
||||
}
|
||||
|
||||
def get_pools_stats(self):
|
||||
self.storage_pools_map = self.get_managed_pools()
|
||||
return [self._get_pool_stats(pool) for pool in self.pools]
|
||||
|
||||
@property
|
||||
def pools(self):
|
||||
return self.storage_pools_map.values()
|
||||
|
||||
def _get_pool_stats(self, pool):
|
||||
return {
|
||||
'pool_name': pool.name,
|
||||
'total_capacity_gb': utils.byte_to_gib(pool.size_total),
|
||||
'provisioned_capacity_gb': utils.byte_to_gib(
|
||||
pool.size_subscribed),
|
||||
'free_capacity_gb': utils.byte_to_gib(pool.size_free),
|
||||
'reserved_percentage': self.reserved_percentage,
|
||||
'location_info': ('%(pool_name)s|%(array_serial)s' %
|
||||
{'pool_name': pool.name,
|
||||
'array_serial': self.serial_number}),
|
||||
'thin_provisioning_support': True,
|
||||
'thick_provisioning_support': False,
|
||||
'max_over_subscription_ratio': (
|
||||
self.max_over_subscription_ratio)}
|
||||
|
||||
def get_lun_id(self, volume):
|
||||
"""Retrieves id of the volume's backing LUN.
|
||||
|
||||
:param volume: volume information
|
||||
"""
|
||||
if volume.provider_location:
|
||||
return utils.extract_provider_location(volume.provider_location,
|
||||
'id')
|
||||
else:
|
||||
# In some cases, cinder will not update volume info in DB with
|
||||
# provider_location returned by us. We need to retrieve the id
|
||||
# from array.
|
||||
lun = self.client.get_lun(name=volume.name)
|
||||
return lun.get_id() if lun is not None else None
|
||||
|
||||
def create_snapshot(self, snapshot):
|
||||
"""Creates a snapshot.
|
||||
|
||||
:param snapshot: snapshot information.
|
||||
"""
|
||||
src_lun_id = self.get_lun_id(snapshot.volume)
|
||||
return self.client.create_snap(src_lun_id, snapshot.name)
|
||||
|
||||
def delete_snapshot(self, snapshot):
|
||||
"""Deletes a snapshot.
|
||||
|
||||
:param snapshot: the snapshot to delete.
|
||||
"""
|
||||
snap = self.client.get_snap(name=snapshot.name)
|
||||
self.client.delete_snap(snap)
|
||||
|
||||
def _get_referenced_lun(self, existing_ref):
|
||||
if 'source-id' in existing_ref:
|
||||
lun = self.client.get_lun(lun_id=existing_ref['source-id'])
|
||||
elif 'source-name' in existing_ref:
|
||||
lun = self.client.get_lun(name=existing_ref['source-name'])
|
||||
else:
|
||||
reason = _('Reference must contain source-id or source-name key.')
|
||||
raise exception.ManageExistingInvalidReference(
|
||||
existing_ref=existing_ref, reason=reason)
|
||||
if lun is None or not lun.existed:
|
||||
raise exception.ManageExistingInvalidReference(
|
||||
existing_ref=existing_ref,
|
||||
reason=_("LUN doesn't exist."))
|
||||
return lun
|
||||
|
||||
def manage_existing(self, volume, existing_ref):
|
||||
"""Manages an existing LUN in the array.
|
||||
|
||||
The LUN should be in a manageable pool backend, otherwise return error.
|
||||
Rename the backend storage object so that it matches the
|
||||
`volume['name']` which is how drivers traditionally map between a
|
||||
cinder volume and the associated backend storage object.
|
||||
|
||||
LUN ID or name are supported in `existing_ref`, like:
|
||||
|
||||
.. code-block::
|
||||
|
||||
existing_ref:{
|
||||
'source-id':<LUN id in Unity>
|
||||
}
|
||||
|
||||
or
|
||||
|
||||
.. code-block::
|
||||
|
||||
existing_ref:{
|
||||
'source-name':<LUN name in Unity>
|
||||
}
|
||||
"""
|
||||
lun = self._get_referenced_lun(existing_ref)
|
||||
lun.modify(name=volume.name)
|
||||
return {'provider_location':
|
||||
self._build_provider_location(lun_id=lun.get_id(),
|
||||
lun_type='lun')}
|
||||
|
||||
def manage_existing_get_size(self, volume, existing_ref):
|
||||
"""Returns size of volume to be managed by `manage_existing`.
|
||||
|
||||
The driver does some check here:
|
||||
1. The LUN `existing_ref` should be managed by the `volume.host`.
|
||||
"""
|
||||
lun = self._get_referenced_lun(existing_ref)
|
||||
target_pool_name = utils.get_pool_name(volume)
|
||||
lun_pool_name = lun.pool.name
|
||||
if target_pool_name and lun_pool_name != target_pool_name:
|
||||
reason = (_('The imported LUN is in pool %(pool_name)s '
|
||||
'which is not managed by the host %(host)s.') %
|
||||
{'pool_name': lun_pool_name,
|
||||
'host': volume.host})
|
||||
raise exception.ManageExistingInvalidReference(
|
||||
existing_ref=existing_ref, reason=reason)
|
||||
|
||||
return utils.byte_to_gib(lun.size_total)
|
||||
|
||||
def _disconnect_device(self, conn):
|
||||
conn['connector'].disconnect_volume(conn['conn']['data'],
|
||||
conn['device'])
|
||||
|
||||
def _connect_device(self, conn):
|
||||
return self.driver._connect_device(conn)
|
||||
|
||||
@contextlib.contextmanager
|
||||
def _connect_resource(self, lun_or_snap, connector, res_id):
|
||||
"""Connects to LUN or snapshot, and makes sure disconnect finally.
|
||||
|
||||
:param lun_or_snap: the LUN or snapshot to connect/disconnect.
|
||||
:param connector: the host connector information.
|
||||
:param res_id: the ID of the LUN or snapshot.
|
||||
|
||||
:return the connection information, in a dict with format like (same as
|
||||
the one returned by `_connect_device`):
|
||||
{
|
||||
'conn': <info returned by `initialize_connection`>,
|
||||
'device': <value returned by `connect_volume`>,
|
||||
'connector': <host connector info>
|
||||
}
|
||||
"""
|
||||
init_conn_func = functools.partial(self._initialize_connection,
|
||||
lun_or_snap, connector, res_id)
|
||||
term_conn_func = functools.partial(self._terminate_connection,
|
||||
lun_or_snap, connector)
|
||||
with utils.assure_cleanup(init_conn_func, term_conn_func,
|
||||
False) as conn_info:
|
||||
conn_device_func = functools.partial(self._connect_device,
|
||||
conn_info)
|
||||
with utils.assure_cleanup(conn_device_func,
|
||||
self._disconnect_device,
|
||||
True) as attach_info:
|
||||
yield attach_info
|
||||
|
||||
def _create_volume_from_snap(self, volume, snap, size_in_m=None):
|
||||
"""Creates a volume from a Unity snapshot.
|
||||
|
||||
It attaches the `volume` and `snap`, then use `dd` to copy the
|
||||
data from the Unity snapshot to the `volume`.
|
||||
"""
|
||||
model_update = self.create_volume(volume)
|
||||
volume.provider_location = model_update['provider_location']
|
||||
src_id = snap.get_id()
|
||||
dest_lun = self.client.get_lun(lun_id=self.get_lun_id(volume))
|
||||
try:
|
||||
conn_props = cinder_utils.brick_get_connector_properties()
|
||||
|
||||
with self._connect_resource(dest_lun, conn_props,
|
||||
volume.id) as dest_info, \
|
||||
self._connect_resource(snap, conn_props,
|
||||
src_id) as src_info:
|
||||
if size_in_m is None:
|
||||
# If size is not specified, need to get the size from LUN
|
||||
# of snapshot.
|
||||
lun = self.client.get_lun(
|
||||
lun_id=snap.storage_resource.get_id())
|
||||
size_in_m = utils.byte_to_mib(lun.size_total)
|
||||
vol_utils.copy_volume(
|
||||
src_info['device']['path'],
|
||||
dest_info['device']['path'],
|
||||
size_in_m,
|
||||
self.driver.configuration.volume_dd_blocksize,
|
||||
sparse=True)
|
||||
except Exception:
|
||||
with excutils.save_and_reraise_exception():
|
||||
utils.ignore_exception(self.delete_volume, volume)
|
||||
LOG.error(_LE('Failed to create cloned volume: %(vol_id)s, '
|
||||
'from source unity snapshot: %(snap_name)s. '),
|
||||
{'vol_id': volume.id, 'snap_name': snap.name})
|
||||
|
||||
return model_update
|
||||
|
||||
def create_volume_from_snapshot(self, volume, snapshot):
|
||||
snap = self.client.get_snap(snapshot.name)
|
||||
return self._create_volume_from_snap(volume, snap)
|
||||
|
||||
def create_cloned_volume(self, volume, src_vref):
|
||||
"""Creates cloned volume.
|
||||
|
||||
1. Take an internal snapshot of source volume, and attach it.
|
||||
2. Create a new volume, and attach it.
|
||||
3. Copy from attached snapshot of step 1 to the volume of step 2.
|
||||
4. Delete the internal snapshot created in step 1.
|
||||
"""
|
||||
|
||||
src_lun_id = self.get_lun_id(src_vref)
|
||||
if src_lun_id is None:
|
||||
raise exception.VolumeBackendAPIException(
|
||||
data=_("LUN ID of source volume: %s not found.") %
|
||||
src_vref.name)
|
||||
src_snap_name = 'snap_clone_%s' % volume.id
|
||||
|
||||
create_snap_func = functools.partial(self.client.create_snap,
|
||||
src_lun_id, src_snap_name)
|
||||
with utils.assure_cleanup(create_snap_func,
|
||||
self.client.delete_snap,
|
||||
True) as src_snap:
|
||||
LOG.debug('Internal snapshot for clone is created, '
|
||||
'name: %(name)s, id: %(id)s.',
|
||||
{'name': src_snap_name,
|
||||
'id': src_snap.get_id()})
|
||||
return self._create_volume_from_snap(
|
||||
volume, src_snap, size_in_m=utils.gib_to_mib(volume.size))
|
||||
|
||||
def get_pool_name(self, volume):
|
||||
return self.client.get_pool_name(volume.name)
|
||||
|
||||
|
||||
class ISCSIAdapter(CommonAdapter):
|
||||
protocol = PROTOCOL_ISCSI
|
||||
driver_name = 'UnityISCSIDriver'
|
||||
driver_volume_type = 'iscsi'
|
||||
|
||||
def get_connector_uids(self, connector):
|
||||
return utils.extract_iscsi_uids(connector)
|
||||
|
||||
def get_connection_info(self, hlu, host, connector):
|
||||
targets = self.client.get_iscsi_target_info()
|
||||
if not targets:
|
||||
msg = _("There is no accessible iSCSI targets on the system.")
|
||||
raise exception.VolumeBackendAPIException(data=msg)
|
||||
one_target = random.choice(targets)
|
||||
portals = [a['portal'] for a in targets]
|
||||
iqns = [a['iqn'] for a in targets]
|
||||
data = {
|
||||
'target_luns': [hlu] * len(portals),
|
||||
'target_iqns': iqns,
|
||||
'target_portals': portals,
|
||||
'target_lun': hlu,
|
||||
'target_portal': one_target['portal'],
|
||||
'target_iqn': one_target['iqn'],
|
||||
}
|
||||
return data
|
||||
|
||||
|
||||
class FCAdapter(CommonAdapter):
|
||||
protocol = PROTOCOL_FC
|
||||
driver_name = 'UnityFCDriver'
|
||||
driver_volume_type = 'fibre_channel'
|
||||
|
||||
def __init__(self, version=None):
|
||||
super(FCAdapter, self).__init__(version=version)
|
||||
self.lookup_service = None
|
||||
|
||||
def do_setup(self, driver, config):
|
||||
super(FCAdapter, self).do_setup(driver, config)
|
||||
self.lookup_service = utils.create_lookup_service()
|
||||
|
||||
def get_connector_uids(self, connector):
|
||||
return utils.extract_fc_uids(connector)
|
||||
|
||||
@property
|
||||
def auto_zone_enabled(self):
|
||||
return self.lookup_service is not None
|
||||
|
||||
def get_connection_info(self, hlu, host, connector):
|
||||
targets = self.client.get_fc_target_info(
|
||||
host, logged_in_only=(not self.auto_zone_enabled))
|
||||
|
||||
if not targets:
|
||||
msg = _("There is no accessible fibre channel targets on the "
|
||||
"system.")
|
||||
raise exception.VolumeBackendAPIException(data=msg)
|
||||
|
||||
if self.auto_zone_enabled:
|
||||
data = self._get_fc_zone_info(connector['wwpns'], targets)
|
||||
else:
|
||||
data = {
|
||||
'target_wwn': targets,
|
||||
}
|
||||
data['target_lun'] = hlu
|
||||
return data
|
||||
|
||||
def terminate_connection(self, volume, connector):
|
||||
super(FCAdapter, self).terminate_connection(volume, connector)
|
||||
|
||||
ret = None
|
||||
if self.auto_zone_enabled:
|
||||
ret = {
|
||||
'driver_volume_type': self.driver_volume_type,
|
||||
'data': {}
|
||||
}
|
||||
host = self.client.get_host(connector['host'])
|
||||
if len(host.host_luns) == 0:
|
||||
targets = self.client.get_fc_target_info(logged_in_only=True)
|
||||
ret['data'] = self._get_fc_zone_info(connector['wwpns'],
|
||||
targets)
|
||||
|
||||
return ret
|
||||
|
||||
def _get_fc_zone_info(self, initiator_wwns, target_wwns):
|
||||
mapping = self.lookup_service.get_device_mapping_from_network(
|
||||
initiator_wwns, target_wwns)
|
||||
targets, itor_tgt_map = utils.convert_to_itor_tgt_map(mapping)
|
||||
return {
|
||||
'target_wwn': targets,
|
||||
'initiator_target_map': itor_tgt_map,
|
||||
}
|
||||
|
|
@ -0,0 +1,279 @@
|
|||
# Copyright (c) 2016 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.
|
||||
|
||||
from oslo_log import log
|
||||
from oslo_utils import excutils
|
||||
from oslo_utils import importutils
|
||||
|
||||
storops = importutils.try_import('storops')
|
||||
if storops:
|
||||
from storops import exception as storops_ex
|
||||
else:
|
||||
# Set storops_ex to be None for unit test
|
||||
storops_ex = None
|
||||
|
||||
from cinder import exception
|
||||
from cinder.i18n import _, _LW
|
||||
from cinder.volume.drivers.dell_emc.unity import utils
|
||||
|
||||
|
||||
LOG = log.getLogger(__name__)
|
||||
|
||||
|
||||
class UnityClient(object):
|
||||
def __init__(self, host, username, password, verify_cert=True):
|
||||
if storops is None:
|
||||
msg = _('Python package storops is not installed which '
|
||||
'is required to run Unity driver.')
|
||||
raise exception.VolumeBackendAPIException(data=msg)
|
||||
self._system = None
|
||||
self.host = host
|
||||
self.username = username
|
||||
self.password = password
|
||||
self.verify_cert = verify_cert
|
||||
|
||||
@property
|
||||
def system(self):
|
||||
if self._system is None:
|
||||
self._system = storops.UnitySystem(
|
||||
host=self.host, username=self.username, password=self.password,
|
||||
verify=self.verify_cert)
|
||||
return self._system
|
||||
|
||||
def get_serial(self):
|
||||
return self.system.serial_number
|
||||
|
||||
def create_lun(self, name, size, pool, description=None,
|
||||
io_limit_policy=None):
|
||||
"""Creates LUN on the Unity system.
|
||||
|
||||
:param name: lun name
|
||||
:param size: lun size in GiB
|
||||
:param pool: UnityPool object represent to pool to place the lun
|
||||
:param description: lun description
|
||||
:param io_limit_policy: io limit on the LUN
|
||||
:return: UnityLun object
|
||||
"""
|
||||
try:
|
||||
lun = pool.create_lun(lun_name=name, size_gb=size,
|
||||
description=description,
|
||||
io_limit_policy=io_limit_policy)
|
||||
except storops_ex.UnityLunNameInUseError:
|
||||
LOG.debug("LUN %s already exists. Return the existing one.",
|
||||
name)
|
||||
lun = self.system.get_lun(name=name)
|
||||
return lun
|
||||
|
||||
def delete_lun(self, lun_id):
|
||||
"""Deletes LUN on the Unity system.
|
||||
|
||||
:param lun_id: id of the LUN
|
||||
"""
|
||||
try:
|
||||
lun = self.system.get_lun(_id=lun_id)
|
||||
lun.delete()
|
||||
except storops_ex.UnityResourceNotFoundError:
|
||||
LOG.debug("LUN %s doesn't exist. Deletion is not needed.",
|
||||
lun_id)
|
||||
|
||||
def get_lun(self, lun_id=None, name=None):
|
||||
"""Gets LUN on the Unity system.
|
||||
|
||||
:param lun_id: id of the LUN
|
||||
:param name: name of the LUN
|
||||
:return: `UnityLun` object
|
||||
"""
|
||||
lun = None
|
||||
if lun_id is None and name is None:
|
||||
LOG.warning(
|
||||
_LW("Both lun_id and name are None to get LUN. Return None."))
|
||||
else:
|
||||
try:
|
||||
lun = self.system.get_lun(_id=lun_id, name=name)
|
||||
except storops_ex.UnityResourceNotFoundError:
|
||||
LOG.warning(
|
||||
_LW("LUN id=%(id)s, name=%(name)s doesn't exist."),
|
||||
{'id': lun_id, 'name': name})
|
||||
return lun
|
||||
|
||||
def extend_lun(self, lun_id, size_gib):
|
||||
lun = self.system.get_lun(lun_id)
|
||||
try:
|
||||
lun.total_size_gb = size_gib
|
||||
except storops_ex.UnityNothingToModifyError:
|
||||
LOG.debug("LUN %s is already expanded. LUN expand is not needed.",
|
||||
lun_id)
|
||||
return lun
|
||||
|
||||
def get_pools(self):
|
||||
"""Gets all storage pools on the Unity system.
|
||||
|
||||
:return: list of UnityPool object
|
||||
"""
|
||||
return self.system.get_pool()
|
||||
|
||||
def create_snap(self, src_lun_id, name=None):
|
||||
"""Creates a snapshot of LUN on the Unity system.
|
||||
|
||||
:param src_lun_id: the source LUN ID of the snapshot.
|
||||
:param name: the name of the snapshot. The Unity system will give one
|
||||
if `name` is None.
|
||||
"""
|
||||
try:
|
||||
lun = self.get_lun(lun_id=src_lun_id)
|
||||
snap = lun.create_snap(name, is_auto_delete=False)
|
||||
except storops_ex.UnitySnapNameInUseError as err:
|
||||
LOG.debug(
|
||||
"Snap %(snap_name)s already exists on LUN %(lun_id)s. "
|
||||
"Return the existing one. Message: %(err)s",
|
||||
{'snap_name': name,
|
||||
'lun_id': src_lun_id,
|
||||
'err': err})
|
||||
snap = self.get_snap(name=name)
|
||||
return snap
|
||||
|
||||
@staticmethod
|
||||
def delete_snap(snap):
|
||||
if snap is None:
|
||||
LOG.debug("Snap to delete is None, skipping deletion.")
|
||||
return
|
||||
|
||||
try:
|
||||
snap.delete()
|
||||
except storops_ex.UnityResourceNotFoundError as err:
|
||||
LOG.debug("Snap %(snap_name)s may be deleted already. "
|
||||
"Message: %(err)s",
|
||||
{'snap_name': snap.name,
|
||||
'err': err})
|
||||
except storops_ex.UnityDeleteAttachedSnapError as err:
|
||||
with excutils.save_and_reraise_exception():
|
||||
LOG.warning(_LW("Failed to delete snapshot %(snap_name)s "
|
||||
"which is in use. Message: %(err)s"),
|
||||
{'snap_name': snap.name, 'err': err})
|
||||
|
||||
def get_snap(self, name=None):
|
||||
try:
|
||||
return self.system.get_snap(name=name)
|
||||
except storops_ex.UnityResourceNotFoundError as err:
|
||||
msg = _LW("Snapshot %(name)s doesn't exist. Message: %(err)s")
|
||||
LOG.warning(msg, {'name': name, 'err': err})
|
||||
return None
|
||||
|
||||
def create_host(self, name, uids):
|
||||
"""Creates a host on Unity.
|
||||
|
||||
Creates a host on Unity which has the uids associated.
|
||||
|
||||
:param name: name of the host
|
||||
:param uids: iqns or wwns list
|
||||
:return: UnitHost object
|
||||
"""
|
||||
|
||||
try:
|
||||
host = self.system.get_host(name=name)
|
||||
except storops_ex.UnityResourceNotFoundError:
|
||||
LOG.debug('Existing host %s not found. Create a new one.', name)
|
||||
host = self.system.create_host(name=name)
|
||||
|
||||
host_initiators_ids = self.get_host_initiator_ids(host)
|
||||
un_registered = filter(lambda h: h not in host_initiators_ids, uids)
|
||||
for uid in un_registered:
|
||||
host.add_initiator(uid, force_create=True)
|
||||
|
||||
host.update()
|
||||
return host
|
||||
|
||||
@staticmethod
|
||||
def get_host_initiator_ids(host):
|
||||
fc = host.fc_host_initiators
|
||||
fc_ids = [] if fc is None else fc.initiator_id
|
||||
iscsi = host.iscsi_host_initiators
|
||||
iscsi_ids = [] if iscsi is None else iscsi.initiator_id
|
||||
return fc_ids + iscsi_ids
|
||||
|
||||
@staticmethod
|
||||
def attach(host, lun_or_snap):
|
||||
"""Attaches a `UnityLun` or `UnitySnap` to a `UnityHost`.
|
||||
|
||||
:param host: `UnityHost` object
|
||||
:param lun_or_snap: `UnityLun` or `UnitySnap` object
|
||||
:return: hlu
|
||||
"""
|
||||
try:
|
||||
return host.attach(lun_or_snap, skip_hlu_0=True)
|
||||
except storops_ex.UnityResourceAlreadyAttachedError:
|
||||
return host.get_hlu(lun_or_snap)
|
||||
|
||||
@staticmethod
|
||||
def detach(host, lun_or_snap):
|
||||
"""Detaches a `UnityLun` or `UnitySnap` from a `UnityHost`.
|
||||
|
||||
:param host: `UnityHost` object
|
||||
:param lun_or_snap: `UnityLun` object
|
||||
"""
|
||||
lun_or_snap.update()
|
||||
host.detach(lun_or_snap)
|
||||
|
||||
def get_host(self, name):
|
||||
return self.system.get_host(name=name)
|
||||
|
||||
def get_iscsi_target_info(self):
|
||||
portals = self.system.get_iscsi_portal()
|
||||
return [{'portal': utils.convert_ip_to_portal(p.ip_address),
|
||||
'iqn': p.iscsi_node.name}
|
||||
for p in portals]
|
||||
|
||||
def get_fc_target_info(self, host=None, logged_in_only=False):
|
||||
"""Get the ports WWN of FC on array.
|
||||
|
||||
:param host: the host to which the FC port is registered.
|
||||
:param logged_in_only: whether to retrieve only the logged-in port.
|
||||
|
||||
:return the WWN of FC ports. For example, the FC WWN on array is like:
|
||||
50:06:01:60:89:20:09:25:50:06:01:6C:09:20:09:25.
|
||||
This function removes the colons and returns the last 16 bits:
|
||||
5006016C09200925.
|
||||
"""
|
||||
ports = []
|
||||
if logged_in_only:
|
||||
for host_initiator in host.fc_host_initiators:
|
||||
paths = host_initiator.paths or []
|
||||
for path in paths:
|
||||
if path.is_logged_in:
|
||||
ports.append(path.fc_port)
|
||||
else:
|
||||
ports = self.system.get_fc_port()
|
||||
return [po.wwn.replace(':', '')[16:] for po in ports]
|
||||
|
||||
def create_io_limit_policy(self, name, max_iops=None, max_kbps=None):
|
||||
try:
|
||||
limit = self.system.create_io_limit_policy(
|
||||
name, max_iops=max_iops, max_kbps=max_kbps)
|
||||
except storops_ex.UnityPolicyNameInUseError:
|
||||
limit = self.system.get_io_limit_policy(name=name)
|
||||
return limit
|
||||
|
||||
def get_io_limit_policy(self, qos_specs):
|
||||
limit_policy = None
|
||||
if qos_specs is not None:
|
||||
limit_policy = self.create_io_limit_policy(
|
||||
qos_specs['id'],
|
||||
qos_specs.get(utils.QOS_MAX_IOPS),
|
||||
qos_specs.get(utils.QOS_MAX_BWS))
|
||||
return limit_policy
|
||||
|
||||
def get_pool_name(self, lun_name):
|
||||
lun = self.system.get_lun(name=lun_name)
|
||||
return lun.pool_name
|
||||
|
|
@ -0,0 +1,216 @@
|
|||
# Copyright (c) 2016 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.
|
||||
|
||||
"""Cinder Driver for Unity"""
|
||||
|
||||
from oslo_config import cfg
|
||||
from oslo_log import log as logging
|
||||
|
||||
from cinder import interface
|
||||
from cinder.volume import driver
|
||||
from cinder.volume.drivers.dell_emc.unity import adapter
|
||||
from cinder.volume.drivers.san.san import san_opts
|
||||
from cinder.zonemanager import utils as zm_utils
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
||||
CONF = cfg.CONF
|
||||
|
||||
UNITY_OPTS = [
|
||||
cfg.ListOpt('unity_storage_pool_names',
|
||||
default=None,
|
||||
help='A comma-separated list of storage pool names '
|
||||
'to be used.')]
|
||||
|
||||
CONF.register_opts(UNITY_OPTS)
|
||||
|
||||
|
||||
@interface.volumedriver
|
||||
class UnityDriver(driver.TransferVD,
|
||||
driver.ManageableVD,
|
||||
driver.ExtendVD,
|
||||
driver.SnapshotVD,
|
||||
driver.ManageableSnapshotsVD,
|
||||
driver.BaseVD):
|
||||
"""Unity Driver.
|
||||
|
||||
Version history:
|
||||
1.0.0 - Initial version
|
||||
"""
|
||||
|
||||
VERSION = '01.00.00'
|
||||
VENDOR = 'Dell EMC'
|
||||
# ThirdPartySystems wiki page
|
||||
CI_WIKI_NAME = "EMC_UNITY_CI"
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
super(UnityDriver, self).__init__(*args, **kwargs)
|
||||
self.configuration.append_config_values(UNITY_OPTS)
|
||||
self.configuration.append_config_values(san_opts)
|
||||
protocol = self.configuration.storage_protocol
|
||||
if protocol.lower() == adapter.PROTOCOL_FC.lower():
|
||||
self.protocol = adapter.PROTOCOL_FC
|
||||
self.adapter = adapter.FCAdapter(self.VERSION)
|
||||
else:
|
||||
self.protocol = adapter.PROTOCOL_ISCSI
|
||||
self.adapter = adapter.ISCSIAdapter(self.VERSION)
|
||||
|
||||
def do_setup(self, context):
|
||||
self.adapter.do_setup(self, self.configuration)
|
||||
|
||||
def check_for_setup_error(self):
|
||||
pass
|
||||
|
||||
def create_volume(self, volume):
|
||||
"""Creates a volume."""
|
||||
return self.adapter.create_volume(volume)
|
||||
|
||||
def create_volume_from_snapshot(self, volume, snapshot):
|
||||
"""Creates a volume from a snapshot."""
|
||||
return self.adapter.create_volume_from_snapshot(volume, snapshot)
|
||||
|
||||
def create_cloned_volume(self, volume, src_vref):
|
||||
"""Creates a cloned volume."""
|
||||
return self.adapter.create_cloned_volume(volume, src_vref)
|
||||
|
||||
def extend_volume(self, volume, new_size):
|
||||
"""Extend a volume."""
|
||||
self.adapter.extend_volume(volume, new_size)
|
||||
|
||||
def delete_volume(self, volume):
|
||||
"""Deletes a volume."""
|
||||
self.adapter.delete_volume(volume)
|
||||
|
||||
def create_snapshot(self, snapshot):
|
||||
"""Creates a snapshot."""
|
||||
self.adapter.create_snapshot(snapshot)
|
||||
|
||||
def delete_snapshot(self, snapshot):
|
||||
"""Deletes a snapshot."""
|
||||
self.adapter.delete_snapshot(snapshot)
|
||||
|
||||
def ensure_export(self, context, volume):
|
||||
"""Driver entry point to get the export info for an existing volume."""
|
||||
pass
|
||||
|
||||
def create_export(self, context, volume, connector):
|
||||
"""Driver entry point to get the export info for a new volume."""
|
||||
pass
|
||||
|
||||
def remove_export(self, context, volume):
|
||||
"""Driver entry point to remove an export for a volume."""
|
||||
pass
|
||||
|
||||
def check_for_export(self, context, volume_id):
|
||||
"""Make sure volume is exported."""
|
||||
pass
|
||||
|
||||
@zm_utils.AddFCZone
|
||||
def initialize_connection(self, volume, connector):
|
||||
"""Initializes the connection and returns connection info.
|
||||
|
||||
Assign any created volume to a compute node/host so that it can be
|
||||
used from that host.
|
||||
|
||||
The driver returns a driver_volume_type of 'fibre_channel'.
|
||||
The target_wwn can be a single entry or a list of wwns that
|
||||
correspond to the list of remote wwn(s) that will export the volume.
|
||||
The initiator_target_map is a map that represents the remote wwn(s)
|
||||
and a list of wwns which are visible to the remote wwn(s).
|
||||
Example return values:
|
||||
FC:
|
||||
{
|
||||
'driver_volume_type': 'fibre_channel'
|
||||
'data': {
|
||||
'target_discovered': True,
|
||||
'target_lun': 1,
|
||||
'target_wwn': ['1234567890123', '0987654321321'],
|
||||
'initiator_target_map': {
|
||||
'1122334455667788': ['1234567890123',
|
||||
'0987654321321']
|
||||
}
|
||||
}
|
||||
}
|
||||
iSCSI:
|
||||
{
|
||||
'driver_volume_type': 'iscsi'
|
||||
'data': {
|
||||
'target_discovered': True,
|
||||
'target_iqns': ['iqn.2010-10.org.openstack:volume-00001',
|
||||
'iqn.2010-10.org.openstack:volume-00002'],
|
||||
'target_portals': ['127.0.0.1:3260', '127.0.1.1:3260'],
|
||||
'target_luns': [1, 1],
|
||||
}
|
||||
}
|
||||
"""
|
||||
LOG.debug("Entering initialize_connection"
|
||||
" - connector: %(connector)s.",
|
||||
{'connector': connector})
|
||||
conn_info = self.adapter.initialize_connection(volume,
|
||||
connector)
|
||||
LOG.debug("Exit initialize_connection"
|
||||
" - Returning connection info: %(conn_info)s.",
|
||||
{'conn_info': conn_info})
|
||||
return conn_info
|
||||
|
||||
@zm_utils.RemoveFCZone
|
||||
def terminate_connection(self, volume, connector, **kwargs):
|
||||
"""Disallow connection from connector."""
|
||||
LOG.debug("Entering terminate_connection"
|
||||
" - connector: %(connector)s.",
|
||||
{'connector': connector})
|
||||
conn_info = self.adapter.terminate_connection(volume, connector)
|
||||
LOG.debug("Exit terminate_connection"
|
||||
" - Returning connection info: %(conn_info)s.",
|
||||
{'conn_info': conn_info})
|
||||
return conn_info
|
||||
|
||||
def get_volume_stats(self, refresh=False):
|
||||
"""Get volume stats.
|
||||
|
||||
:param refresh: True to get updated data
|
||||
"""
|
||||
if refresh:
|
||||
self.update_volume_stats()
|
||||
|
||||
return self._stats
|
||||
|
||||
def update_volume_stats(self):
|
||||
"""Retrieve stats info from volume group."""
|
||||
LOG.debug("Updating volume stats.")
|
||||
stats = self.adapter.update_volume_stats()
|
||||
stats['driver_version'] = self.VERSION
|
||||
stats['vendor_name'] = self.VENDOR
|
||||
self._stats = stats
|
||||
|
||||
def manage_existing(self, volume, existing_ref):
|
||||
"""Manages an existing LUN in the array.
|
||||
|
||||
:param volume: the mapping cinder volume of the Unity LUN.
|
||||
:param existing_ref: the Unity LUN info.
|
||||
"""
|
||||
return self.adapter.manage_existing(volume, existing_ref)
|
||||
|
||||
def manage_existing_get_size(self, volume, existing_ref):
|
||||
"""Returns size of volume to be managed by manage_existing."""
|
||||
return self.adapter.manage_existing_get_size(volume, existing_ref)
|
||||
|
||||
def get_pool(self, volume):
|
||||
"""Returns the pool name of a volume."""
|
||||
return self.adapter.get_pool_name(volume)
|
||||
|
||||
def unmanage(self, volume):
|
||||
"""Unmanages a volume."""
|
||||
pass
|
||||
|
|
@ -0,0 +1,263 @@
|
|||
# Copyright (c) 2016 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.
|
||||
|
||||
from __future__ import division
|
||||
|
||||
import contextlib
|
||||
import functools
|
||||
from oslo_log import log as logging
|
||||
from oslo_utils import units
|
||||
import six
|
||||
|
||||
from cinder import exception
|
||||
from cinder.i18n import _, _LW
|
||||
from cinder.volume import utils as vol_utils
|
||||
from cinder.volume import volume_types
|
||||
from cinder.zonemanager import utils as zm_utils
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
BACKEND_QOS_CONSUMERS = frozenset(['back-end', 'both'])
|
||||
QOS_MAX_IOPS = 'maxIOPS'
|
||||
QOS_MAX_BWS = 'maxBWS'
|
||||
|
||||
|
||||
def dump_provider_location(location_dict):
|
||||
sorted_keys = sorted(location_dict.keys())
|
||||
return '|'.join('%(k)s^%(v)s' % {'k': k, 'v': location_dict[k]}
|
||||
for k in sorted_keys)
|
||||
|
||||
|
||||
def build_provider_location(system, lun_type, lun_id, version):
|
||||
"""Builds provider_location for volume or snapshot.
|
||||
|
||||
:param system: Unity serial number
|
||||
:param lun_id: LUN ID in Unity
|
||||
:param lun_type: 'lun'
|
||||
:param version: driver version
|
||||
"""
|
||||
location_dict = {'system': system,
|
||||
'type': lun_type,
|
||||
'id': six.text_type(lun_id),
|
||||
'version': version}
|
||||
return dump_provider_location(location_dict)
|
||||
|
||||
|
||||
def extract_provider_location(provider_location, key):
|
||||
"""Extracts value of the specified field from provider_location string.
|
||||
|
||||
:param provider_location: provider_location string
|
||||
:param key: field name of the value that to be extracted
|
||||
:return: value of the specified field if it exists, otherwise,
|
||||
None is returned
|
||||
"""
|
||||
if provider_location:
|
||||
for kvp in provider_location.split('|'):
|
||||
fields = kvp.split('^')
|
||||
if len(fields) == 2 and fields[0] == key:
|
||||
return fields[1]
|
||||
else:
|
||||
msg = _LW('"%(key)s" is not found in provider '
|
||||
'location "%(location)s."')
|
||||
LOG.warning(msg, {'key': key, 'location': provider_location})
|
||||
else:
|
||||
LOG.warning(_LW('Empty provider location received.'))
|
||||
|
||||
|
||||
def byte_to_gib(byte):
|
||||
return byte / units.Gi
|
||||
|
||||
|
||||
def byte_to_mib(byte):
|
||||
return byte / units.Mi
|
||||
|
||||
|
||||
def gib_to_mib(gib):
|
||||
return gib * units.Ki
|
||||
|
||||
|
||||
def validate_pool_names(conf_pools, array_pools):
|
||||
if not conf_pools:
|
||||
LOG.debug('No storage pools are specified. This host will manage '
|
||||
'all the pools on the Unity system.')
|
||||
return array_pools
|
||||
|
||||
conf_pools = set(map(lambda i: i.strip(), conf_pools))
|
||||
array_pools = set(map(lambda i: i.strip(), array_pools))
|
||||
existed = conf_pools & array_pools
|
||||
|
||||
if not existed:
|
||||
msg = (_('No storage pools to be managed exist. Please check '
|
||||
'your configuration. The available storage pools on the '
|
||||
'system are %s.') % array_pools)
|
||||
raise exception.VolumeBackendAPIException(data=msg)
|
||||
|
||||
return existed
|
||||
|
||||
|
||||
def extract_iscsi_uids(connector):
|
||||
if 'initiator' not in connector:
|
||||
msg = _("Host %s doesn't have iSCSI initiator.") % connector['host']
|
||||
raise exception.VolumeBackendAPIException(data=msg)
|
||||
|
||||
return [connector['initiator']]
|
||||
|
||||
|
||||
def extract_fc_uids(connector):
|
||||
if 'wwnns' not in connector or 'wwpns' not in connector:
|
||||
msg = _("Host %s doesn't have FC initiators.") % connector['host']
|
||||
LOG.error(msg)
|
||||
raise exception.VolumeBackendAPIException(data=msg)
|
||||
|
||||
wwnns = connector['wwnns']
|
||||
wwpns = connector['wwpns']
|
||||
wwns = [(node + port).upper() for node, port in zip(wwnns, wwpns)]
|
||||
|
||||
def _to_wwn(wwn):
|
||||
# Format the wwn to include the colon
|
||||
# For example, convert 1122200000051E55E100 to
|
||||
# 11:22:20:00:00:05:1E:55:A1:00
|
||||
return ':'.join(wwn[i:i + 2] for i in range(0, len(wwn), 2))
|
||||
|
||||
return list(map(_to_wwn, wwns))
|
||||
|
||||
|
||||
def convert_ip_to_portal(ip):
|
||||
return '%s:3260' % ip
|
||||
|
||||
|
||||
def convert_to_itor_tgt_map(zone_mapping):
|
||||
"""Function to process data from lookup service.
|
||||
|
||||
:param zone_mapping: mapping is the data from the zone lookup service
|
||||
with below format
|
||||
{
|
||||
<San name>: {
|
||||
'initiator_port_wwn_list':
|
||||
('200000051e55a100', '200000051e55a121'..)
|
||||
'target_port_wwn_list':
|
||||
('100000051e55a100', '100000051e55a121'..)
|
||||
}
|
||||
}
|
||||
"""
|
||||
target_wwns = []
|
||||
itor_tgt_map = {}
|
||||
for san_name in zone_mapping:
|
||||
one_map = zone_mapping[san_name]
|
||||
for target in one_map['target_port_wwn_list']:
|
||||
if target not in target_wwns:
|
||||
target_wwns.append(target)
|
||||
for initiator in one_map['initiator_port_wwn_list']:
|
||||
itor_tgt_map[initiator] = one_map['target_port_wwn_list']
|
||||
LOG.debug("target_wwns: %(tgt_wwns)s\n init_targ_map: %(itor_tgt_map)s",
|
||||
{'tgt_wwns': target_wwns,
|
||||
'itor_tgt_map': itor_tgt_map})
|
||||
return target_wwns, itor_tgt_map
|
||||
|
||||
|
||||
def get_pool_name(volume):
|
||||
return vol_utils.extract_host(volume.host, 'pool')
|
||||
|
||||
|
||||
def get_extra_spec(volume, spec_key):
|
||||
spec_value = None
|
||||
type_id = volume.volume_type_id
|
||||
if type_id is not None:
|
||||
extra_specs = volume_types.get_volume_type_extra_specs(type_id)
|
||||
if spec_key in extra_specs:
|
||||
spec_value = extra_specs[spec_key]
|
||||
return spec_value
|
||||
|
||||
|
||||
def ignore_exception(func, *args, **kwargs):
|
||||
try:
|
||||
func(*args, **kwargs)
|
||||
except Exception as ex:
|
||||
LOG.warning(_LW('Error occurred but ignored. Function: %(func_name)s, '
|
||||
'args: %(args)s, kwargs: %(kwargs)s, '
|
||||
'exception: %(ex)s.'),
|
||||
{'func_name': func, 'args': args,
|
||||
'kwargs': kwargs, 'ex': ex})
|
||||
|
||||
|
||||
@contextlib.contextmanager
|
||||
def assure_cleanup(enter_func, exit_func, use_enter_return):
|
||||
"""Assures the resource is cleaned up. Used as a context.
|
||||
|
||||
:param enter_func: the function to execute when entering the context.
|
||||
:param exit_func: the function to execute when leaving the context.
|
||||
:param use_enter_return: the flag indicates whether to pass the return
|
||||
value of enter_func in to the exit_func.
|
||||
"""
|
||||
|
||||
enter_return = None
|
||||
try:
|
||||
if isinstance(enter_func, functools.partial):
|
||||
enter_func_name = enter_func.func.__name__
|
||||
else:
|
||||
enter_func_name = enter_func.__name__
|
||||
LOG.debug(('Entering context. Function: %(func_name)s, '
|
||||
'use_enter_return: %(use)s.'),
|
||||
{'func_name': enter_func_name,
|
||||
'use': use_enter_return})
|
||||
enter_return = enter_func()
|
||||
yield enter_return
|
||||
finally:
|
||||
if isinstance(exit_func, functools.partial):
|
||||
exit_func_name = exit_func.func.__name__
|
||||
else:
|
||||
exit_func_name = exit_func.__name__
|
||||
LOG.debug(('Exiting context. Function: %(func_name)s, '
|
||||
'use_enter_return: %(use)s.'),
|
||||
{'func_name': exit_func_name,
|
||||
'use': use_enter_return})
|
||||
if enter_return is not None:
|
||||
if use_enter_return:
|
||||
ignore_exception(exit_func, enter_return)
|
||||
else:
|
||||
ignore_exception(exit_func)
|
||||
|
||||
|
||||
def create_lookup_service():
|
||||
return zm_utils.create_lookup_service()
|
||||
|
||||
|
||||
def get_backend_qos_specs(volume):
|
||||
type_id = volume.volume_type_id
|
||||
if type_id is None:
|
||||
return None
|
||||
|
||||
qos_specs = volume_types.get_volume_type_qos_specs(type_id)
|
||||
if qos_specs is None:
|
||||
return None
|
||||
|
||||
qos_specs = qos_specs['qos_specs']
|
||||
if qos_specs is None:
|
||||
return None
|
||||
|
||||
consumer = qos_specs['consumer']
|
||||
# Front end QoS specs are handled by nova. We ignore them here.
|
||||
if consumer not in BACKEND_QOS_CONSUMERS:
|
||||
return None
|
||||
|
||||
max_iops = qos_specs['specs'].get(QOS_MAX_IOPS)
|
||||
max_bws = qos_specs['specs'].get(QOS_MAX_BWS)
|
||||
if max_iops is None and max_bws is None:
|
||||
return None
|
||||
|
||||
return {
|
||||
'id': qos_specs['id'],
|
||||
QOS_MAX_IOPS: max_iops,
|
||||
QOS_MAX_BWS: max_bws,
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
---
|
||||
features:
|
||||
- Added backend driver for Dell EMC Unity storage.
|
||||
Loading…
Reference in New Issue