def test_obj_load_attr(self, mock_va_get_all_by_vol, mock_vt_get_by_id, mock_admin_metadata_get, mock_metadata_get):
volume = objects.Volume._from_db_object(self.context, objects.Volume(), fake_volume.fake_db_volume())
# Test metadata lazy-loaded field
metadata = {"foo": "bar"}
mock_metadata_get.return_value = metadata
self.assertEqual(metadata, volume.metadata)
mock_metadata_get.assert_called_once_with(self.context, volume.id)
# Test volume_type lazy-loaded field
volume_type = objects.VolumeType(context=self.context, id=5)
mock_vt_get_by_id.return_value = volume_type
self.assertEqual(volume_type, volume.volume_type)
mock_vt_get_by_id.assert_called_once_with(self.context, volume.volume_type_id)
# Test volume_attachment lazy-loaded field
va_objs = [objects.VolumeAttachment(context=self.context, id=i) for i in [3, 4, 5]]
va_list = objects.VolumeAttachmentList(context=self.context, objects=va_objs)
mock_va_get_all_by_vol.return_value = va_list
self.assertEqual(va_list, volume.volume_attachment)
mock_va_get_all_by_vol.assert_called_once_with(self.context, volume.id)
# Test admin_metadata lazy-loaded field - user context
adm_metadata = {"bar": "foo"}
mock_admin_metadata_get.return_value = adm_metadata
self.assertEqual({}, volume.admin_metadata)
self.assertFalse(mock_admin_metadata_get.called)
# Test admin_metadata lazy-loaded field - admin context
adm_context = self.context.elevated()
volume = objects.Volume._from_db_object(adm_context, objects.Volume(), fake_volume.fake_db_volume())
adm_metadata = {"bar": "foo"}
mock_admin_metadata_get.return_value = adm_metadata
self.assertEqual(adm_metadata, volume.admin_metadata)
mock_admin_metadata_get.assert_called_once_with(adm_context, volume.id)
def test_finish_volume_migration(self, volume_update, metadata_update):
src_volume_db = fake_volume.fake_db_volume(**{'id': fake.volume_id})
dest_volume_db = fake_volume.fake_db_volume(**{'id': fake.volume2_id})
src_volume = objects.Volume._from_db_object(
self.context, objects.Volume(), src_volume_db,
expected_attrs=['metadata', 'glance_metadata'])
dest_volume = objects.Volume._from_db_object(
self.context, objects.Volume(), dest_volume_db,
expected_attrs=['metadata', 'glance_metadata'])
updated_dest_volume = src_volume.finish_volume_migration(
dest_volume)
self.assertEqual('deleting', updated_dest_volume.migration_status)
self.assertEqual('migration src for ' + src_volume.id,
updated_dest_volume.display_description)
self.assertEqual(src_volume.id, updated_dest_volume._name_id)
self.assertTrue(volume_update.called)
# Ignore these attributes, since they were updated by
# finish_volume_migration
ignore_keys = ('id', 'provider_location', '_name_id',
'migration_status', 'display_description', 'status')
dest_vol_filtered = {k: v for k, v in updated_dest_volume.iteritems()
if k not in ignore_keys}
src_vol_filtered = {k: v for k, v in src_volume.iteritems()
if k not in ignore_keys}
self.assertEqual(src_vol_filtered, dest_vol_filtered)
def test_get_by_project_with_sort_key(self, sort_keys):
fake_volume.fake_db_volume()
self.assertRaises(exception.InvalidInput,
objects.VolumeList.get_all_by_project,
self.context,
self.context.project_id,
sort_keys=sort_keys)
def test_restore_backup(self, arg1):
"""Test restore_backup."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
rc_vol = self.driver.create_volume(volume)
volume['provider_location'] = rc_vol['provider_location']
volume_backup = fake_volume.fake_db_volume(**self._VOLUME_BACKUP)
self.driver.restore_backup(None, volume_backup, volume, None)
arg1.assert_called_with(None, volume_backup, volume, None)
def test_create_cloned_volume_error_on_non_existing_volume(self):
"""Test create_cloned_volume is error on non existing volume."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
volume['provider_location'] = '1'
volume2 = fake_volume.fake_db_volume(**self._VOLUME2)
self.assertRaises(exception.VolumeBackendAPIException,
self.driver.create_cloned_volume,
volume2, volume)
def test_create_volume_error_on_no_available_ldev(self):
"""Test create_volume is error on no available ldev."""
for i in range(1, 1024):
volume = fake_volume.fake_db_volume(**self._VOLUME)
rc = self.driver.create_volume(volume)
self.assertEqual(str(i), rc['provider_location'])
volume = fake_volume.fake_db_volume(**self._VOLUME)
self.assertRaises(exception.VolumeBackendAPIException,
self.driver.create_volume, volume)
def test_restore_backup_error(self, arg1):
"""Test restore_backup is error."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
volume['provider_location'] = '1'
volume_backup = fake_volume.fake_db_volume(**self._VOLUME_BACKUP)
self.assertRaises(exception.CinderException,
self.driver.restore_backup,
None, volume_backup, volume, None)
arg1.assert_called_with(None, volume_backup, volume, None)
def test_create_cloned_volume_error_on_diff_size(self):
"""Test create_cloned_volume is error on different size."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
rc_vol = self.driver.create_volume(volume)
volume['provider_location'] = rc_vol['provider_location']
volume3 = fake_volume.fake_db_volume(**self._VOLUME3)
self.assertRaises(exception.VolumeBackendAPIException,
self.driver.create_cloned_volume,
volume3, volume)
def test_finish_volume_migration(self, volume_update, metadata_update,
src_vol_type_id, dest_vol_type_id,
src_vol_status=None):
src_volume_db = fake_volume.fake_db_volume(
**{'id': fake.VOLUME_ID, 'volume_type_id': src_vol_type_id})
if src_vol_type_id:
src_volume_db['volume_type'] = fake_volume.fake_db_volume_type(
id=src_vol_type_id)
if src_vol_status:
src_volume_db['status'] = src_vol_status
dest_volume_db = fake_volume.fake_db_volume(
**{'id': fake.VOLUME2_ID, 'volume_type_id': dest_vol_type_id})
if dest_vol_type_id:
dest_volume_db['volume_type'] = fake_volume.fake_db_volume_type(
id=dest_vol_type_id)
expected_attrs = objects.Volume._get_expected_attrs(self.context)
src_volume = objects.Volume._from_db_object(
self.context, objects.Volume(), src_volume_db,
expected_attrs=expected_attrs)
dest_volume = objects.Volume._from_db_object(
self.context, objects.Volume(), dest_volume_db,
expected_attrs=expected_attrs)
updated_dest_volume = src_volume.finish_volume_migration(
dest_volume)
self.assertEqual('deleting', updated_dest_volume.migration_status)
self.assertEqual('migration src for ' + src_volume.id,
updated_dest_volume.display_description)
self.assertEqual(src_volume.id, updated_dest_volume._name_id)
self.assertTrue(volume_update.called)
volume_update.assert_has_calls([
mock.call(self.context, src_volume.id, mock.ANY),
mock.call(self.context, dest_volume.id, mock.ANY)])
ctxt, vol_id, updates = volume_update.call_args[0]
if src_vol_status and src_vol_status == 'retyping':
self.assertIn('volume_type', updates)
else:
self.assertNotIn('volume_type', updates)
# Ensure that the destination volume type has not been overwritten
self.assertEqual(dest_vol_type_id,
getattr(updated_dest_volume, 'volume_type_id'))
# Ignore these attributes, since they were updated by
# finish_volume_migration
ignore_keys = ('id', 'provider_location', '_name_id',
'migration_status', 'display_description', 'status',
'volume_glance_metadata', 'volume_type')
dest_vol_dict = {k: updated_dest_volume[k] for k in
updated_dest_volume.keys() if k not in ignore_keys}
src_vol_dict = {k: src_volume[k] for k in src_volume.keys()
if k not in ignore_keys}
self.assertEqual(src_vol_dict, dest_vol_dict)
def test_copy_volume_data(self, arg1):
"""Test copy_volume_data."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
rc_vol = self.driver.create_volume(volume)
volume['provider_location'] = rc_vol['provider_location']
volume2 = fake_volume.fake_db_volume(**self._VOLUME2)
rc_vol2 = self.driver.create_volume(volume2)
volume2['provider_location'] = rc_vol2['provider_location']
self.driver.copy_volume_data(None, volume, volume2, None)
arg1.assert_called_with(None, volume, volume2, None)
def test_create_cloned_volume(self):
"""Test create_cloned_volume."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
rc_vol = self.driver.create_volume(volume)
volume['provider_location'] = rc_vol['provider_location']
volume2 = fake_volume.fake_db_volume(**self._VOLUME2)
rc = self.driver.create_cloned_volume(volume2, volume)
volume2['provider_location'] = rc['provider_location']
has_volume = self.driver.common.volume_exists(volume2)
self.assertTrue(has_volume)
def test_create_volume_from_snapshot_error_on_diff_size(self):
"""Test create_volume_from_snapshot is error on different size."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
self.driver.create_volume(volume)
snapshot = fake_snapshot.fake_db_snapshot(**self._TEST_SNAPSHOT)
rc_snap = self.driver.create_snapshot(snapshot)
snapshot['provider_location'] = rc_snap['provider_location']
volume3 = fake_volume.fake_db_volume(**self._VOLUME3)
self.assertRaises(exception.VolumeBackendAPIException,
self.driver.create_volume_from_snapshot,
volume3, snapshot)
def test_copy_volume_data_error(self, arg1):
"""Test copy_volume_data is error."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
rc_vol = self.driver.create_volume(volume)
volume['provider_location'] = rc_vol['provider_location']
volume2 = fake_volume.fake_db_volume(**self._VOLUME2)
volume2['provider_location'] = '2'
self.assertRaises(exception.CinderException,
self.driver.copy_volume_data,
None, volume, volume2, None)
arg1.assert_called_with(None, volume, volume2, None)
def test_create_volume_from_snapshot(self):
"""Test create_volume_from_snapshot."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
self.driver.create_volume(volume)
snapshot = fake_snapshot.fake_db_snapshot(**self._TEST_SNAPSHOT)
rc_snap = self.driver.create_snapshot(snapshot)
snapshot['provider_location'] = rc_snap['provider_location']
volume2 = fake_volume.fake_db_volume(**self._VOLUME2)
rc = self.driver.create_volume_from_snapshot(volume2, snapshot)
volume2['provider_location'] = rc['provider_location']
has_volume = self.driver.common.volume_exists(volume2)
self.assertTrue(has_volume)
def test_extend_volume_error_on_non_existing_volume(self):
"""Test extend_volume is error on non existing volume."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
volume['provider_location'] = '1'
self.assertRaises(exception.VolumeBackendAPIException,
self.driver.extend_volume, volume, 256)
def test_obj_load_attr_group_not_exist(self, mock_group_get_by_id):
fake_db_volume = fake_volume.fake_db_volume(group_id=None)
volume = objects.Volume._from_db_object(
self.context, objects.Volume(), fake_db_volume)
self.assertIsNone(volume.group)
mock_group_get_by_id.assert_not_called()
def test_manage_existing_with_none_sourceid(self):
"""Test manage_existing is error with no source-id."""
existing_ref = {'source-id': None}
volume = fake_volume.fake_db_volume(**self._VOLUME)
rc = self.driver.manage_existing(volume, existing_ref)
self.assertIsNone(rc['provider_location'])
def test_manage_existing_snapshot(self, mock_can_send_version):
volume_update = {'host': 'fake_host'}
snpshot = {
'id': fake.snapshot_id,
'volume_id': fake.volume_id,
'status': "creating",
'progress': '0%',
'volume_size': 0,
'display_name': 'fake_name',
'display_description': 'fake_description',
'volume': fake_volume.fake_db_volume(**volume_update),
'expected_attrs': ['volume'], }
my_fake_snapshot_obj = fake_snapshot.fake_snapshot_obj(self.context,
**snpshot)
self._test_volume_api('manage_existing_snapshot',
rpc_method='cast',
snapshot=my_fake_snapshot_obj,
ref='foo',
host='fake_host',
version='2.0')
mock_can_send_version.return_value = False
self._test_volume_api('manage_existing_snapshot',
rpc_method='cast',
snapshot=my_fake_snapshot_obj,
ref='foo',
host='fake_host',
version='1.28')
def test_manage_existing_get_size(self):
"""Test manage_existing_get_size."""
existing_ref = {'source-id': '101'}
volume = fake_volume.fake_db_volume(**self._VOLUME)
return_size = self.driver.manage_existing_get_size(
volume, existing_ref)
self.assertEqual(EXISTING_POOL_REF['101']['size'], return_size)
def test_destroy(self, volume_destroy):
db_volume = fake_volume.fake_db_volume()
volume = objects.Volume._from_db_object(self.context, objects.Volume(), db_volume)
volume.destroy()
self.assertTrue(volume_destroy.called)
admin_context = volume_destroy.call_args[0][0]
self.assertTrue(admin_context.is_admin)
def test_manage_existing_get_size_with_none_sourceid(self):
"""Test manage_existing_get_size is error with no source-id."""
existing_ref = {'source-id': None}
volume = fake_volume.fake_db_volume(**self._VOLUME)
self.assertRaises(exception.ManageExistingInvalidReference,
self.driver.manage_existing_get_size,
volume, existing_ref)
def test_save_with_glance_metadata(self):
db_volume = fake_volume.fake_db_volume()
volume = objects.Volume._from_db_object(self.context,
objects.Volume(), db_volume)
volume.display_name = 'foobar'
volume.glance_metadata = {'key1': 'value1'}
self.assertRaises(exception.ObjectActionError, volume.save)
def test_save_with_consistencygroup(self):
db_volume = fake_volume.fake_db_volume()
volume = objects.Volume._from_db_object(self.context,
objects.Volume(), db_volume)
volume.display_name = 'foobar'
volume.consistencygroup = objects.ConsistencyGroup()
self.assertRaises(exception.ObjectActionError, volume.save)
def test_save_with_snapshots(self):
db_volume = fake_volume.fake_db_volume()
volume = objects.Volume._from_db_object(self.context,
objects.Volume(), db_volume)
volume.display_name = 'foobar'
volume.snapshots = objects.SnapshotList()
self.assertRaises(exception.ObjectActionError, volume.save)
def test_migrate_volume_generic_for_clone(self, volume_get,
migrate_volume_completion,
nova_api, create_volume, save):
def fake_create_volume(*args, **kwargs):
context, volume, request_spec, filter_properties = args
fake_db = mock.Mock()
task = create_volume_manager.ExtractVolumeSpecTask(fake_db)
specs = task.execute(context, volume, {})
self.assertEqual('raw', specs['type'])
def fake_copy_volume_data_with_chk_param(*args, **kwargs):
context, src, dest = args
self.assertEqual(src['source_volid'], dest['source_volid'])
fake_db_new_volume = {'status': 'available', 'id': fake.VOLUME_ID}
fake_new_volume = fake_volume.fake_db_volume(**fake_db_new_volume)
host_obj = {'host': 'newhost', 'capabilities': {}}
volume_get.return_value = fake_new_volume
clone = tests_utils.create_volume(self.context, size=1,
host=CONF.host)
clone['source_volid'] = fake.VOLUME2_ID
create_volume.side_effect = fake_create_volume
with mock.patch.object(self.volume, '_copy_volume_data') as \
mock_copy_volume:
mock_copy_volume.side_effect = fake_copy_volume_data_with_chk_param
self.volume._migrate_volume_generic(self.context, clone,
host_obj, None)
def test_manage_existing(self):
"""Test manage_existing."""
existing_ref = {'source-id': '101'}
volume = fake_volume.fake_db_volume(**self._VOLUME)
rc = self.driver.manage_existing(volume, existing_ref)
self.assertEqual('101', rc['provider_location'])
def test_get_by_group(self, get_all_by_group):
db_volume = fake_volume.fake_db_volume()
get_all_by_group.return_value = [db_volume]
volumes = objects.VolumeList.get_all_by_group(self.context, "fake-host")
self.assertEqual(1, len(volumes))
TestVolume._compare(self, db_volume, volumes[0])
def test_from_db_object_with_all_expected_attributes(self):
expected_attrs = ['metadata', 'admin_metadata', 'glance_metadata',
'volume_type', 'volume_attachment',
'consistencygroup']
db_metadata = [{'key': 'foo', 'value': 'bar'}]
db_admin_metadata = [{'key': 'admin_foo', 'value': 'admin_bar'}]
db_glance_metadata = [{'key': 'glance_foo', 'value': 'glance_bar'}]
db_volume_type = fake_volume.fake_db_volume_type()
db_volume_attachments = fake_volume.fake_db_volume_attachment()
db_consistencygroup = fake_consistencygroup.fake_db_consistencygroup()
db_snapshots = fake_snapshot.fake_db_snapshot()
db_volume = fake_volume.fake_db_volume(
volume_metadata=db_metadata,
volume_admin_metadata=db_admin_metadata,
volume_glance_metadata=db_glance_metadata,
volume_type=db_volume_type,
volume_attachment=[db_volume_attachments],
consistencygroup=db_consistencygroup,
snapshots=[db_snapshots],
)
volume = objects.Volume._from_db_object(self.context, objects.Volume(),
db_volume, expected_attrs)
self.assertEqual({'foo': 'bar'}, volume.metadata)
self.assertEqual({'admin_foo': 'admin_bar'}, volume.admin_metadata)
self.assertEqual({'glance_foo': 'glance_bar'}, volume.glance_metadata)
self._compare(self, db_volume_type, volume.volume_type)
self._compare(self, db_volume_attachments, volume.volume_attachment)
self._compare(self, db_consistencygroup, volume.consistencygroup)
self._compare(self, db_snapshots, volume.snapshots)
def test_delete_volume_on_non_existing_volume(self):
"""Test delete_volume on non existing volume."""
volume = fake_volume.fake_db_volume(**self._VOLUME)
volume['provider_location'] = '1'
has_volume = self.driver.common.volume_exists(volume)
self.assertFalse(has_volume)
self.driver.delete_volume(volume)
def test_save(self, volume_update):
db_volume = fake_volume.fake_db_volume()
volume = objects.Volume._from_db_object(self.context,
objects.Volume(), db_volume)
volume.display_name = 'foobar'
volume.save()
volume_update.assert_called_once_with(self.context, volume.id,
{'display_name': 'foobar'})
def test_create_snapshot(self, volume_get):
with mock.patch.object(self.driver, "_rpc_call",
self.jsonrpcclient.call):
db_volume = fake_volume.fake_db_volume()
db_volume['name'] = "lvs_test/lvol0"
ctxt = context.get_admin_context()
db_volume = objects.Volume._from_db_object(ctxt, objects.Volume(),
db_volume)
volume_get.return_value = db_volume
snapshot = {}
snapshot['volume_id'] = db_volume['id']
snapshot['name'] = "snapshot0"
snapshot['volume'] = db_volume
for bdev in self.jsonrpcclient.bdevs:
if bdev['aliases'][-1] == "lvs_test/lvol0":
bdev['aliases'].append(db_volume.name)
self.driver.create_snapshot(snapshot)
bdev = self.driver._get_spdk_volume_name("lvs_test/snapshot0")
self.assertEqual("58b17014-d4a1-4f85-9761-093643ed18f2", bdev)
def test_initialize_connection(self):
"""Test initialize_connection."""
connector = {
'wwpns': ['12345678912345aa', '12345678912345bb'],
'ip': '127.0.0.1'
}
volume = fake_volume.fake_db_volume(**self._VOLUME)
rc_vol = self.driver.create_volume(volume)
volume['provider_location'] = rc_vol['provider_location']
conn_info = self.driver.initialize_connection(volume, connector)
self.assertIn('data', conn_info)
self.assertIn('initiator_target_map', conn_info['data'])
is_attached = self.driver.common.is_volume_attached(volume, connector)
self.assertTrue(is_attached)
self.driver.terminate_connection(volume, connector)
self.driver.delete_volume(volume)
def test_save_with_admin_metadata(self, volume_update,
admin_metadata_update):
# Test with no admin context
db_volume = fake_volume.fake_db_volume()
volume = objects.Volume._from_db_object(self.context,
objects.Volume(), db_volume)
volume.admin_metadata = {'key1': 'value1'}
volume.save()
self.assertFalse(admin_metadata_update.called)
# Test with admin context
admin_context = context.RequestContext(self.user_id, self.project_id,
is_admin=True)
volume = objects.Volume._from_db_object(admin_context,
objects.Volume(), db_volume)
volume.admin_metadata = {'key1': 'value1'}
volume.save()
admin_metadata_update.assert_called_once_with(
admin_context, volume.id, {'key1': 'value1'}, True)
def test_volume_attached(self, volume_attached):
attachment = fake_volume.volume_attachment_ovo(self.context)
updated_values = {
'mountpoint': '/dev/sda',
'attach_status': fields.VolumeAttachStatus.ATTACHED,
'instance_uuid': fake.INSTANCE_ID
}
volume_attached.return_value = (fake_volume.fake_db_volume(),
updated_values)
volume = attachment.finish_attach(fake.INSTANCE_ID, 'fake_host',
'/dev/sda', 'rw')
self.assertIsInstance(volume, objects.Volume)
volume_attached.assert_called_once_with(mock.ANY, attachment.id,
fake.INSTANCE_ID, 'fake_host',
'/dev/sda', 'rw', True)
self.assertEqual('/dev/sda', attachment.mountpoint)
self.assertEqual(fake.INSTANCE_ID, attachment.instance_uuid)
self.assertEqual(fields.VolumeAttachStatus.ATTACHED,
attachment.attach_status)
def test_create_from_image_no_internal_context(
self, mock_get_internal_context, mock_create_from_img_dl,
mock_create_from_src, mock_handle_bootable, mock_fetch_img):
self.mock_driver.clone_image.return_value = (None, False)
mock_get_internal_context.return_value = None
volume = fake_volume.fake_db_volume()
image_location = 'someImageLocationStr'
image_id = 'c7a8b8d4-e519-46c7-a0df-ddf1b9b9fff2'
image_meta = {'properties': {'virtual_size': '2147483648'}}
manager = create_volume_manager.CreateVolumeFromSpecTask(
self.mock_volume_manager,
self.mock_db,
self.mock_driver,
image_volume_cache=self.mock_cache)
manager._create_from_image(self.ctxt, volume, image_location, image_id,
image_meta, self.mock_image_service)
# Make sure clone_image is always called
self.assertTrue(self.mock_driver.clone_image.called)
# Create from source shouldn't happen if cache cannot be used.
self.assertFalse(mock_create_from_src.called)
# The image download should happen if clone fails and we can't use the
# image-volume cache due to not having an internal context available.
mock_create_from_img_dl.assert_called_once_with(
self.ctxt, volume, image_location, image_id,
self.mock_image_service)
# This should not attempt to use a minimal size volume
self.assertFalse(self.mock_db.volume_update.called)
# Make sure we didn't try and create a cache entry
self.assertFalse(self.mock_cache.ensure_space.called)
self.assertFalse(self.mock_cache.create_cache_entry.called)
mock_handle_bootable.assert_called_once_with(self.ctxt,
volume['id'],
image_id=image_id,
image_meta=image_meta)
def test_create_from_snapshot(self, snapshot_get_by_id, handle_bootable):
fake_db = mock.MagicMock()
fake_driver = mock.MagicMock()
fake_volume_manager = mock.MagicMock()
fake_manager = create_volume_manager.CreateVolumeFromSpecTask(
fake_volume_manager, fake_db, fake_driver)
volume = fake_volume.fake_db_volume()
orig_volume_db = mock.MagicMock(id=10, bootable=True)
snapshot_obj = fake_snapshot.fake_snapshot_obj(self.ctxt)
snapshot_get_by_id.return_value = snapshot_obj
fake_db.volume_get.return_value = orig_volume_db
fake_manager._create_from_snapshot(self.ctxt, volume,
snapshot_obj.id)
fake_driver.create_volume_from_snapshot.assert_called_once_with(
volume, snapshot_obj)
fake_db.volume_get.assert_called_once_with(self.ctxt,
snapshot_obj.volume_id)
handle_bootable.assert_called_once_with(self.ctxt, volume['id'],
snapshot_id=snapshot_obj.id)
def test_manage_existing_snapshot(self):
volume_update = {'host': 'fake_host'}
snpshot = {
'id': fake.SNAPSHOT_ID,
'volume_id': fake.VOLUME_ID,
'status': fields.SnapshotStatus.CREATING,
'progress': '0%',
'volume_size': 0,
'display_name': 'fake_name',
'display_description': 'fake_description',
'volume': fake_volume.fake_db_volume(**volume_update),
'expected_attrs': ['volume'], }
my_fake_snapshot_obj = fake_snapshot.fake_snapshot_obj(self.context,
**snpshot)
self._test_volume_api('manage_existing_snapshot',
rpc_method='cast',
snapshot=my_fake_snapshot_obj,
ref='foo',
host='fake_host',
version='3.0')
def test_manage_existing_snapshot(self):
volume_update = {'host': 'fake_host'}
snpshot = {
'id': 1,
'volume_id': 'fake_id',
'status': "creating",
'progress': '0%',
'volume_size': 0,
'display_name': 'fake_name',
'display_description': 'fake_description',
'volume': fake_volume.fake_db_volume(**volume_update),
'expected_attrs': ['volume'], }
my_fake_snapshot_obj = fake_snapshot.fake_snapshot_obj(self.context,
**snpshot)
self._test_volume_api('manage_existing_snapshot',
rpc_method='cast',
snapshot=my_fake_snapshot_obj,
ref='foo',
host='fake_host',
version='1.28')
def test_refresh(self, volume_get, volume_metadata_get):
db_volume1 = fake_volume.fake_db_volume()
db_volume2 = db_volume1.copy()
db_volume2['display_name'] = 'foobar'
# On the second volume_get, return the volume with an updated
# display_name
volume_get.side_effect = [db_volume1, db_volume2]
volume = objects.Volume.get_by_id(self.context, '1')
self._compare(self, db_volume1, volume)
# display_name was updated, so a volume refresh should have a new value
# for that field
volume.refresh()
self._compare(self, db_volume2, volume)
volume_get.assert_has_calls([
mock.call(self.context, '1'),
mock.call.__nonzero__(),
mock.call(self.context, '1')
])
def test_get_volume_format_spec(self, volume_versioned_object,
volume_meta_contains_fmt,
volume_type_contains_fmt):
fake_vol_meta_fmt = 'vhd'
fake_vol_type_fmt = 'vhdx'
volume_metadata = {}
volume_type_extra_specs = {}
fake_vol_dict = fake_volume.fake_db_volume()
del fake_vol_dict['name']
if volume_meta_contains_fmt:
volume_metadata['volume_format'] = fake_vol_meta_fmt
elif volume_type_contains_fmt:
volume_type_extra_specs['smbfs:volume_format'] = fake_vol_type_fmt
ctxt = context.get_admin_context()
volume_type = db.volume_type_create(
ctxt, {'extra_specs': volume_type_extra_specs,
'name': 'fake_vol_type'})
fake_vol_dict.update(metadata=volume_metadata,
volume_type_id=volume_type.id)
# We want to get a 'real' SqlA model object, not just a dict.
volume = db.volume_create(ctxt, fake_vol_dict)
volume = db.volume_get(ctxt, volume.id)
if volume_versioned_object:
volume = objects.Volume._from_db_object(ctxt, objects.Volume(),
volume)
resulted_fmt = self._smbfs_driver._get_volume_format_spec(volume)
if volume_meta_contains_fmt:
expected_fmt = fake_vol_meta_fmt
elif volume_type_contains_fmt:
expected_fmt = fake_vol_type_fmt
else:
expected_fmt = None
self.assertEqual(expected_fmt, resulted_fmt)
def test_create_backup_no_service(self, mock_volume_update,
mock_volume_get, mock_host, mock_error):
volume = fake_volume.fake_db_volume()
volume['status'] = 'backing-up'
volume['previous_status'] = 'available'
mock_volume_get.return_value = volume
mock_host.side_effect = exception.ServiceNotFound(
service_id='cinder-volume')
backup = fake_backup.fake_backup_obj(self.context)
self.manager.create_backup(self.context, backup=backup)
mock_host.assert_called_once_with(volume)
mock_volume_get.assert_called_once_with(self.context, backup.volume_id)
mock_volume_update.assert_called_once_with(
self.context, backup.volume_id, {
'status': 'available',
'previous_status': 'backing-up'
})
mock_error.assert_called_once_with(
backup, 'Service not found for creating backup.')
def test_save(self, test_cg, ovo, expected, volume_update):
use_quota = ovo.pop('use_quota', None)
db_volume = fake_volume.fake_db_volume(**ovo)
# TODO: (Y release) remove expected_attrs
if 'volume_admin_metadata' in ovo:
expected_attrs = ['admin_metadata']
else:
expected_attrs = []
volume = objects.Volume._from_db_object(self.context,
objects.Volume(), db_volume,
expected_attrs=expected_attrs)
volume.display_name = 'foobar'
if test_cg:
volume.consistencygroup = None
# TODO: (Y release) remove next 2 lines
if use_quota is not None:
volume.use_quota = use_quota
volume.save()
# TODO: (Y release) remove use_quota
volume_update.assert_called_once_with(self.context, volume.id,
{'display_name': 'foobar',
'use_quota': expected})
def test_migrate_volume_generic(self, volume_get,
migrate_volume_completion,
nova_api):
fake_db_new_volume = {'status': 'available', 'id': fake.VOLUME_ID}
fake_new_volume = fake_volume.fake_db_volume(**fake_db_new_volume)
new_volume_obj = fake_volume.fake_volume_obj(self.context,
**fake_new_volume)
host_obj = {'host': 'newhost', 'capabilities': {}}
volume_get.return_value = fake_new_volume
update_server_volume = nova_api.return_value.update_server_volume
volume = tests_utils.create_volume(self.context, size=1,
host=CONF.host)
with mock.patch.object(self.volume, '_copy_volume_data') as \
mock_copy_volume:
self.volume._migrate_volume_generic(self.context, volume,
host_obj, None)
mock_copy_volume.assert_called_with(self.context, volume,
new_volume_obj,
remote='dest')
migrate_volume_completion.assert_called_with(
self.context, volume, new_volume_obj, error=False)
self.assertFalse(update_server_volume.called)
def test_create_from_image_cache_miss_error_size_invalid(
self, mock_qemu_info, mock_get_internal_context,
mock_create_from_img_dl, mock_create_from_src,
mock_handle_bootable, mock_fetch_img):
mock_fetch_img.return_value = mock.MagicMock()
image_info = imageutils.QemuImgInfo()
image_info.virtual_size = '2147483648'
mock_qemu_info.return_value = image_info
self.mock_driver.clone_image.return_value = (None, False)
self.mock_cache.get_entry.return_value = None
volume = fake_volume.fake_volume_obj(self.ctxt,
size=1,
host='foo@bar#pool')
image_volume = fake_volume.fake_db_volume(size=2)
self.mock_db.volume_create.return_value = image_volume
image_location = 'someImageLocationStr'
image_id = 'c7a8b8d4-e519-46c7-a0df-ddf1b9b9fff2'
image_meta = mock.MagicMock()
manager = create_volume_manager.CreateVolumeFromSpecTask(
self.mock_volume_manager,
self.mock_db,
self.mock_driver,
image_volume_cache=self.mock_cache)
self.assertRaises(exception.ImageUnacceptable,
manager._create_from_image, self.ctxt, volume,
image_location, image_id, image_meta,
self.mock_image_service)
# The volume size should NOT be changed when in this case
self.assertFalse(self.mock_db.volume_update.called)
# Make sure we didn't try and create a cache entry
self.assertFalse(self.mock_cache.ensure_space.called)
self.assertFalse(self.mock_cache.create_cache_entry.called)
def test_migrate_volume_generic_attached_volume(self, volume_get,
migrate_volume_completion,
nova_api):
attached_host = 'some-host'
fake_volume_id = fake.VOLUME_ID
fake_db_new_volume = {'status': 'available', 'id': fake_volume_id}
fake_new_volume = fake_volume.fake_db_volume(**fake_db_new_volume)
host_obj = {'host': 'newhost', 'capabilities': {}}
fake_uuid = fakes.get_fake_uuid()
update_server_volume = nova_api.return_value.update_server_volume
volume_get.return_value = fake_new_volume
volume = tests_utils.create_volume(self.context, size=1,
host=CONF.host)
volume_attach = tests_utils.attach_volume(
self.context, volume['id'], fake_uuid, attached_host, '/dev/vda')
self.assertIsNotNone(volume_attach['volume_attachment'][0]['id'])
self.assertEqual(
fake_uuid, volume_attach['volume_attachment'][0]['instance_uuid'])
self.assertEqual('in-use', volume_attach['status'])
self.volume._migrate_volume_generic(self.context, volume,
host_obj, None)
self.assertFalse(migrate_volume_completion.called)
update_server_volume.assert_called_with(self.context, fake_uuid,
volume['id'], fake_volume_id)
def test_copy_volume_to_image_volume_vhd(self, mock_copy_volume_to_image,
mock_update, mock_get,
mock_create,
mock_get_volume_image_metadata):
"""Test create image from volume with vhd_disk_format"""
db_volume = fake_volume.fake_db_volume()
volume_obj = objects.Volume._from_db_object(self.context,
objects.Volume(),
db_volume)
mock_create.side_effect = self.fake_vhd_image_service_create
mock_get.return_value = volume_obj
mock_copy_volume_to_image.side_effect = (
self.fake_rpc_copy_volume_to_image)
req = fakes.HTTPRequest.blank('/v2/tenant1/volumes/%s/action' % id)
body = self._get_os_volume_upload_image()
res_dict = self.controller._volume_upload_image(req, id, body)
expected_res = {
'os-volume_upload_image': {
'id': fake.volume_id,
'updated_at': None,
'status': 'uploading',
'display_description': None,
'size': 1,
'volume_type': None,
'image_id': 1,
'container_format': u'bare',
'disk_format': u'vhd',
'image_name': u'image_name'
}
}
self.assertDictMatch(expected_res, res_dict)
def test_create(self, volume_create):
db_volume = fake_volume.fake_db_volume()
volume_create.return_value = db_volume
volume = objects.Volume(context=self.context)
volume.create()
self.assertEqual(db_volume['id'], volume.id)
def test_get_by_id(self, volume_get):
db_volume = fake_volume.fake_db_volume()
volume_get.return_value = db_volume
volume = objects.Volume.get_by_id(self.context, fake.volume_id)
volume_get.assert_called_once_with(self.context, fake.volume_id)
self._compare(self, db_volume, volume)
def test_obj_load_attr(self, mock_sl_get_all_for_volume, mock_cg_get_by_id,
mock_va_get_all_by_vol, mock_vt_get_by_id,
mock_admin_metadata_get, mock_glance_metadata_get,
mock_metadata_get):
volume = objects.Volume._from_db_object(self.context, objects.Volume(),
fake_volume.fake_db_volume())
# Test metadata lazy-loaded field
metadata = {'foo': 'bar'}
mock_metadata_get.return_value = metadata
self.assertEqual(metadata, volume.metadata)
mock_metadata_get.assert_called_once_with(self.context, volume.id)
# Test glance_metadata lazy-loaded field
glance_metadata = [{'key': 'foo', 'value': 'bar'}]
mock_glance_metadata_get.return_value = glance_metadata
self.assertEqual({'foo': 'bar'}, volume.glance_metadata)
mock_glance_metadata_get.assert_called_once_with(
self.context, volume.id)
# Test volume_type lazy-loaded field
# Case1. volume.volume_type_id = None
self.assertIsNone(volume.volume_type)
# Case2. volume2.volume_type_id = 1
fake2 = fake_volume.fake_db_volume()
fake2.update({'volume_type_id': fake.volume_id})
volume2 = objects.Volume._from_db_object(self.context,
objects.Volume(), fake2)
volume_type = objects.VolumeType(context=self.context,
id=fake.volume_type_id)
mock_vt_get_by_id.return_value = volume_type
self.assertEqual(volume_type, volume2.volume_type)
mock_vt_get_by_id.assert_called_once_with(self.context,
volume2.volume_type_id)
# Test consistencygroup lazy-loaded field
consistencygroup = objects.ConsistencyGroup(
context=self.context, id=fake.consistency_group_id)
mock_cg_get_by_id.return_value = consistencygroup
self.assertEqual(consistencygroup, volume.consistencygroup)
mock_cg_get_by_id.assert_called_once_with(self.context,
volume.consistencygroup_id)
# Test snapshots lazy-loaded field
snapshots = objects.SnapshotList(context=self.context,
id=fake.snapshot_id)
mock_sl_get_all_for_volume.return_value = snapshots
self.assertEqual(snapshots, volume.snapshots)
mock_sl_get_all_for_volume.assert_called_once_with(
self.context, volume.id)
# Test volume_attachment lazy-loaded field
va_objs = [
objects.VolumeAttachment(context=self.context, id=i)
for i in [fake.object_id, fake.object2_id, fake.object3_id]
]
va_list = objects.VolumeAttachmentList(context=self.context,
objects=va_objs)
mock_va_get_all_by_vol.return_value = va_list
self.assertEqual(va_list, volume.volume_attachment)
mock_va_get_all_by_vol.assert_called_once_with(self.context, volume.id)
# Test admin_metadata lazy-loaded field - user context
adm_metadata = {'bar': 'foo'}
mock_admin_metadata_get.return_value = adm_metadata
self.assertEqual({}, volume.admin_metadata)
self.assertFalse(mock_admin_metadata_get.called)
# Test admin_metadata lazy-loaded field - admin context
adm_context = self.context.elevated()
volume = objects.Volume._from_db_object(adm_context, objects.Volume(),
fake_volume.fake_db_volume())
adm_metadata = {'bar': 'foo'}
mock_admin_metadata_get.return_value = adm_metadata
self.assertEqual(adm_metadata, volume.admin_metadata)
mock_admin_metadata_get.assert_called_once_with(adm_context, volume.id)
def test_get_by_id(self, volume_get, volume_glance_metadata_get):
db_volume = fake_volume.fake_db_volume()
volume_get.return_value = db_volume
volume = objects.Volume.get_by_id(self.context, 1)
self._compare(self, db_volume, volume)
def test_destroy(self, volume_destroy):
db_volume = fake_volume.fake_db_volume()
volume = objects.Volume._from_db_object(self.context, objects.Volume(),
db_volume)
volume.destroy()
volume_destroy.assert_called_once_with(self.context, '1')
def _stub_volume(*args, **kwargs):
updates = {'provider_location': 'hyperscale-sv:/hyperscale'}
return fake_volume.fake_db_volume(**updates)
def test_create_from_image_cache_miss_error_downloading(
self, mock_qemu_info, mock_get_internal_context,
mock_create_from_img_dl, mock_create_from_src,
mock_handle_bootable, mock_fetch_img):
mock_fetch_img.return_value = mock.MagicMock()
image_info = imageutils.QemuImgInfo()
image_info.virtual_size = '2147483648'
mock_qemu_info.return_value = image_info
self.mock_driver.clone_image.return_value = (None, False)
self.mock_cache.get_entry.return_value = None
volume = fake_volume.fake_volume_obj(self.ctxt, size=10,
host='foo@bar#pool')
image_volume = fake_volume.fake_db_volume(size=2)
self.mock_db.volume_create.return_value = image_volume
mock_create_from_img_dl.side_effect = exception.CinderException()
def update_volume(ctxt, id, updates):
volume.update(updates)
return volume
self.mock_db.volume_update.side_effect = update_volume
image_location = 'someImageLocationStr'
image_id = 'c7a8b8d4-e519-46c7-a0df-ddf1b9b9fff2'
image_meta = mock.MagicMock()
manager = create_volume_manager.CreateVolumeFromSpecTask(
self.mock_volume_manager,
self.mock_db,
self.mock_driver,
image_volume_cache=self.mock_cache
)
self.assertRaises(
exception.CinderException,
manager._create_from_image,
self.ctxt,
volume,
image_location,
image_id,
image_meta,
self.mock_image_service
)
# Make sure clone_image is always called
self.assertTrue(self.mock_driver.clone_image.called)
# The image download should happen if clone fails and
# we get a cache miss
mock_create_from_img_dl.assert_called_once_with(
self.ctxt,
mock.ANY,
image_location,
image_id,
self.mock_image_service
)
# The volume size should be reduced to virtual_size and then put back,
# especially if there is an exception while creating the volume.
self.assertEqual(2, self.mock_db.volume_update.call_count)
self.mock_db.volume_update.assert_any_call(self.ctxt,
volume['id'],
{'size': 2})
self.mock_db.volume_update.assert_any_call(self.ctxt,
volume['id'],
{'size': 10})
# Make sure we didn't try and create a cache entry
self.assertFalse(self.mock_cache.ensure_space.called)
self.assertFalse(self.mock_cache.create_cache_entry.called)
'status': fields.BackupStatus.CREATING,
'size': 1,
'display_name': 'fake_name',
'display_description': 'fake_description',
'user_id': fake.USER_ID,
'project_id': fake.PROJECT_ID,
'temp_volume_id': None,
'temp_snapshot_id': None,
'snapshot_id': None,
'data_timestamp': None,
'restore_volume_id': None,
'backup_metadata': {},
}
vol_props = {'status': 'available', 'size': 1}
fake_vol = fake_volume.fake_db_volume(**vol_props)
snap_props = {
'status': fields.BackupStatus.AVAILABLE,
'volume_id': fake_vol['id'],
'expected_attrs': ['metadata']
}
fake_snap = fake_snapshot.fake_db_snapshot(**snap_props)
class TestBackup(test_objects.BaseObjectsTestCase):
@mock.patch('cinder.db.get_by_id', return_value=fake_backup)
def test_get_by_id(self, backup_get):
backup = objects.Backup.get_by_id(self.context, fake.USER_ID)
self._compare(self, fake_backup, backup)
backup_get.assert_called_once_with(self.context, models.Backup,
fake.USER_ID)
def test_finish_volume_migration(self,
volume_update,
metadata_update,
src_vol_type_id,
dest_vol_type_id,
src_vol_status=None):
src_volume_db = fake_volume.fake_db_volume(
**{
'id': fake.VOLUME_ID,
'volume_type_id': src_vol_type_id
})
if src_vol_type_id:
src_volume_db['volume_type'] = fake_volume.fake_db_volume_type(
id=src_vol_type_id)
if src_vol_status:
src_volume_db['status'] = src_vol_status
dest_volume_db = fake_volume.fake_db_volume(
**{
'id': fake.VOLUME2_ID,
'volume_type_id': dest_vol_type_id
})
if dest_vol_type_id:
dest_volume_db['volume_type'] = fake_volume.fake_db_volume_type(
id=dest_vol_type_id)
expected_attrs = objects.Volume._get_expected_attrs(self.context)
src_volume = objects.Volume._from_db_object(
self.context,
objects.Volume(),
src_volume_db,
expected_attrs=expected_attrs)
dest_volume = objects.Volume._from_db_object(
self.context,
objects.Volume(),
dest_volume_db,
expected_attrs=expected_attrs)
updated_dest_volume = src_volume.finish_volume_migration(dest_volume)
self.assertEqual('deleting', updated_dest_volume.migration_status)
self.assertEqual('migration src for ' + src_volume.id,
updated_dest_volume.display_description)
self.assertEqual(src_volume.id, updated_dest_volume._name_id)
self.assertTrue(volume_update.called)
volume_update.assert_has_calls([
mock.call(self.context, src_volume.id, mock.ANY),
mock.call(self.context, dest_volume.id, mock.ANY)
])
ctxt, vol_id, updates = volume_update.call_args[0]
if src_vol_status and src_vol_status == 'retyping':
self.assertIn('volume_type', updates)
else:
self.assertNotIn('volume_type', updates)
# Ensure that the destination volume type has not been overwritten
self.assertEqual(dest_vol_type_id,
getattr(updated_dest_volume, 'volume_type_id'))
# Ignore these attributes, since they were updated by
# finish_volume_migration
ignore_keys = ('id', 'provider_location', '_name_id',
'migration_status', 'display_description', 'status',
'volume_glance_metadata', 'volume_type')
dest_vol_dict = {
k: updated_dest_volume[k]
for k in updated_dest_volume.keys() if k not in ignore_keys
}
src_vol_dict = {
k: src_volume[k]
for k in src_volume.keys() if k not in ignore_keys
}
self.assertEqual(src_vol_dict, dest_vol_dict)