def _test_driver_default_size(self, name):
size = "swap_size" if name == "swap" else "size"
no_size_bdm = getattr(self, "%s_bdm_dict" % name).copy()
no_size_bdm["volume_size"] = None
driver_bdm = self.driver_classes[name](fake_block_device.fake_bdm_object(self.context, no_size_bdm))
self.assertEqual(driver_bdm[size], 0)
del no_size_bdm["volume_size"]
driver_bdm = self.driver_classes[name](fake_block_device.fake_bdm_object(self.context, no_size_bdm))
self.assertEqual(driver_bdm[size], 0)
def _test_driver_default_size(self, name):
size = 'swap_size' if name == 'swap' else 'size'
no_size_bdm = getattr(self, "%s_bdm_dict" % name).copy()
no_size_bdm['volume_size'] = None
driver_bdm = self.driver_classes[name](
fake_block_device.fake_bdm_object(self.context, no_size_bdm))
self.assertEqual(driver_bdm[size], 0)
del no_size_bdm['volume_size']
driver_bdm = self.driver_classes[name](
fake_block_device.fake_bdm_object(self.context, no_size_bdm))
self.assertEqual(driver_bdm[size], 0)
def test_image_attach_no_volume(self):
no_volume_image = self.image_bdm_dict.copy()
no_volume_image['volume_id'] = None
test_bdm = self.driver_classes['image'](
fake_block_device.fake_bdm_object(self.context, no_volume_image))
image = {'id': 'fake-image-id-1'}
volume = {'id': 'fake-volume-id-2', 'attach_status': 'detached'}
wait_func = self.mox.CreateMockAnything()
self.volume_api.create(self.context,
1,
'',
'',
image_id=image['id'],
availability_zone=None).AndReturn(volume)
wait_func(self.context, 'fake-volume-id-2').AndReturn(None)
instance, expected_conn_info = self._test_volume_attach(
test_bdm, no_volume_image, volume)
self.mox.ReplayAll()
test_bdm.attach(self.context, instance, self.volume_api,
self.virt_driver, wait_func)
self.assertEqual(test_bdm.volume_id, 'fake-volume-id-2')
def test_blank_attach_fail_volume(self):
no_blank_volume = self.blank_bdm_dict.copy()
no_blank_volume["volume_id"] = None
test_bdm = self.driver_classes["blank"](fake_block_device.fake_bdm_object(self.context, no_blank_volume))
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx, **{"uuid": "fake-uuid"})
volume = {"id": "fake-volume-id-2", "display_name": "fake-uuid-blank-vol"}
with test.nested(
mock.patch.object(self.volume_api, "create", return_value=volume),
mock.patch.object(self.volume_api, "delete"),
) as (vol_create, vol_delete):
wait_func = mock.MagicMock()
mock_exception = exception.VolumeNotCreated(
volume_id=volume["id"], seconds=1, attempts=1, volume_status="error"
)
wait_func.side_effect = mock_exception
self.assertRaises(
exception.VolumeNotCreated,
test_bdm.attach,
context=self.context,
instance=instance,
volume_api=self.volume_api,
virt_driver=self.virt_driver,
wait_func=wait_func,
)
vol_create.assert_called_once_with(
self.context, test_bdm.volume_size, "fake-uuid-blank-vol", "", availability_zone=None
)
vol_delete.assert_called_once_with(self.context, volume["id"])
def test_image_attach_no_volume_cinder_cross_az_attach_false(self):
# Tests that the volume created from the image has the same AZ as the
# instance.
self.flags(cross_az_attach=False, group='cinder')
no_volume_image = self.image_bdm_dict.copy()
no_volume_image['volume_id'] = None
test_bdm = self.driver_classes['image'](
fake_block_device.fake_bdm_object(self.context, no_volume_image))
image = {'id': 'fake-image-id-1'}
volume = {'id': 'fake-volume-id-2', 'attach_status': 'detached'}
wait_func = self.mox.CreateMockAnything()
self.volume_api.create(self.context,
1,
'',
'',
image_id=image['id'],
availability_zone='test-az').AndReturn(volume)
wait_func(self.context, 'fake-volume-id-2').AndReturn(None)
instance, expected_conn_info = self._test_volume_attach(
test_bdm, no_volume_image, volume, availability_zone='test-az')
self.mox.ReplayAll()
test_bdm.attach(self.context, instance, self.volume_api,
self.virt_driver, wait_func)
self.assertEqual('fake-volume-id-2', test_bdm.volume_id)
def test_snapshot_attach_fail_volume(self):
fail_volume_snapshot = self.snapshot_bdm_dict.copy()
fail_volume_snapshot["volume_id"] = None
test_bdm = self.driver_classes["snapshot"](
fake_block_device.fake_bdm_object(self.context, fail_volume_snapshot)
)
snapshot = {"id": "fake-volume-id-1", "attach_status": "detached"}
volume = {"id": "fake-volume-id-2", "attach_status": "detached"}
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx, **{"uuid": "fake-uuid"})
with test.nested(
mock.patch.object(self.volume_api, "get_snapshot", return_value=snapshot),
mock.patch.object(self.volume_api, "create", return_value=volume),
mock.patch.object(self.volume_api, "delete"),
) as (vol_get_snap, vol_create, vol_delete):
wait_func = mock.MagicMock()
mock_exception = exception.VolumeNotCreated(
volume_id=volume["id"], seconds=1, attempts=1, volume_status="error"
)
wait_func.side_effect = mock_exception
self.assertRaises(
exception.VolumeNotCreated,
test_bdm.attach,
context=self.context,
instance=instance,
volume_api=self.volume_api,
virt_driver=self.virt_driver,
wait_func=wait_func,
)
vol_get_snap.assert_called_once_with(self.context, "fake-snapshot-id-1")
vol_create.assert_called_once_with(self.context, 3, "", "", snapshot, availability_zone=None)
vol_delete.assert_called_once_with(self.context, volume["id"])
def test_blank_attach_volume(self):
no_blank_volume = self.blank_bdm_dict.copy()
no_blank_volume['volume_id'] = None
test_bdm = self.driver_classes['blank'](
fake_block_device.fake_bdm_object(self.context, no_blank_volume))
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx,
**{'uuid': 'fake-uuid'})
volume_class = self.driver_classes['volume']
volume = {
'id': 'fake-volume-id-2',
'display_name': 'fake-uuid-blank-vol'
}
with test.nested(
mock.patch.object(self.volume_api,
'create',
return_value=volume),
mock.patch.object(volume_class,
'attach')) as (vol_create, vol_attach):
test_bdm.attach(self.context, instance, self.volume_api,
self.virt_driver)
vol_create.assert_called_once_with(self.context,
test_bdm.volume_size,
'fake-uuid-blank-vol',
'',
availability_zone=None)
vol_attach.assert_called_once_with(self.context,
instance,
self.volume_api,
self.virt_driver,
do_check_attach=True)
self.assertEqual('fake-volume-id-2', test_bdm.volume_id)
def test_driver_image_block_device_destination_local(self):
self._test_driver_device('image')
bdm = self.image_bdm_dict.copy()
bdm['destination_type'] = 'local'
self.assertRaises(driver_block_device._InvalidType,
self.driver_classes['image'],
fake_block_device.fake_bdm_object(self.context, bdm))
def test_image_attach_fail_volume(self):
fail_volume_image = self.image_bdm_dict.copy()
fail_volume_image['volume_id'] = None
test_bdm = self.driver_classes['image'](
fake_block_device.fake_bdm_object(
self.context, fail_volume_image))
image = {'id': 'fake-image-id-1'}
volume = {'id': 'fake-volume-id-2',
'attach_status': 'detached'}
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx,
**{'uuid': 'fake-uuid'})
with test.nested(
mock.patch.object(self.volume_api, 'create', return_value=volume),
mock.patch.object(self.volume_api, 'delete'),
) as (vol_create, vol_delete):
wait_func = mock.MagicMock()
mock_exception = exception.VolumeNotCreated(volume_id=volume['id'],
seconds=1,
attempts=1,
volume_status='error')
wait_func.side_effect = mock_exception
self.assertRaises(exception.VolumeNotCreated,
test_bdm.attach, context=self.context,
instance=instance,
volume_api=self.volume_api,
virt_driver=self.virt_driver,
wait_func=wait_func)
vol_create.assert_called_once_with(
self.context, 1, '', '', image_id=image['id'],
availability_zone=None)
vol_delete.assert_called_once_with(self.context, volume['id'])
def test_blank_attach_fail_volume(self):
no_blank_volume = self.blank_bdm_dict.copy()
no_blank_volume['volume_id'] = None
test_bdm = self.driver_classes['blank'](
fake_block_device.fake_bdm_object(
self.context, no_blank_volume))
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx,
**{'uuid': uuids.uuid})
volume = {'id': 'fake-volume-id-2',
'display_name': '%s-blank-vol' % uuids.uuid}
with test.nested(
mock.patch.object(self.volume_api, 'create', return_value=volume),
mock.patch.object(self.volume_api, 'delete'),
) as (vol_create, vol_delete):
wait_func = mock.MagicMock()
mock_exception = exception.VolumeNotCreated(volume_id=volume['id'],
seconds=1,
attempts=1,
volume_status='error')
wait_func.side_effect = mock_exception
self.assertRaises(exception.VolumeNotCreated,
test_bdm.attach, context=self.context,
instance=instance,
volume_api=self.volume_api,
virt_driver=self.virt_driver,
wait_func=wait_func)
vol_create.assert_called_once_with(
self.context, test_bdm.volume_size,
'%s-blank-vol' % uuids.uuid,
'', availability_zone=None)
vol_delete.assert_called_once_with(
self.context, volume['id'])
def test_blank_attach_fail_volume(self):
no_blank_volume = self.blank_bdm_dict.copy()
no_blank_volume['volume_id'] = None
test_bdm = self.driver_classes['blank'](
fake_block_device.fake_bdm_object(
self.context, no_blank_volume))
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx,
**{'uuid': uuids.uuid})
volume = {'id': 'fake-volume-id-2',
'display_name': '%s-blank-vol' % uuids.uuid}
with test.nested(
mock.patch.object(self.volume_api, 'create', return_value=volume),
mock.patch.object(self.volume_api, 'delete'),
) as (vol_create, vol_delete):
wait_func = mock.MagicMock()
mock_exception = exception.VolumeNotCreated(volume_id=volume['id'],
seconds=1,
attempts=1,
volume_status='error')
wait_func.side_effect = mock_exception
self.assertRaises(exception.VolumeNotCreated,
test_bdm.attach, context=self.context,
instance=instance,
volume_api=self.volume_api,
virt_driver=self.virt_driver,
wait_func=wait_func)
vol_create.assert_called_once_with(
self.context, test_bdm.volume_size,
'%s-blank-vol' % uuids.uuid,
'', availability_zone=None)
vol_delete.assert_called_once_with(
self.context, volume['id'])
def test_blank_attach_volume(self):
no_blank_volume = self.blank_bdm_dict.copy()
no_blank_volume['volume_id'] = None
test_bdm = self.driver_classes['blank'](
fake_block_device.fake_bdm_object(
self.context, no_blank_volume))
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx,
**{'uuid': uuids.uuid})
volume_class = self.driver_classes['volume']
volume = {'id': 'fake-volume-id-2',
'display_name': '%s-blank-vol' % uuids.uuid}
with test.nested(
mock.patch.object(self.volume_api, 'create', return_value=volume),
mock.patch.object(volume_class, 'attach')
) as (vol_create, vol_attach):
test_bdm.attach(self.context, instance, self.volume_api,
self.virt_driver)
vol_create.assert_called_once_with(
self.context, test_bdm.volume_size,
'%s-blank-vol' % uuids.uuid,
'', availability_zone=None)
vol_attach.assert_called_once_with(self.context, instance,
self.volume_api,
self.virt_driver,
do_check_attach=True)
self.assertEqual('fake-volume-id-2', test_bdm.volume_id)
def test_blank_attach_volume_cinder_cross_az_attach_false(self):
# Tests that the blank volume created is in the same availability zone
# as the instance.
self.flags(cross_az_attach=False, group='cinder')
no_blank_volume = self.blank_bdm_dict.copy()
no_blank_volume['volume_id'] = None
test_bdm = self.driver_classes['blank'](
fake_block_device.fake_bdm_object(
self.context, no_blank_volume))
updates = {'uuid': uuids.uuid, 'availability_zone': 'test-az'}
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx,
**updates)
volume_class = self.driver_classes['volume']
volume = {'id': 'fake-volume-id-2',
'display_name': '%s-blank-vol' % uuids.uuid}
with mock.patch.object(self.volume_api, 'create',
return_value=volume) as vol_create:
with mock.patch.object(volume_class, 'attach') as vol_attach:
test_bdm.attach(self.context, instance, self.volume_api,
self.virt_driver)
vol_create.assert_called_once_with(
self.context, test_bdm.volume_size,
'%s-blank-vol' % uuids.uuid,
'', availability_zone='test-az')
vol_attach.assert_called_once_with(self.context, instance,
self.volume_api,
self.virt_driver,
do_check_attach=True)
self.assertEqual('fake-volume-id-2', test_bdm.volume_id)
def test_image_attach_no_volume_cinder_cross_az_attach_false(self):
# Tests that the volume created from the image has the same AZ as the
# instance.
self.flags(cross_az_attach=False, group='cinder')
no_volume_image = self.image_bdm_dict.copy()
no_volume_image['volume_id'] = None
test_bdm = self.driver_classes['image'](
fake_block_device.fake_bdm_object(
self.context, no_volume_image))
image = {'id': 'fake-image-id-1'}
volume = {'id': 'fake-volume-id-2',
'attach_status': 'detached'}
wait_func = self.mox.CreateMockAnything()
self.volume_api.create(self.context, 1, '', '', image_id=image['id'],
availability_zone='test-az').AndReturn(volume)
wait_func(self.context, 'fake-volume-id-2').AndReturn(None)
instance, expected_conn_info = self._test_volume_attach(
test_bdm, no_volume_image, volume,
availability_zone='test-az')
self.mox.ReplayAll()
test_bdm.attach(self.context, instance, self.volume_api,
self.virt_driver, wait_func)
self.assertEqual('fake-volume-id-2', test_bdm.volume_id)
def test_blank_attach_volume_cinder_cross_az_attach_false(self):
# Tests that the blank volume created is in the same availability zone
# as the instance.
self.flags(cross_az_attach=False, group='cinder')
no_blank_volume = self.blank_bdm_dict.copy()
no_blank_volume['volume_id'] = None
test_bdm = self.driver_classes['blank'](
fake_block_device.fake_bdm_object(self.context, no_blank_volume))
updates = {'uuid': 'fake-uuid', 'availability_zone': 'test-az'}
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx,
**updates)
volume_class = self.driver_classes['volume']
volume = {
'id': 'fake-volume-id-2',
'display_name': 'fake-uuid-blank-vol'
}
with mock.patch.object(self.volume_api, 'create',
return_value=volume) as vol_create:
with mock.patch.object(volume_class, 'attach') as vol_attach:
test_bdm.attach(self.context, instance, self.volume_api,
self.virt_driver)
vol_create.assert_called_once_with(self.context,
test_bdm.volume_size,
'fake-uuid-blank-vol',
'',
availability_zone='test-az')
vol_attach.assert_called_once_with(self.context,
instance,
self.volume_api,
self.virt_driver,
do_check_attach=True)
self.assertEqual('fake-volume-id-2', test_bdm.volume_id)
def test_snapshot_attach_no_volume(self):
no_volume_snapshot = self.snapshot_bdm_dict.copy()
no_volume_snapshot['volume_id'] = None
test_bdm = self.driver_classes['snapshot'](
fake_block_device.fake_bdm_object(
self.context, no_volume_snapshot))
snapshot = {'id': 'fake-volume-id-1',
'attach_status': 'detached'}
volume = {'id': 'fake-volume-id-2',
'attach_status': 'detached'}
wait_func = self.mox.CreateMockAnything()
self.volume_api.get_snapshot(self.context,
'fake-snapshot-id-1').AndReturn(snapshot)
self.volume_api.create(self.context, 3, '', '', snapshot,
availability_zone=None).AndReturn(volume)
wait_func(self.context, 'fake-volume-id-2').AndReturn(None)
instance, expected_conn_info = self._test_volume_attach(
test_bdm, no_volume_snapshot, volume)
self.mox.ReplayAll()
test_bdm.attach(self.context, instance, self.volume_api,
self.virt_driver, wait_func)
self.assertEqual(test_bdm.volume_id, 'fake-volume-id-2')
def test_driver_image_block_device_destination_local(self):
self._test_driver_device('image')
bdm = self.image_bdm_dict.copy()
bdm['destination_type'] = 'local'
self.assertRaises(driver_block_device._InvalidType,
self.driver_classes['image'],
fake_block_device.fake_bdm_object(self.context, bdm))
def test_is_implemented(self):
for bdm in (self.image_bdm, self.volume_bdm, self.swap_bdm,
self.ephemeral_bdm, self.snapshot_bdm):
self.assertTrue(driver_block_device.is_implemented(bdm))
local_image = self.image_bdm_dict.copy()
local_image['destination_type'] = 'local'
self.assertFalse(driver_block_device.is_implemented(
fake_block_device.fake_bdm_object(self.context, local_image)))
def test_is_implemented(self):
for bdm in (self.image_bdm, self.volume_bdm, self.swap_bdm,
self.ephemeral_bdm, self.snapshot_bdm):
self.assertTrue(driver_block_device.is_implemented(bdm))
local_image = self.image_bdm_dict.copy()
local_image['destination_type'] = 'local'
self.assertFalse(driver_block_device.is_implemented(
fake_block_device.fake_bdm_object(self.context, local_image)))
def test_driver_image_block_device_destination_local(self):
self._test_driver_device("image")
bdm = self.image_bdm_dict.copy()
bdm["destination_type"] = "local"
self.assertRaises(
driver_block_device._InvalidType,
self.driver_classes["image"],
fake_block_device.fake_bdm_object(self.context, bdm),
)
def fake_db_req(**updates):
ctxt = context.RequestContext('fake-user', 'fake-project')
instance_uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_instance_obj(ctxt,
objects.Instance,
uuid=instance_uuid)
# This will always be set this way for an instance at build time
instance.host = None
block_devices = objects.BlockDeviceMappingList(objects=[
fake_block_device.fake_bdm_object(
context,
fake_block_device.FakeDbBlockDeviceDict(
source_type='blank',
destination_type='local',
guest_format='foo',
device_type='disk',
disk_bus='',
boot_index=1,
device_name='xvda',
delete_on_termination=False,
snapshot_id=None,
volume_id=None,
volume_size=0,
image_id='bar',
no_device=False,
connection_info=None,
tag='',
instance_uuid=uuids.instance))
])
tags = objects.TagList(
objects=[objects.Tag(tag='tag1', resource_id=instance_uuid)])
db_build_request = {
'id': 1,
'project_id': 'fake-project',
'instance_uuid': instance_uuid,
'instance': jsonutils.dumps(instance.obj_to_primitive()),
'block_device_mappings':
jsonutils.dumps(block_devices.obj_to_primitive()),
'tags': jsonutils.dumps(tags.obj_to_primitive()),
'created_at': datetime.datetime(2016, 1, 16),
'updated_at': datetime.datetime(2016, 1, 16),
}
for name, field in objects.BuildRequest.fields.items():
if name in db_build_request:
continue
if field.nullable:
db_build_request[name] = None
elif field.default != fields.UnspecifiedDefault:
db_build_request[name] = field.default
else:
raise Exception('fake_db_req needs help with %s' % name)
if updates:
db_build_request.update(updates)
return db_build_request
def test_image_attach_no_volume(self):
no_volume_image = self.image_bdm_dict.copy()
no_volume_image["volume_id"] = None
test_bdm = self.driver_classes["image"](fake_block_device.fake_bdm_object(self.context, no_volume_image))
image = {"id": "fake-image-id-1"}
volume = {"id": "fake-volume-id-2", "attach_status": "detached"}
wait_func = self.mox.CreateMockAnything()
self.volume_api.create(self.context, 1, "", "", image_id=image["id"], availability_zone=None).AndReturn(volume)
wait_func(self.context, "fake-volume-id-2").AndReturn(None)
instance, expected_conn_info = self._test_volume_attach(test_bdm, no_volume_image, volume)
self.mox.ReplayAll()
test_bdm.attach(self.context, instance, self.volume_api, self.virt_driver, wait_func)
self.assertEqual(test_bdm.volume_id, "fake-volume-id-2")
def setUp(self):
super(TestDriverBlockDevice, self).setUp()
self.volume_api = self.mox.CreateMock(cinder.API)
self.virt_driver = self.mox.CreateMock(driver.ComputeDriver)
self.context = context.RequestContext("fake_user", "fake_project")
# create bdm objects for testing
self.swap_bdm = fake_block_device.fake_bdm_object(self.context, self.swap_bdm_dict)
self.ephemeral_bdm = fake_block_device.fake_bdm_object(self.context, self.ephemeral_bdm_dict)
self.volume_bdm = fake_block_device.fake_bdm_object(self.context, self.volume_bdm_dict)
self.snapshot_bdm = fake_block_device.fake_bdm_object(self.context, self.snapshot_bdm_dict)
self.image_bdm = fake_block_device.fake_bdm_object(self.context, self.image_bdm_dict)
self.blank_bdm = fake_block_device.fake_bdm_object(self.context, self.blank_bdm_dict)
def fake_db_req(**updates):
ctxt = context.RequestContext('fake-user', 'fake-project')
instance_uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_instance_obj(ctxt, objects.Instance,
uuid=instance_uuid)
# This will always be set this way for an instance at build time
instance.host = None
block_devices = objects.BlockDeviceMappingList(
objects=[fake_block_device.fake_bdm_object(
context,
fake_block_device.FakeDbBlockDeviceDict(
source_type='blank', destination_type='local',
guest_format='foo', device_type='disk', disk_bus='',
boot_index=1, device_name='xvda', delete_on_termination=False,
snapshot_id=None, volume_id=None, volume_size=0,
image_id='bar', no_device=False, connection_info=None,
tag='', instance_uuid=uuids.instance))])
tags = objects.TagList(objects=[objects.Tag(tag='tag1',
resource_id=instance_uuid)])
db_build_request = {
'id': 1,
'project_id': 'fake-project',
'instance_uuid': instance_uuid,
'instance': jsonutils.dumps(instance.obj_to_primitive()),
'block_device_mappings': jsonutils.dumps(
block_devices.obj_to_primitive()),
'tags': jsonutils.dumps(tags.obj_to_primitive()),
'created_at': datetime.datetime(2016, 1, 16),
'updated_at': datetime.datetime(2016, 1, 16),
}
for name, field in objects.BuildRequest.fields.items():
if name in db_build_request:
continue
if field.nullable:
db_build_request[name] = None
elif field.default != fields.UnspecifiedDefault:
db_build_request[name] = field.default
else:
raise Exception('fake_db_req needs help with %s' % name)
if updates:
db_build_request.update(updates)
return db_build_request
def test_snapshot_attach_fail_volume(self):
fail_volume_snapshot = self.snapshot_bdm_dict.copy()
fail_volume_snapshot['volume_id'] = None
test_bdm = self.driver_classes['snapshot'](
fake_block_device.fake_bdm_object(self.context,
fail_volume_snapshot))
snapshot = {'id': 'fake-volume-id-1', 'attach_status': 'detached'}
volume = {'id': 'fake-volume-id-2', 'attach_status': 'detached'}
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx,
**{'uuid': 'fake-uuid'})
with test.nested(
mock.patch.object(self.volume_api,
'get_snapshot',
return_value=snapshot),
mock.patch.object(self.volume_api,
'create',
return_value=volume),
mock.patch.object(self.volume_api, 'delete'),
) as (vol_get_snap, vol_create, vol_delete):
wait_func = mock.MagicMock()
mock_exception = exception.VolumeNotCreated(volume_id=volume['id'],
seconds=1,
attempts=1,
volume_status='error')
wait_func.side_effect = mock_exception
self.assertRaises(exception.VolumeNotCreated,
test_bdm.attach,
context=self.context,
instance=instance,
volume_api=self.volume_api,
virt_driver=self.virt_driver,
wait_func=wait_func)
vol_get_snap.assert_called_once_with(self.context,
'fake-snapshot-id-1')
vol_create.assert_called_once_with(self.context,
3,
'',
'',
snapshot,
availability_zone=None)
vol_delete.assert_called_once_with(self.context, volume['id'])
def test_blank_attach_volume(self):
no_blank_volume = self.blank_bdm_dict.copy()
no_blank_volume["volume_id"] = None
test_bdm = self.driver_classes["blank"](fake_block_device.fake_bdm_object(self.context, no_blank_volume))
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx, **{"uuid": "fake-uuid"})
volume_class = self.driver_classes["volume"]
volume = {"id": "fake-volume-id-2", "display_name": "fake-uuid-blank-vol"}
with test.nested(
mock.patch.object(self.volume_api, "create", return_value=volume), mock.patch.object(volume_class, "attach")
) as (vol_create, vol_attach):
test_bdm.attach(self.context, instance, self.volume_api, self.virt_driver)
vol_create.assert_called_once_with(
self.context, test_bdm.volume_size, "fake-uuid-blank-vol", "", availability_zone=None
)
vol_attach.assert_called_once_with(
self.context, instance, self.volume_api, self.virt_driver, do_check_attach=True
)
self.assertEqual("fake-volume-id-2", test_bdm.volume_id)
def test_detail_with_cell_failures(self, mock_sg,
mock_get_by_instance_uuids):
mock_get_by_instance_uuids.return_value = [
objects.InstanceMapping(instance_uuid=UUID1,
cell_mapping=objects.CellMapping(
uuid=uuids.cell1,
transport_url='fake://nowhere/',
database_connection=uuids.cell1)),
objects.InstanceMapping(instance_uuid=UUID2,
cell_mapping=objects.CellMapping(
uuid=uuids.cell2,
transport_url='fake://nowhere/',
database_connection=uuids.cell2))
]
bdm = fake_bdms_get_all_by_instance_uuids()
fake_bdm = fake_block_device.fake_bdm_object(
nova_context.RequestContext, bdm[0])
mock_sg.return_value = {
uuids.cell1: {
UUID1: [fake_bdm]
},
uuids.cell2: nova_context.raised_exception_sentinel
}
res = self._make_request('/detail')
mock_get_by_instance_uuids.assert_called_once_with(
test.MatchType(nova_context.RequestContext), [UUID1, UUID2])
self.assertEqual(200, res.status_int)
# we would get an empty list for the second instance
# which is in the down cell, however this would printed
# in the logs.
for i, server in enumerate(self._get_servers(res.body)):
actual = server.get('%svolumes_attached' % self.prefix)
if i == 0:
self.assertEqual(self.exp_volumes_detail[i], actual)
else:
self.assertEqual([], actual)
def test_detail_with_cell_failures(self, mock_sg,
mock_get_by_instance_uuids):
mock_get_by_instance_uuids.return_value = [
objects.InstanceMapping(
instance_uuid=UUID1,
cell_mapping=objects.CellMapping(
uuid=uuids.cell1,
transport_url='fake://nowhere/',
database_connection=uuids.cell1)),
objects.InstanceMapping(
instance_uuid=UUID2,
cell_mapping=objects.CellMapping(
uuid=uuids.cell2,
transport_url='fake://nowhere/',
database_connection=uuids.cell2))
]
bdm = fake_bdms_get_all_by_instance_uuids()
fake_bdm = fake_block_device.fake_bdm_object(
nova_context.RequestContext, bdm[0])
mock_sg.return_value = {
uuids.cell1: {UUID1: [fake_bdm]},
uuids.cell2: nova_context.raised_exception_sentinel
}
res = self._make_request('/detail')
mock_get_by_instance_uuids.assert_called_once_with(
test.MatchType(nova_context.RequestContext), [UUID1, UUID2])
self.assertEqual(200, res.status_int)
# we would get an empty list for the second instance
# which is in the down cell, however this would printed
# in the logs.
for i, server in enumerate(self._get_servers(res.body)):
actual = server.get('%svolumes_attached' % self.prefix)
if i == 0:
self.assertEqual(self.exp_volumes_detail[i], actual)
else:
self.assertEqual([], actual)
def test_snapshot_attach_no_volume_cinder_cross_az_attach_false(self):
# Tests that the volume created from the snapshot has the same AZ as
# the instance.
self.flags(cross_az_attach=False, group="cinder")
no_volume_snapshot = self.snapshot_bdm_dict.copy()
no_volume_snapshot["volume_id"] = None
test_bdm = self.driver_classes["snapshot"](fake_block_device.fake_bdm_object(self.context, no_volume_snapshot))
snapshot = {"id": "fake-volume-id-1", "attach_status": "detached"}
volume = {"id": "fake-volume-id-2", "attach_status": "detached"}
wait_func = self.mox.CreateMockAnything()
self.volume_api.get_snapshot(self.context, "fake-snapshot-id-1").AndReturn(snapshot)
self.volume_api.create(self.context, 3, "", "", snapshot, availability_zone="test-az").AndReturn(volume)
wait_func(self.context, "fake-volume-id-2").AndReturn(None)
instance, expected_conn_info = self._test_volume_attach(
test_bdm, no_volume_snapshot, volume, availability_zone="test-az"
)
self.mox.ReplayAll()
test_bdm.attach(self.context, instance, self.volume_api, self.virt_driver, wait_func)
self.assertEqual("fake-volume-id-2", test_bdm.volume_id)
def test_blank_attach_volume_cinder_cross_az_attach_false(self):
# Tests that the blank volume created is in the same availability zone
# as the instance.
self.flags(cross_az_attach=False, group="cinder")
no_blank_volume = self.blank_bdm_dict.copy()
no_blank_volume["volume_id"] = None
test_bdm = self.driver_classes["blank"](fake_block_device.fake_bdm_object(self.context, no_blank_volume))
updates = {"uuid": "fake-uuid", "availability_zone": "test-az"}
instance = fake_instance.fake_instance_obj(mock.sentinel.ctx, **updates)
volume_class = self.driver_classes["volume"]
volume = {"id": "fake-volume-id-2", "display_name": "fake-uuid-blank-vol"}
with mock.patch.object(self.volume_api, "create", return_value=volume) as vol_create:
with mock.patch.object(volume_class, "attach") as vol_attach:
test_bdm.attach(self.context, instance, self.volume_api, self.virt_driver)
vol_create.assert_called_once_with(
self.context, test_bdm.volume_size, "fake-uuid-blank-vol", "", availability_zone="test-az"
)
vol_attach.assert_called_once_with(
self.context, instance, self.volume_api, self.virt_driver, do_check_attach=True
)
self.assertEqual("fake-volume-id-2", test_bdm.volume_id)
def setUp(self):
super(TestDriverBlockDevice, self).setUp()
self.volume_api = self.mox.CreateMock(cinder.API)
self.virt_driver = self.mox.CreateMock(driver.ComputeDriver)
self.context = context.RequestContext('fake_user', 'fake_project')
# create bdm objects for testing
self.swap_bdm = fake_block_device.fake_bdm_object(
self.context, self.swap_bdm_dict)
self.ephemeral_bdm = fake_block_device.fake_bdm_object(
self.context, self.ephemeral_bdm_dict)
self.volume_bdm = fake_block_device.fake_bdm_object(
self.context, self.volume_bdm_dict)
self.snapshot_bdm = fake_block_device.fake_bdm_object(
self.context, self.snapshot_bdm_dict)
self.image_bdm = fake_block_device.fake_bdm_object(
self.context, self.image_bdm_dict)
self.blank_bdm = fake_block_device.fake_bdm_object(
self.context, self.blank_bdm_dict)
def test_no_device_raises(self):
for name, cls in self.driver_classes.items():
bdm = fake_block_device.fake_bdm_object(
self.context, {'no_device': True})
self.assertRaises(driver_block_device._NotTransformable,
cls, bdm)
def test_no_device_raises(self):
for name, cls in self.driver_classes.items():
bdm = fake_block_device.fake_bdm_object(self.context,
{'no_device': True})
self.assertRaises(driver_block_device._NotTransformable, cls, bdm)
