def validate(self, storagerouter=None, storagedriver=None):
"""
Perform some validations before creating or extending a vPool
:param storagerouter: StorageRouter on which the vPool will be created or extended
:type storagerouter: ovs.dal.hybrids.storagerouter.StorageRouter
:param storagedriver: When passing a StorageDriver, perform validations when shrinking a vPool
:type storagedriver: ovs.dal.hybrids.storagedriver.StorageDriver
:raises ValueError: If extending a vPool which status is not RUNNING
RuntimeError: If this vPool's configuration does not meet the requirements
If the vPool has already been extended on the specified StorageRouter
:return: None
:rtype: NoneType
"""
if self.vpool is not None:
if self.vpool.status != VPool.STATUSES.RUNNING:
raise ValueError('vPool should be in {0} status'.format(
VPool.STATUSES.RUNNING))
ExtensionsToolbox.verify_required_params(
actual_params=self.vpool.configuration,
required_params={
'sco_size':
(int, StorageDriverClient.TLOG_MULTIPLIER_MAP.keys()),
'dtl_mode':
(str, StorageDriverClient.VPOOL_DTL_MODE_MAP.keys()),
'write_buffer': (float, None),
'dtl_transport':
(str, StorageDriverClient.VPOOL_DTL_TRANSPORT_MAP.keys()),
'tlog_multiplier':
(int, StorageDriverClient.TLOG_MULTIPLIER_MAP.values())
})
if storagerouter is not None:
for vpool_storagedriver in self.vpool.storagedrivers:
if vpool_storagedriver.storagerouter_guid == storagerouter.guid:
raise RuntimeError(
'A StorageDriver is already linked to this StorageRouter for vPool {0}'
.format(self.vpool.name))
if storagedriver is not None:
VDiskController.sync_with_reality(vpool_guid=self.vpool.guid)
storagedriver.invalidate_dynamics('vdisks_guids')
if len(storagedriver.vdisks_guids) > 0:
raise RuntimeError(
'There are still vDisks served from the given StorageDriver'
)
self.mds_services = [
mds_service for mds_service in self.vpool.mds_services
if mds_service.service.storagerouter_guid ==
storagedriver.storagerouter_guid
]
for mds_service in self.mds_services:
if len(mds_service.storagedriver_partitions
) == 0 or mds_service.storagedriver_partitions[
0].storagedriver is None:
raise RuntimeError(
'Failed to retrieve the linked StorageDriver to this MDS Service {0}'
.format(mds_service.service.name))
def test_sync_vdisk_with_voldrv(self):
clone_depth = 3
def _make_clones(vdisks_map, depth=clone_depth):
for level in range(depth):
previous_vd = list(vdisks_map.itervalues())[-1]
new_name = previous_vd.name + '_clone'
new_guid = VDiskController.clone(previous_vd.guid,
new_name).get('vdisk_guid')
vdisks_map[new_name] = VDisk(new_guid)
structure = DalHelper.build_dal_structure({
'vpools': [1],
'storagerouters': [1],
'storagedrivers':
[(1, 1, 1)], # (<id>, <vpool_id>, <storagerouter_id>)
'mds_services': [(1, 1)]
} # (<id>, <storagedriver_id>)
)
vdisk_name = 'vdisk_1'
storagedriver = structure['storagedrivers'][1]
vdisk_1 = VDisk(
VDiskController.create_new(volume_name=vdisk_name,
volume_size=1024**4,
storagedriver_guid=storagedriver.guid))
vdisks = OrderedDict()
vdisks[vdisk_name] = vdisk_1
_make_clones(vdisks)
self.assertEquals(clone_depth + 1, len(list(VDiskList.get_vdisks())))
delete_list = list(vdisks.itervalues(
))[::-1][:-1] # These vDisks are clones and ought to be deleted
for vdisk in delete_list:
for mds_service in vdisk.mds_services:
mds_service.delete()
vdisk.delete()
self.assertEquals(1, len(list(VDiskList.get_vdisks()))
) # Make sure vDisk clones are properly removed
self.assertEquals(
VDiskList.get_vdisks()[0].name,
vdisk_name) # Make sure only item left is original vDisk
VDiskController.sync_with_reality()
self.assertEquals(clone_depth + 1, len(list(
VDiskList.get_vdisks()))) # The clones should be in place now
parents = 0
for vdisk in VDiskList.get_vdisks():
try:
if vdisk.parent_vdisk.name:
parents += 1
except AttributeError:
pass
self.assertEquals(
clone_depth, parents
) # As much parents should be detected as the depth of the clones
def test_sync(self):
"""
Validates whether the sync works as expected
"""
structure = DalHelper.build_dal_structure({
'vpools': [1],
'storagerouters': [1],
'storagedrivers':
[(1, 1, 1)], # (<id>, <vpool_id>, <storagerouter_id>)
'mds_services': [(1, 1)]
} # (<id>, <storagedriver_id>)
)
vpool = structure['vpools'][1]
storagedriver = structure['storagedrivers'][1]
mds_service = structure['mds_services'][1]
# noinspection PyArgumentList
backend_config = MDSMetaDataBackendConfig([
MDSNodeConfig(address=str(mds_service.service.storagerouter.ip),
port=mds_service.service.ports[0])
])
srclient = StorageRouterClient(vpool.guid, None)
VDiskController.create_new('one', 1024**3, storagedriver.guid)
VDiskController.create_new('two', 1024**3, storagedriver.guid)
vdisks = VDiskList.get_vdisks()
self.assertEqual(len(vdisks), 2)
self.assertEqual(len(srclient.list_volumes()), 2)
VDiskController.sync_with_reality()
vdisks = VDiskList.get_vdisks()
self.assertEqual(len(vdisks), 2)
self.assertEqual(len(srclient.list_volumes()), 2)
volume_id = srclient.create_volume('/three.raw', backend_config,
1024**3,
storagedriver.storagedriver_id)
vdisks = VDiskList.get_vdisks()
self.assertEqual(len(vdisks), 2)
self.assertEqual(len(srclient.list_volumes()), 3)
VDiskController.sync_with_reality()
vdisks = VDiskList.get_vdisks()
self.assertEqual(len(vdisks), 3)
self.assertEqual(len(srclient.list_volumes()), 3)
vdisk = VDiskList.get_vdisk_by_volume_id(volume_id)
self.assertEqual(vdisk.devicename, '/three.raw')
vdisk = VDisk()
vdisk.volume_id = 'foo'
vdisk.name = 'foo'
vdisk.devicename = 'foo.raw'
vdisk.size = 1024**3
vdisk.vpool = vpool
vdisk.save()
vdisks = VDiskList.get_vdisks()
self.assertEqual(len(vdisks), 4)
self.assertEqual(len(srclient.list_volumes()), 3)
VDiskController.sync_with_reality()
vdisks = VDiskList.get_vdisks()
self.assertEqual(len(vdisks), 3)
self.assertEqual(len(srclient.list_volumes()), 3)
with self.assertRaises(ObjectNotFoundException):
vdisk.save()
