def test_attach(self):
volume_id = '00000000-0000-0000-0000-000000000000'
server_id = '11111111-1111-1111-1111-111111111111'
device_name = '/dev/fake'
volume_ctx = cfy_mocks.MockContext({
'node':
cfy_mocks.MockContext(
{'properties': {
volume.DEVICE_NAME_PROPERTY: device_name
}}),
'instance':
cfy_mocks.MockContext(
{'runtime_properties': {
OPENSTACK_ID_PROPERTY: volume_id,
}})
})
server_ctx = cfy_mocks.MockContext({
'node':
cfy_mocks.MockContext({'properties': {}}),
'instance':
cfy_mocks.MockContext({
'runtime_properties': {
server.OPENSTACK_ID_PROPERTY: server_id
}
})
})
ctx_m = cfy_mocks.MockCloudifyContext(node_id='a',
target=server_ctx,
source=volume_ctx)
cinderclient_m = mock.Mock()
novaclient_m = mock.Mock()
novaclient_m.volumes = mock.Mock()
novaclient_m.volumes.create_server_volume = mock.Mock()
with contextlib.nested(
mock.patch.object(NovaClient, 'get',
mock.Mock(return_value=novaclient_m)),
mock.patch.object(CinderClient, 'get',
mock.Mock(return_value=cinderclient_m)),
mock.patch.object(volume, 'wait_until_status',
mock.Mock(return_value=(None, True)))):
server.attach_volume(ctx=ctx_m)
novaclient_m.volumes.create_server_volume.assert_called_once_with(
server_id, volume_id, device_name)
volume.wait_until_status.assert_called_once_with(
cinder_client=cinderclient_m,
volume_id=volume_id,
status=volume.VOLUME_STATUS_IN_USE)
def test_attach(self):
volume_id = '00000000-0000-0000-0000-000000000000'
server_id = '11111111-1111-1111-1111-111111111111'
device_name = '/dev/fake'
volume_ctx = cfy_mocks.MockContext({
'node': cfy_mocks.MockContext({
'properties': {volume.DEVICE_NAME_PROPERTY: device_name}
}),
'instance': cfy_mocks.MockContext({
'runtime_properties': {
OPENSTACK_ID_PROPERTY: volume_id,
}
})
})
server_ctx = cfy_mocks.MockContext({
'node': cfy_mocks.MockContext({
'properties': {}
}),
'instance': cfy_mocks.MockContext({
'runtime_properties': {
server.OPENSTACK_ID_PROPERTY: server_id
}
})
})
ctx_m = self._mock(node_id='a',
target=server_ctx,
source=volume_ctx)
cinderclient_m = mock.Mock()
novaclient_m = mock.Mock()
novaclient_m.volumes = mock.Mock()
novaclient_m.volumes.create_server_volume = mock.Mock()
with contextlib.nested(
mock.patch.object(NovaClient, 'get',
mock.Mock(return_value=novaclient_m)),
mock.patch.object(CinderClient, 'get',
mock.Mock(return_value=cinderclient_m)),
mock.patch.object(volume,
'wait_until_status',
mock.Mock(return_value=(None, True)))):
server.attach_volume(ctx=ctx_m)
novaclient_m.volumes.create_server_volume.assert_called_once_with(
server_id, volume_id, device_name)
volume.wait_until_status.assert_called_once_with(
cinder_client=cinderclient_m,
volume_id=volume_id,
status=volume.VOLUME_STATUS_IN_USE)
def test_attach(self, wait_until_status_m, cinder_m, nova_m):
volume_id = '00000000-0000-0000-0000-000000000000'
server_id = '11111111-1111-1111-1111-111111111111'
device_name = '/dev/fake'
volume_ctx = cfy_mocks.MockContext({
'node': cfy_mocks.MockContext({
'properties': {volume.DEVICE_NAME_PROPERTY: device_name}
}),
'instance': cfy_mocks.MockContext({
'runtime_properties': {
OPENSTACK_ID_PROPERTY: volume_id,
}
})
})
server_ctx = cfy_mocks.MockContext({
'node': cfy_mocks.MockContext({
'properties': {}
}),
'instance': cfy_mocks.MockContext({
'runtime_properties': {
server.OPENSTACK_ID_PROPERTY: server_id
}
})
})
ctx_m = self._mock(node_id='a',
target=server_ctx,
source=volume_ctx)
nova_instance = nova_m.return_value
cinder_instance = cinder_m.return_value
server.attach_volume(ctx=ctx_m, status_attempts=10,
status_timeout=2)
nova_instance.volumes.create_server_volume.assert_called_once_with(
server_id, volume_id, device_name)
wait_until_status_m.assert_called_once_with(
cinder_client=cinder_instance,
volume_id=volume_id,
status=volume.VOLUME_STATUS_IN_USE,
num_tries=10,
timeout=2,
)
def _test_cleanup__after_attach_fails(
self, volume_ctx_mgr, expected_err_cls, expect_cleanup=True):
volume_id = '00000000-0000-0000-0000-000000000000'
server_id = '11111111-1111-1111-1111-111111111111'
attachment_id = '22222222-2222-2222-2222-222222222222'
device_name = '/dev/fake'
attachment = {'id': attachment_id,
'server_id': server_id,
'volume_id': volume_id}
volume_ctx = cfy_mocks.MockContext({
'node': cfy_mocks.MockContext({
'properties': {volume.DEVICE_NAME_PROPERTY: device_name}
}),
'instance': cfy_mocks.MockContext({
'runtime_properties': {
OPENSTACK_ID_PROPERTY: volume_id,
}
})
})
server_ctx = cfy_mocks.MockContext({
'node': cfy_mocks.MockContext({
'properties': {}
}),
'instance': cfy_mocks.MockContext({
'runtime_properties': {
server.OPENSTACK_ID_PROPERTY: server_id
}
})
})
ctx_m = self._mock(node_id='a',
target=server_ctx,
source=volume_ctx)
attached_volume_m = mock.Mock()
attached_volume_m.id = volume_id
attached_volume_m.status = volume.VOLUME_STATUS_IN_USE
attached_volume_m.attachments = [attachment]
cinderclient_m = mock.Mock()
cinderclient_m.volumes = mock.Mock()
cinderclient_m.volumes.get = mock.Mock(
return_value=attached_volume_m)
novaclient_m = mock.Mock()
novacl_vols_m = novaclient_m.volumes = mock.Mock()
novacl_vols_m.create_server_volume = mock.Mock()
with contextlib.nested(
mock.patch.object(NovaClient, 'get',
mock.Mock(return_value=novaclient_m)),
mock.patch.object(CinderClient, 'get',
mock.Mock(return_value=cinderclient_m)),
volume_ctx_mgr):
with self.assertRaises(expected_err_cls):
server.attach_volume(ctx=ctx_m)
novacl_vols_m.create_server_volume.assert_called_once_with(
server_id, volume_id, device_name)
volume.wait_until_status.assert_any_call(
cinder_client=cinderclient_m,
volume_id=volume_id,
status=volume.VOLUME_STATUS_IN_USE)
if expect_cleanup:
novacl_vols_m.delete_server_volume.assert_called_once_with(
server_id, attachment_id)
self.assertEqual(2, volume.wait_until_status.call_count)
volume.wait_until_status.assert_called_with(
cinder_client=cinderclient_m,
volume_id=volume_id,
status=volume.VOLUME_STATUS_AVAILABLE)
def _test_cleanup__after_attach_fails(
self, expected_err_cls, expect_cleanup,
wait_until_status_m, cinder_m, nova_m):
volume_id = '00000000-0000-0000-0000-000000000000'
server_id = '11111111-1111-1111-1111-111111111111'
attachment_id = '22222222-2222-2222-2222-222222222222'
device_name = '/dev/fake'
attachment = {'id': attachment_id,
'server_id': server_id,
'volume_id': volume_id}
volume_ctx = cfy_mocks.MockContext({
'node': cfy_mocks.MockContext({
'properties': {volume.DEVICE_NAME_PROPERTY: device_name}
}),
'instance': cfy_mocks.MockContext({
'runtime_properties': {
OPENSTACK_ID_PROPERTY: volume_id,
}
})
})
server_ctx = cfy_mocks.MockContext({
'node': cfy_mocks.MockContext({
'properties': {}
}),
'instance': cfy_mocks.MockContext({
'runtime_properties': {
server.OPENSTACK_ID_PROPERTY: server_id
}
})
})
ctx_m = self._mock(node_id='a',
target=server_ctx,
source=volume_ctx)
attached_volume = mock.Mock(id=volume_id,
status=volume.VOLUME_STATUS_IN_USE,
attachments=[attachment])
nova_instance = nova_m.return_value
cinder_instance = cinder_m.return_value
cinder_instance.volumes.get.return_value = attached_volume
with self.assertRaises(expected_err_cls):
server.attach_volume(ctx=ctx_m, status_attempts=10,
status_timeout=2)
nova_instance.volumes.create_server_volume.assert_called_once_with(
server_id, volume_id, device_name)
volume.wait_until_status.assert_any_call(
cinder_client=cinder_instance,
volume_id=volume_id,
status=volume.VOLUME_STATUS_IN_USE,
num_tries=10,
timeout=2,
)
if expect_cleanup:
nova_instance.volumes.delete_server_volume.assert_called_once_with(
server_id, attachment_id)
self.assertEqual(2, volume.wait_until_status.call_count)
volume.wait_until_status.assert_called_with(
cinder_client=cinder_instance,
volume_id=volume_id,
status=volume.VOLUME_STATUS_AVAILABLE,
num_tries=10,
timeout=2)
