904 lines
33 KiB
Python
904 lines
33 KiB
Python
|
|
# Copyright 2012 OpenStack Foundation
|
|
# 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 math
|
|
|
|
import mock
|
|
import mox
|
|
from oslo.config import cfg
|
|
from oslo.serialization import jsonutils
|
|
from oslo.utils import units
|
|
|
|
from cinder.brick.initiator import connector
|
|
from cinder import exception
|
|
from cinder.image import image_utils
|
|
from cinder.openstack.common import log as logging
|
|
from cinder import test
|
|
from cinder import utils
|
|
from cinder.volume import configuration as conf
|
|
from cinder.volume.drivers import coraid
|
|
from cinder.volume import volume_types
|
|
|
|
|
|
CONF = cfg.CONF
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
def to_coraid_kb(gb):
|
|
return math.ceil(float(gb) * units.Gi / 1000)
|
|
|
|
|
|
def coraid_volume_size(gb):
|
|
return '{0}K'.format(to_coraid_kb(gb))
|
|
|
|
|
|
fake_esm_ipaddress = "192.168.0.1"
|
|
fake_esm_username = "darmok"
|
|
fake_esm_group = "tanagra"
|
|
fake_esm_group_id = 1
|
|
fake_esm_password = "12345678"
|
|
|
|
fake_coraid_repository_key = 'repository_key'
|
|
|
|
fake_volume_name = "volume-12345678-1234-1234-1234-1234567890ab"
|
|
fake_clone_name = "volume-ffffffff-1234-1234-1234-1234567890ab"
|
|
fake_volume_size = 10
|
|
fake_repository_name = "A-B:C:D"
|
|
fake_pool_name = "FakePool"
|
|
fake_aoetarget = 4081
|
|
fake_shelf = 16
|
|
fake_lun = 241
|
|
|
|
fake_str_aoetarget = str(fake_aoetarget)
|
|
fake_lun_addr = {"shelf": fake_shelf, "lun": fake_lun}
|
|
|
|
fake_volume_type = {'id': 1}
|
|
|
|
fake_volume = {"id": fake_volume_name,
|
|
"name": fake_volume_name,
|
|
"size": fake_volume_size,
|
|
"volume_type": fake_volume_type}
|
|
|
|
fake_clone_volume = {"name": fake_clone_name,
|
|
"size": fake_volume_size,
|
|
"volume_type": fake_volume_type}
|
|
|
|
fake_big_clone_volume = {"name": fake_clone_name,
|
|
"size": fake_volume_size + 1,
|
|
"volume_type": fake_volume_type}
|
|
|
|
fake_volume_info = {"pool": fake_pool_name,
|
|
"repo": fake_repository_name,
|
|
"vsxidx": fake_aoetarget,
|
|
"index": fake_lun,
|
|
"shelf": fake_shelf}
|
|
|
|
fake_lun_info = {"shelf": fake_shelf, "lun": fake_lun}
|
|
|
|
fake_snapshot_name = "snapshot-12345678-8888-8888-1234-1234567890ab"
|
|
fake_snapshot_id = "12345678-8888-8888-1234-1234567890ab"
|
|
fake_volume_id = "12345678-1234-1234-1234-1234567890ab"
|
|
fake_snapshot = {"id": fake_snapshot_id,
|
|
"name": fake_snapshot_name,
|
|
"volume_id": fake_volume_id,
|
|
"volume_name": fake_volume_name,
|
|
"volume_size": int(fake_volume_size) - 1,
|
|
"volume": fake_volume}
|
|
|
|
fake_configure_data = [{"addr": "cms", "data": "FAKE"}]
|
|
|
|
fake_esm_fetch = [[
|
|
{"command": "super_fake_command"},
|
|
{"reply": [
|
|
{"lv":
|
|
{"containingPool": fake_pool_name,
|
|
"lunIndex": fake_aoetarget,
|
|
"name": fake_volume_name,
|
|
"lvStatus":
|
|
{"exportedLun":
|
|
{"lun": fake_lun,
|
|
"shelf": fake_shelf}}
|
|
},
|
|
"repoName": fake_repository_name}]}]]
|
|
|
|
fake_esm_fetch_no_volume = [[
|
|
{"command": "super_fake_command"},
|
|
{"reply": []}]]
|
|
|
|
fake_esm_success = {"category": "provider",
|
|
"tracking": False,
|
|
"configState": "completedSuccessfully",
|
|
"heldPending": False,
|
|
"metaCROp": "noAction",
|
|
"message": None}
|
|
|
|
fake_group_fullpath = "admin group:%s" % (fake_esm_group)
|
|
fake_group_id = 4
|
|
fake_login_reply = {"values": [
|
|
{"fullPath": fake_group_fullpath,
|
|
"groupId": fake_group_id}],
|
|
"message": "",
|
|
"state": "adminSucceed",
|
|
"metaCROp": "noAction"}
|
|
|
|
fake_group_fail_fullpath = "fail group:%s" % (fake_esm_group)
|
|
fake_group_fail_id = 5
|
|
fake_login_reply_group_fail = {"values": [
|
|
{"fullPath": fake_group_fail_fullpath,
|
|
"groupId": fake_group_fail_id}],
|
|
"message": "",
|
|
"state": "adminSucceed",
|
|
"metaCROp": "noAction"}
|
|
|
|
|
|
def compare(a, b):
|
|
if type(a) != type(b):
|
|
return False
|
|
if type(a) == list or type(a) == tuple:
|
|
if len(a) != len(b):
|
|
return False
|
|
return all(map(lambda t: compare(t[0], t[1]), zip(a, b)))
|
|
elif type(a) == dict:
|
|
if len(a) != len(b):
|
|
return False
|
|
for k, v in a.items():
|
|
if not compare(v, b[k]):
|
|
return False
|
|
return True
|
|
else:
|
|
return a == b
|
|
|
|
|
|
def pack_data(request):
|
|
request['data'] = jsonutils.dumps(request['data'])
|
|
|
|
|
|
class FakeRpcBadRequest(Exception):
|
|
pass
|
|
|
|
|
|
class FakeRpcIsNotCalled(Exception):
|
|
def __init__(self, handle, url_params, data):
|
|
self.handle = handle
|
|
self.url_params = url_params
|
|
self.data = data
|
|
|
|
def __str__(self):
|
|
return 'Fake Rpc handle for {0}/{1}/{2} not found'.format(
|
|
self.handle, self.url_params, self.data)
|
|
|
|
|
|
class FakeRpcHandle(object):
|
|
def __init__(self, handle, url_params, data, result):
|
|
self.handle = handle
|
|
self.url_params = url_params
|
|
self.data = data
|
|
self.result = result
|
|
self._is_called = False
|
|
|
|
def set_called(self):
|
|
self._is_called = True
|
|
|
|
def __call__(self, handle, url_params, data,
|
|
allow_empty_response=False):
|
|
if handle != self.handle:
|
|
raise FakeRpcBadRequest(
|
|
'Unexpected handle name {0}. Expected {1}.'
|
|
.format(handle, self.handle))
|
|
if not compare(url_params, self.url_params):
|
|
raise FakeRpcBadRequest('Unexpected url params: {0} / {1}'
|
|
.format(url_params, self.url_params))
|
|
if not compare(data, self.data):
|
|
raise FakeRpcBadRequest('Unexpected data: {0}/{1}'
|
|
.format(data, self.data))
|
|
if callable(self.result):
|
|
return self.result()
|
|
else:
|
|
return self.result
|
|
|
|
|
|
class FakeRpc(object):
|
|
def __init__(self):
|
|
self._handles = []
|
|
|
|
def handle(self, handle, url_params, data, result):
|
|
self._handles.append(FakeRpcHandle(handle, url_params, data, result))
|
|
|
|
def __call__(self, handle_name, url_params, data,
|
|
allow_empty_response=False):
|
|
for handle in self._handles:
|
|
if (handle.handle == handle_name and
|
|
compare(handle.url_params, url_params) and
|
|
compare(handle.data, handle.data)):
|
|
handle.set_called()
|
|
return handle(handle_name, url_params, data,
|
|
allow_empty_response)
|
|
raise FakeRpcIsNotCalled(handle_name, url_params, data)
|
|
|
|
|
|
class CoraidDriverTestCase(test.TestCase):
|
|
def setUp(self):
|
|
super(CoraidDriverTestCase, self).setUp()
|
|
configuration = mox.MockObject(conf.Configuration)
|
|
configuration.append_config_values(mox.IgnoreArg())
|
|
configuration.coraid_default_repository = 'default_repository'
|
|
configuration.coraid_esm_address = fake_esm_ipaddress
|
|
configuration.coraid_user = fake_esm_username
|
|
configuration.coraid_group = fake_esm_group
|
|
configuration.coraid_password = fake_esm_password
|
|
configuration.volume_name_template = "volume-%s"
|
|
configuration.snapshot_name_template = "snapshot-%s"
|
|
configuration.coraid_repository_key = fake_coraid_repository_key
|
|
configuration.use_multipath_for_image_xfer = False
|
|
configuration.num_volume_device_scan_tries = 3
|
|
configuration.volume_dd_blocksize = '1M'
|
|
self.fake_rpc = FakeRpc()
|
|
|
|
self.stubs.Set(coraid.CoraidRESTClient, 'rpc', self.fake_rpc)
|
|
|
|
self.driver = coraid.CoraidDriver(configuration=configuration)
|
|
self.driver.do_setup({})
|
|
|
|
def mock_volume_types(self, repositories=None):
|
|
if not repositories:
|
|
repositories = [fake_repository_name]
|
|
self.mox.StubOutWithMock(volume_types, 'get_volume_type_extra_specs')
|
|
for repository in repositories:
|
|
(volume_types
|
|
.get_volume_type_extra_specs(fake_volume_type['id'],
|
|
fake_coraid_repository_key)
|
|
.AndReturn('<in> {0}'.format(repository)))
|
|
|
|
|
|
class CoraidDriverLoginSuccessTestCase(CoraidDriverTestCase):
|
|
def setUp(self):
|
|
super(CoraidDriverLoginSuccessTestCase, self).setUp()
|
|
|
|
login_results = {'state': 'adminSucceed',
|
|
'values': [
|
|
{'fullPath':
|
|
'admin group:{0}'.format(fake_esm_group),
|
|
'groupId': fake_esm_group_id
|
|
}]}
|
|
|
|
self.fake_rpc.handle('admin', {'op': 'login',
|
|
'username': fake_esm_username,
|
|
'password': fake_esm_password},
|
|
'Login', login_results)
|
|
|
|
self.fake_rpc.handle('admin', {'op': 'setRbacGroup',
|
|
'groupId': fake_esm_group_id},
|
|
'Group', {'state': 'adminSucceed'})
|
|
|
|
|
|
class CoraidDriverApplianceTestCase(CoraidDriverLoginSuccessTestCase):
|
|
def test_resize_volume(self):
|
|
new_volume_size = int(fake_volume_size) + 1
|
|
|
|
fetch_request = {'shelf': 'cms',
|
|
'orchStrRepo': '',
|
|
'lv': fake_volume_name}
|
|
self.fake_rpc.handle('fetch', fetch_request, None,
|
|
fake_esm_fetch)
|
|
|
|
reply = {'configState': 'completedSuccessfully'}
|
|
|
|
resize_volume_request = {'addr': 'cms',
|
|
'data': {
|
|
'lvName': fake_volume_name,
|
|
'newLvName': fake_volume_name + '-resize',
|
|
'size':
|
|
coraid_volume_size(new_volume_size),
|
|
'repoName': fake_repository_name},
|
|
'op': 'orchStrLunMods',
|
|
'args': 'resize'}
|
|
pack_data(resize_volume_request)
|
|
self.fake_rpc.handle('configure', {}, [resize_volume_request],
|
|
reply)
|
|
|
|
real_reply = self.driver.appliance.resize_volume(fake_volume_name,
|
|
new_volume_size)
|
|
|
|
self.assertEqual(reply['configState'], real_reply['configState'])
|
|
|
|
|
|
class CoraidDriverIntegrationalTestCase(CoraidDriverLoginSuccessTestCase):
|
|
def setUp(self):
|
|
super(CoraidDriverIntegrationalTestCase, self).setUp()
|
|
self.appliance = self.driver.appliance
|
|
# NOTE(nsobolevsky) prevent re-creation esm appliance
|
|
self.stubs.Set(coraid.CoraidDriver, 'appliance', self.appliance)
|
|
|
|
def test_create_volume(self):
|
|
self.mock_volume_types()
|
|
|
|
create_volume_request = {'addr': 'cms',
|
|
'data': {
|
|
'servers': [],
|
|
'size':
|
|
coraid_volume_size(fake_volume_size),
|
|
'repoName': fake_repository_name,
|
|
'lvName': fake_volume_name},
|
|
'op': 'orchStrLun',
|
|
'args': 'add'}
|
|
pack_data(create_volume_request)
|
|
|
|
self.fake_rpc.handle('configure', {}, [create_volume_request],
|
|
{'configState': 'completedSuccessfully',
|
|
'firstParam': 'fake_first_param'})
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.create_volume(fake_volume)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
@mock.patch.object(volume_types, 'get_volume_type_extra_specs')
|
|
def test_create_volume_volume_type_no_repo_key(self, volume_specs_mock):
|
|
"""Test volume creation without repo specified in volume type."""
|
|
volume_specs_mock.return_value = None
|
|
|
|
create_volume_request = {'addr': 'cms',
|
|
'data': {
|
|
'servers': [],
|
|
'size':
|
|
coraid_volume_size(fake_volume_size),
|
|
'repoName': 'default_repository',
|
|
'lvName': fake_volume_name},
|
|
'op': 'orchStrLun',
|
|
'args': 'add'}
|
|
pack_data(create_volume_request)
|
|
|
|
self.fake_rpc.handle('configure', {}, [create_volume_request],
|
|
{'configState': 'completedSuccessfully',
|
|
'firstParam': 'fake_first_param'})
|
|
|
|
self.driver.create_volume(fake_volume)
|
|
|
|
@mock.patch.object(volume_types, 'get_volume_type_extra_specs')
|
|
def test_create_volume_volume_type_no_repo_data(self, volume_specs_mock):
|
|
"""Test volume creation w/o repo in volume type nor config."""
|
|
volume_specs_mock.return_value = None
|
|
self.driver.configuration.coraid_default_repository = None
|
|
|
|
create_volume_request = {'addr': 'cms',
|
|
'data': {
|
|
'servers': [],
|
|
'size':
|
|
coraid_volume_size(fake_volume_size),
|
|
'repoName': 'default_repository',
|
|
'lvName': fake_volume_name},
|
|
'op': 'orchStrLun',
|
|
'args': 'add'}
|
|
pack_data(create_volume_request)
|
|
|
|
self.fake_rpc.handle('configure', {}, [create_volume_request],
|
|
{'configState': 'completedSuccessfully',
|
|
'firstParam': 'fake_first_param'})
|
|
|
|
self.assertRaises(exception.CoraidException,
|
|
self.driver.create_volume, fake_volume)
|
|
|
|
def test_delete_volume(self):
|
|
delete_volume_request = {'addr': 'cms',
|
|
'data': {
|
|
'repoName': fake_repository_name,
|
|
'lvName': fake_volume_name},
|
|
'op': 'orchStrLun/verified',
|
|
'args': 'delete'}
|
|
pack_data(delete_volume_request)
|
|
|
|
self.fake_rpc.handle('configure', {}, [delete_volume_request],
|
|
{'configState': 'completedSuccessfully'})
|
|
|
|
self.fake_rpc.handle('fetch', {'orchStrRepo': '',
|
|
'shelf': 'cms',
|
|
'lv': fake_volume_name},
|
|
None,
|
|
fake_esm_fetch)
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.delete_volume(fake_volume)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_ping_ok(self):
|
|
self.fake_rpc.handle('fetch', {}, None, '')
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.appliance.ping()
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_ping_failed(self):
|
|
def rpc(handle, url_params, data,
|
|
allow_empty_response=True):
|
|
raise test.TestingException("Some exception")
|
|
|
|
self.stubs.Set(self.driver.appliance, 'rpc', rpc)
|
|
self.mox.ReplayAll()
|
|
|
|
self.assertRaises(exception.CoraidESMNotAvailable,
|
|
self.driver.appliance.ping)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_delete_not_existing_lun(self):
|
|
delete_volume_request = {'addr': 'cms',
|
|
'data': {
|
|
'repoName': fake_repository_name,
|
|
'lvName': fake_volume_name},
|
|
'op': 'orchStrLun/verified',
|
|
'args': 'delete'}
|
|
pack_data(delete_volume_request)
|
|
|
|
self.fake_rpc.handle('configure', {}, [delete_volume_request],
|
|
{'configState': 'completedSuccessfully'})
|
|
|
|
self.fake_rpc.handle('fetch', {'orchStrRepo': '',
|
|
'shelf': 'cms',
|
|
'lv': fake_volume_name},
|
|
None,
|
|
fake_esm_fetch_no_volume)
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.assertRaises(
|
|
exception.VolumeNotFound,
|
|
self.driver.appliance.delete_lun,
|
|
fake_volume['name'])
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_delete_not_existing_volumeappliance_is_ok(self):
|
|
def delete_lun(volume_name):
|
|
raise exception.VolumeNotFound(volume_id=fake_volume['name'])
|
|
|
|
self.stubs.Set(self.driver.appliance, 'delete_lun', delete_lun)
|
|
|
|
def ping():
|
|
pass
|
|
|
|
self.stubs.Set(self.driver.appliance, 'ping', ping)
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.delete_volume(fake_volume)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_delete_not_existing_volume_sleepingappliance(self):
|
|
def delete_lun(volume_name):
|
|
raise exception.VolumeNotFound(volume_id=fake_volume['name'])
|
|
|
|
self.stubs.Set(self.driver.appliance, 'delete_lun', delete_lun)
|
|
|
|
def ping():
|
|
raise exception.CoraidESMNotAvailable(reason="Any reason")
|
|
|
|
self.stubs.Set(self.driver.appliance, 'ping', ping)
|
|
|
|
self.driver.appliance.ping = ping
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.assertRaises(exception.CoraidESMNotAvailable,
|
|
self.driver.delete_volume,
|
|
fake_volume)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_create_snapshot(self):
|
|
fetch_request = {'shelf': 'cms',
|
|
'orchStrRepo': '',
|
|
'lv': fake_volume_name}
|
|
self.fake_rpc.handle('fetch', fetch_request, None,
|
|
fake_esm_fetch)
|
|
|
|
create_snapshot_request = {'addr': 'cms',
|
|
'data': {
|
|
'repoName': fake_repository_name,
|
|
'lvName': fake_volume_name,
|
|
'newLvName': fake_snapshot_name},
|
|
'op': 'orchStrLunMods',
|
|
'args': 'addClSnap'}
|
|
pack_data(create_snapshot_request)
|
|
self.fake_rpc.handle('configure', {}, [create_snapshot_request],
|
|
{'configState': 'completedSuccessfully'})
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.create_snapshot(fake_snapshot)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_delete_snapshot(self):
|
|
fetch_request = {'shelf': 'cms',
|
|
'orchStrRepo': '',
|
|
'lv': fake_snapshot_name}
|
|
self.fake_rpc.handle('fetch', fetch_request, None,
|
|
fake_esm_fetch)
|
|
|
|
delete_snapshot_request = {'addr': 'cms',
|
|
'data': {
|
|
'repoName': fake_repository_name,
|
|
'lvName': fake_snapshot_name,
|
|
'newLvName': 'noop'},
|
|
'op': 'orchStrLunMods',
|
|
'args': 'delClSnap'}
|
|
pack_data(delete_snapshot_request)
|
|
self.fake_rpc.handle('configure', {}, [delete_snapshot_request],
|
|
{'configState': 'completedSuccessfully'})
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.delete_snapshot(fake_snapshot)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_create_volume_from_snapshot(self):
|
|
self.mock_volume_types()
|
|
|
|
self.mox.StubOutWithMock(self.driver.appliance, 'resize_volume')
|
|
self.driver.appliance.resize_volume(fake_volume_name,
|
|
fake_volume['size'])\
|
|
.AndReturn(None)
|
|
|
|
fetch_request = {'shelf': 'cms',
|
|
'orchStrRepo': '',
|
|
'lv': fake_snapshot_name}
|
|
self.fake_rpc.handle('fetch', fetch_request, None,
|
|
fake_esm_fetch)
|
|
|
|
create_clone_request = {'addr': 'cms',
|
|
'data': {
|
|
'lvName': fake_snapshot_name,
|
|
'repoName': fake_repository_name,
|
|
'newLvName': fake_volume_name,
|
|
'newRepoName': fake_repository_name},
|
|
'op': 'orchStrLunMods',
|
|
'args': 'addClone'}
|
|
pack_data(create_clone_request)
|
|
self.fake_rpc.handle('configure', {}, [create_clone_request],
|
|
{'configState': 'completedSuccessfully'})
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.create_volume_from_snapshot(fake_volume, fake_snapshot)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_initialize_connection(self):
|
|
fetch_request = {'shelf': 'cms',
|
|
'orchStrRepo': '',
|
|
'lv': fake_volume_name}
|
|
self.fake_rpc.handle('fetch', fetch_request, None,
|
|
fake_esm_fetch)
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
connection = self.driver.initialize_connection(fake_volume, {})
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
self.assertEqual(connection['driver_volume_type'], 'aoe')
|
|
self.assertEqual(connection['data']['target_shelf'], fake_shelf)
|
|
self.assertEqual(connection['data']['target_lun'], fake_lun)
|
|
|
|
def test_get_repository_capabilities(self):
|
|
reply = [[{}, {'reply': [
|
|
{'name': 'repo1',
|
|
'profile':
|
|
{'fullName': 'Bronze-Bronze:Profile1'}},
|
|
{'name': 'repo2',
|
|
'profile':
|
|
{'fullName': 'Bronze-Bronze:Profile2'}}]}]]
|
|
|
|
self.fake_rpc.handle('fetch', {'orchStrRepo': ''}, None,
|
|
reply)
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
capabilities = self.driver.get_volume_stats(refresh=True)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
self.assertEqual(
|
|
capabilities[fake_coraid_repository_key],
|
|
'Bronze-Bronze:Profile1:repo1 Bronze-Bronze:Profile2:repo2')
|
|
|
|
def test_create_cloned_volume(self):
|
|
self.mock_volume_types([fake_repository_name])
|
|
|
|
fetch_request = {'shelf': 'cms',
|
|
'orchStrRepo': '',
|
|
'lv': fake_volume_name}
|
|
self.fake_rpc.handle('fetch', fetch_request, None,
|
|
fake_esm_fetch)
|
|
|
|
shelf_lun = '{0}.{1}'.format(fake_shelf, fake_lun)
|
|
create_clone_request = {'addr': 'cms',
|
|
'data': {
|
|
'shelfLun': shelf_lun,
|
|
'lvName': fake_volume_name,
|
|
'repoName': fake_repository_name,
|
|
'newLvName': fake_clone_name,
|
|
'newRepoName': fake_repository_name},
|
|
'op': 'orchStrLunMods',
|
|
'args': 'addClone'}
|
|
pack_data(create_clone_request)
|
|
self.fake_rpc.handle('configure', {}, [create_clone_request],
|
|
{'configState': 'completedSuccessfully'})
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.create_cloned_volume(fake_clone_volume, fake_volume)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_create_cloned_volume_with_resize(self):
|
|
self.mock_volume_types([fake_repository_name])
|
|
|
|
self.mox.StubOutWithMock(self.driver.appliance, 'resize_volume')
|
|
self.driver.appliance.resize_volume(fake_big_clone_volume['name'],
|
|
fake_big_clone_volume['size'])\
|
|
.AndReturn(None)
|
|
|
|
fetch_request = {'shelf': 'cms',
|
|
'orchStrRepo': '',
|
|
'lv': fake_volume_name}
|
|
self.fake_rpc.handle('fetch', fetch_request, None,
|
|
fake_esm_fetch)
|
|
|
|
shelf_lun = '{0}.{1}'.format(fake_shelf, fake_lun)
|
|
create_clone_request = {'addr': 'cms',
|
|
'data': {
|
|
'shelfLun': shelf_lun,
|
|
'lvName': fake_volume_name,
|
|
'repoName': fake_repository_name,
|
|
'newLvName': fake_clone_name,
|
|
'newRepoName': fake_repository_name},
|
|
'op': 'orchStrLunMods',
|
|
'args': 'addClone'}
|
|
pack_data(create_clone_request)
|
|
self.fake_rpc.handle('configure', {}, [create_clone_request],
|
|
{'configState': 'completedSuccessfully'})
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.create_cloned_volume(fake_big_clone_volume, fake_volume)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_create_cloned_volume_in_different_repository(self):
|
|
self.mock_volume_types([fake_repository_name + '_another'])
|
|
|
|
fetch_request = {'shelf': 'cms',
|
|
'orchStrRepo': '',
|
|
'lv': fake_volume_name}
|
|
self.fake_rpc.handle('fetch', fetch_request, None,
|
|
fake_esm_fetch)
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.assertRaises(
|
|
exception.CoraidException,
|
|
self.driver.create_cloned_volume,
|
|
fake_clone_volume,
|
|
fake_volume)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_extend_volume(self):
|
|
self.mox.StubOutWithMock(self.driver.appliance, 'resize_volume')
|
|
self.driver.appliance.resize_volume(fake_volume_name, 10)\
|
|
.AndReturn(None)
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.extend_volume(fake_volume, 10)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
|
|
class AutoReloginCoraidTestCase(test.TestCase):
|
|
def setUp(self):
|
|
super(AutoReloginCoraidTestCase, self).setUp()
|
|
self.rest_client = coraid.CoraidRESTClient('https://fake')
|
|
self.appliance = coraid.CoraidAppliance(self.rest_client,
|
|
'fake_username',
|
|
'fake_password',
|
|
'fake_group')
|
|
|
|
def _test_auto_relogin_fail(self, state):
|
|
self.mox.StubOutWithMock(self.rest_client, 'rpc')
|
|
|
|
self.rest_client.rpc('fake_handle', {}, None, False).\
|
|
AndReturn({'state': state,
|
|
'metaCROp': 'reboot'})
|
|
|
|
self.rest_client.rpc('fake_handle', {}, None, False).\
|
|
AndReturn({'state': state,
|
|
'metaCROp': 'reboot'})
|
|
|
|
self.rest_client.rpc('fake_handle', {}, None, False).\
|
|
AndReturn({'state': state,
|
|
'metaCROp': 'reboot'})
|
|
|
|
self.mox.StubOutWithMock(self.appliance, '_ensure_session')
|
|
self.appliance._ensure_session().AndReturn(None)
|
|
|
|
self.mox.StubOutWithMock(self.appliance, '_relogin')
|
|
self.appliance._relogin().AndReturn(None)
|
|
self.appliance._relogin().AndReturn(None)
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.assertRaises(exception.CoraidESMReloginFailed,
|
|
self.appliance.rpc,
|
|
'fake_handle', {}, None, False)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_auto_relogin_fail_admin(self):
|
|
self._test_auto_relogin_fail('GeneralAdminFailure')
|
|
|
|
def test_auto_relogin_fail_inactivity(self):
|
|
self._test_auto_relogin_fail('passwordInactivityTimeout')
|
|
|
|
def test_auto_relogin_fail_absolute(self):
|
|
self._test_auto_relogin_fail('passwordAbsoluteTimeout')
|
|
|
|
def test_auto_relogin_success(self):
|
|
self.mox.StubOutWithMock(self.rest_client, 'rpc')
|
|
|
|
self.rest_client.rpc('fake_handle', {}, None, False).\
|
|
AndReturn({'state': 'GeneralAdminFailure',
|
|
'metaCROp': 'reboot'})
|
|
|
|
self.rest_client.rpc('fake_handle', {}, None, False).\
|
|
AndReturn({'state': 'ok'})
|
|
|
|
self.mox.StubOutWithMock(self.appliance, '_ensure_session')
|
|
self.appliance._ensure_session().AndReturn(None)
|
|
|
|
self.mox.StubOutWithMock(self.appliance, '_relogin')
|
|
self.appliance._relogin().AndReturn(None)
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
reply = self.appliance.rpc('fake_handle', {}, None, False)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
self.assertEqual(reply['state'], 'ok')
|
|
|
|
|
|
class CoraidDriverImageTestCases(CoraidDriverTestCase):
|
|
def setUp(self):
|
|
super(CoraidDriverImageTestCases, self).setUp()
|
|
|
|
self.fake_dev_path = '/dev/ether/fake_dev'
|
|
|
|
self.fake_connection = {'driver_volume_type': 'aoe',
|
|
'data': {'target_shelf': fake_shelf,
|
|
'target_lun': fake_lun}}
|
|
|
|
self.fake_volume_info = {
|
|
'shelf': self.fake_connection['data']['target_shelf'],
|
|
'lun': self.fake_connection['data']['target_lun']}
|
|
|
|
self.mox.StubOutWithMock(self.driver, 'initialize_connection')
|
|
self.driver.initialize_connection(fake_volume, {})\
|
|
.AndReturn(self.fake_connection)
|
|
|
|
self.mox.StubOutWithMock(self.driver, 'terminate_connection')
|
|
self.driver.terminate_connection(fake_volume, mox.IgnoreArg(),
|
|
force=False).AndReturn(None)
|
|
|
|
root_helper = 'sudo cinder-rootwrap /etc/cinder/rootwrap.conf'
|
|
|
|
self.mox.StubOutWithMock(connector, 'get_connector_properties')
|
|
connector.get_connector_properties(root_helper,
|
|
CONF.my_ip).\
|
|
AndReturn({})
|
|
|
|
self.mox.StubOutWithMock(utils, 'brick_get_connector')
|
|
|
|
aoe_initiator = self.mox.CreateMockAnything()
|
|
|
|
utils.brick_get_connector('aoe',
|
|
device_scan_attempts=3,
|
|
use_multipath=False,
|
|
conn=mox.IgnoreArg()).\
|
|
AndReturn(aoe_initiator)
|
|
|
|
aoe_initiator\
|
|
.connect_volume(self.fake_connection['data'])\
|
|
.AndReturn({'path': self.fake_dev_path})
|
|
|
|
aoe_initiator.check_valid_device(self.fake_dev_path, mox.IgnoreArg())\
|
|
.AndReturn(True)
|
|
|
|
aoe_initiator.disconnect_volume(
|
|
{'target_shelf': self.fake_volume_info['shelf'],
|
|
'target_lun': self.fake_volume_info['lun']}, mox.IgnoreArg())
|
|
|
|
def test_copy_volume_to_image(self):
|
|
fake_image_service = 'fake-image-service'
|
|
fake_image_meta = 'fake-image-meta'
|
|
|
|
self.mox.StubOutWithMock(image_utils, 'upload_volume')
|
|
image_utils.upload_volume({},
|
|
fake_image_service,
|
|
fake_image_meta,
|
|
self.fake_dev_path)
|
|
|
|
self.mox.ReplayAll()
|
|
self.driver.copy_volume_to_image({},
|
|
fake_volume,
|
|
fake_image_service,
|
|
fake_image_meta)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
def test_copy_image_to_volume(self):
|
|
fake_image_service = 'fake-image-service'
|
|
fake_image_id = 'fake-image-id;'
|
|
|
|
self.mox.StubOutWithMock(image_utils, 'fetch_to_raw')
|
|
image_utils.fetch_to_raw({},
|
|
fake_image_service,
|
|
fake_image_id,
|
|
self.fake_dev_path,
|
|
mox.IgnoreArg(),
|
|
size=fake_volume_size)
|
|
|
|
self.mox.ReplayAll()
|
|
|
|
self.driver.copy_image_to_volume({},
|
|
fake_volume,
|
|
fake_image_service,
|
|
fake_image_id)
|
|
|
|
self.mox.VerifyAll()
|
|
|
|
|
|
class CoraidResetConnectionTestCase(CoraidDriverTestCase):
|
|
def test_create_new_appliance_for_every_request(self):
|
|
self.mox.StubOutWithMock(coraid, 'CoraidRESTClient')
|
|
self.mox.StubOutWithMock(coraid, 'CoraidAppliance')
|
|
|
|
coraid.CoraidRESTClient(mox.IgnoreArg())
|
|
coraid.CoraidRESTClient(mox.IgnoreArg())
|
|
|
|
coraid.CoraidAppliance(mox.IgnoreArg(),
|
|
mox.IgnoreArg(),
|
|
mox.IgnoreArg(),
|
|
mox.IgnoreArg()).AndReturn('fake_app1')
|
|
coraid.CoraidAppliance(mox.IgnoreArg(),
|
|
mox.IgnoreArg(),
|
|
mox.IgnoreArg(),
|
|
mox.IgnoreArg()).AndReturn('fake_app2')
|
|
self.mox.ReplayAll()
|
|
|
|
self.assertEqual(self.driver.appliance, 'fake_app1')
|
|
self.assertEqual(self.driver.appliance, 'fake_app2')
|
|
|
|
self.mox.VerifyAll()
|