def test_migrate_attachment_specs(self):
# Create an attachment.
attachment = objects.VolumeAttachment(self.context,
attach_status='attaching',
volume_id=fake.VOLUME_ID)
attachment.create()
# Create some attachment_specs. Note that the key and value have to
# be strings, the table doesn't handle things like a wwpns list
# for a fibrechannel connector.
connector = {'host': '127.0.0.1'}
db.attachment_specs_update_or_create(self.context, attachment.id,
connector)
# Now get the volume attachment object from the database and make
# sure the connector was migrated from the attachment_specs table
# to the volume_attachment table and the specs were deleted.
attachment = objects.VolumeAttachment.get_by_id(
self.context, attachment.id)
self.assertIn('connector', attachment)
self.assertDictEqual(connector, attachment.connector)
self.assertEqual(
0, len(db.attachment_specs_get(self.context, attachment.id)))
# Make sure we can store a fibrechannel type connector that has a wwpns
# list value.
connector['wwpns'] = ['21000024ff34c92d', '21000024ff34c92c']
attachment.connector = connector
attachment.save()
# Get the object from the DB again and make sure the connector is
# there.
attachment = objects.VolumeAttachment.get_by_id(
self.context, attachment.id)
self.assertIn('connector', attachment)
self.assertDictEqual(connector, attachment.connector)
def test_view_get_attachments(self):
fake_volume = self._fake_create_volume()
fake_volume['attach_status'] = fields.VolumeAttachStatus.ATTACHING
att_time = datetime.datetime(2017,
8,
31,
21,
55,
7,
tzinfo=iso8601.UTC)
a1 = {
'id': fake.UUID1,
'volume_id': fake.UUID2,
'instance': None,
'attached_host': None,
'mountpoint': None,
'attach_time': None,
'attach_status': fields.VolumeAttachStatus.ATTACHING
}
a2 = {
'id': fake.UUID3,
'volume_id': fake.UUID4,
'instance_uuid': fake.UUID5,
'attached_host': 'host1',
'mountpoint': 'na',
'attach_time': att_time,
'attach_status': fields.VolumeAttachStatus.ATTACHED
}
attachment1 = objects.VolumeAttachment(self.ctxt, **a1)
attachment2 = objects.VolumeAttachment(self.ctxt, **a2)
atts = {'objects': [attachment1, attachment2]}
attachments = objects.VolumeAttachmentList(self.ctxt, **atts)
fake_volume['volume_attachment'] = attachments
# get_attachments should only return attachments with the
# attached status = ATTACHED
attachments = ViewBuilder()._get_attachments(fake_volume)
self.assertEqual(1, len(attachments))
self.assertEqual(fake.UUID3, attachments[0]['attachment_id'])
self.assertEqual(fake.UUID4, attachments[0]['volume_id'])
self.assertEqual(fake.UUID5, attachments[0]['server_id'])
self.assertEqual('host1', attachments[0]['host_name'])
self.assertEqual('na', attachments[0]['device'])
self.assertEqual(att_time, attachments[0]['attached_at'])
def test_lazy_load_volume(self, volume_get_mock):
volume = objects.Volume(self.context, id=fake.VOLUME_ID)
volume_get_mock.return_value = volume
attach = objects.VolumeAttachment(self.context, id=fake.ATTACHMENT_ID,
volume_id=volume.id)
r = attach.volume
self.assertEqual(volume, r)
volume_get_mock.assert_called_once_with(self.context, volume.id)
def begin_attach(self, attach_mode):
attachment = objects.VolumeAttachment(
context=self._context,
attach_status=c_fields.VolumeAttachStatus.ATTACHING,
volume_id=self.id)
attachment.create()
with self.obj_as_admin():
self.admin_metadata['attached_mode'] = attach_mode
self.save()
return attachment
def test_obj_make_compatible(self, version):
connection_info = {'field': 'value'}
vol_attach = objects.VolumeAttachment(self.context,
connection_info=connection_info)
primitive = vol_attach.obj_to_primitive(version)
converted_vol_attach = objects.VolumeAttachment.obj_from_primitive(
primitive)
if version == '1.2':
self.assertEqual(connection_info,
converted_vol_attach.connection_info)
else:
self.assertFalse(
converted_vol_attach.obj_attr_is_set('connection_info'))
def test_from_db_object_no_volume(self):
original_get = attributes.InstrumentedAttribute.__get__
def my_get(get_self, instance, owner):
self.assertNotEqual('volume', get_self.key)
return original_get(get_self, instance, owner)
# Volume field is not loaded
attach = fake_volume.models.VolumeAttachment(id=fake.ATTACHMENT_ID,
volume_id=fake.VOLUME_ID)
patch_str = 'sqlalchemy.orm.attributes.InstrumentedAttribute.__get__'
with mock.patch(patch_str, side_effect=my_get):
objects.VolumeAttachment._from_db_object(
self.context, objects.VolumeAttachment(), attach)
def _create_attachment(self, ctxt=None, volume_uuid=None,
instance_uuid=None, mountpoint=None,
attach_time=None, detach_time=None,
attach_status=None, attach_mode=None):
"""Create an attachment object."""
ctxt = ctxt or self.ctxt
attachment = objects.VolumeAttachment(ctxt)
attachment.volume_id = volume_uuid
attachment.instance_uuid = instance_uuid
attachment.mountpoint = mountpoint
attachment.attach_time = attach_time
attachment.detach_time = detach_time
attachment.attach_status = attach_status or 'reserved'
attachment.attach_mode = attach_mode
attachment.create()
return attachment
def test_set_connection(self):
vol = cinderlib.Volume(self.backend, size=1, name='disk')
conn = cinderlib.Connection(self.backend, volume=vol, connector={})
self.assertEqual(0,
len(sqla_api.volume_attachment_get_all(self.context)))
self.persistence.set_connection(conn)
db_entries = sqla_api.volume_attachment_get_all(self.context)
self.assertEqual(1, len(db_entries))
ovo_conn = cinder_ovos.VolumeAttachment(self.context)
ovo_conn._from_db_object(ovo_conn._context, ovo_conn, db_entries[0])
cl_conn = cinderlib.Connection(vol.backend, volume=vol, __ovo=ovo_conn)
self.assertEqualObj(conn, cl_conn)
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_volume_detached_with_attachment(self, volume_attachment_get,
volume_detached, metadata_delete):
va_objs = [
objects.VolumeAttachment(context=self.context, id=i)
for i in [fake.OBJECT_ID, fake.OBJECT2_ID, fake.OBJECT3_ID]
]
# As changes are not saved, we need reset it here. Later changes
# will be checked.
for obj in va_objs:
obj.obj_reset_changes()
va_list = objects.VolumeAttachmentList(context=self.context,
objects=va_objs)
va_list.obj_reset_changes()
volume_attachment_get.return_value = va_list
admin_context = context.get_admin_context()
volume = fake_volume.fake_volume_obj(admin_context,
volume_attachment=va_list,
volume_admin_metadata=[{
'key':
'attached_mode',
'value':
'rw'
}])
self.assertEqual(3, len(volume.volume_attachment))
volume_detached.return_value = ({
'status': 'in-use'
}, {
'attached_mode': 'rw'
})
with mock.patch.object(admin_context, 'elevated') as mock_elevated:
mock_elevated.return_value = admin_context
volume.finish_detach(fake.OBJECT_ID)
volume_detached.assert_called_once_with(admin_context, volume.id,
fake.OBJECT_ID)
metadata_delete.assert_called_once_with(admin_context, volume.id,
'attached_mode')
self.assertEqual('in-use', volume.status)
self.assertEqual({}, volume.cinder_obj_get_changes())
self.assertEqual(2, len(volume.volume_attachment))
self.assertIsNone(volume.admin_metadata.get('attached_mode'))
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 fake_volume_attachment_obj(context, **updates):
return objects.VolumeAttachment._from_db_object(
context, objects.VolumeAttachment(),
fake_db_volume_attachment(**updates))
def volume_attachment_ovo(context, **updates):
orm = volume_attachment_db_obj(**updates)
return objects.VolumeAttachment._from_db_object(context,
objects.VolumeAttachment(),
orm)
