def enable(self, server_id, retention, day_of_week=None):
"""
Enable the creation of scheduled images for the server.
:param server_id: The ID of the server to enable scheduled images for.
:param retention: The number of scheduled images to retain.
:param day_of_week: If given, the day of week (0-6, 0=Sunday) to create
a weekly schedule for. If omitted, create a daily schedule.
:rtype: :class:`ScheduledImage`
"""
try:
retention_val = int(retention)
except ValueError:
msg = "Retention value must be an integer"
raise exceptions.BadRequest(400, msg)
body = {'image_schedule': {'retention': int(retention_val)}}
if day_of_week is not None:
day_of_week_str = str(day_of_week)
if day_of_week_str.lower() not in DAYS:
msg = ("Day_of_week value must be a string in %s" % str(DAYS))
raise exceptions.BadRequest(400, msg)
body['image_schedule']['day_of_week'] = day_of_week_str
return self._create("/servers/%s/rax-si-image-schedule" % server_id,
body, "image_schedule")
def test_get_console_url_tolerate_unavailable(self):
msg = 'Unavailable console type %s.' % self.console_type
self.console_method.side_effect = nova_exceptions.BadRequest(
400, message=msg)
console_url = self.nova_plugin.get_console_urls(
self.server)[self.console_type]
self.console_method.assert_called_once_with(self.console_type)
self.assertEqual(msg, console_url)
def test_delete_quotas(self, mock_keystone, mock_nova):
project = fakes.FakeProject('project_a')
mock_keystone.tenants.list.return_value = [project]
self.op_cloud.delete_compute_quotas(project)
mock_nova.quotas.delete.assert_called_once_with(tenant_id='project_a')
mock_nova.quotas.delete.side_effect = nova_exceptions.BadRequest(400)
self.assertRaises(exc.OpenStackCloudException,
self.op_cloud.delete_compute_quotas, project)
def test_get_server_console_no_console(self, mock_nova):
server = dict(id='12345')
exc = nova_exceptions.BadRequest(
'There is no such action: os-getConsoleOutput')
mock_nova.servers.get_console_output.side_effect = exc
log = self.cloud.get_server_console(server)
self.assertEqual('', log)
mock_nova.servers.list.assert_not_called()
mock_nova.servers.get_console_output.assert_called_once_with(
server='12345', length=None)
def test_delete_quotas(self, mock_nova):
project = self.mock_for_keystone_projects(project_count=1,
list_get=True)[0]
# re-mock the list-get as the call to set_delete_compute_quotas when
# bad-request is raised, still calls out to get the project data.
self.mock_for_keystone_projects(project=project, list_get=True)
self.op_cloud.delete_compute_quotas(project.project_id)
mock_nova.quotas.delete.assert_called_once_with(
tenant_id=project.project_id)
mock_nova.quotas.delete.side_effect = nova_exceptions.BadRequest(400)
self.assertRaises(exc.OpenStackCloudException,
self.op_cloud.delete_compute_quotas, project)
self.assert_calls()
def test_delete_floating_ip_assoc_successful_if_create_failed(self):
rsrc = self.prepare_floating_ip_assoc()
self.novaclient.servers.add_floating_ip(None, '11.0.0.1').AndRaise(
ncli_ex.BadRequest(400))
self.m.ReplayAll()
rsrc.validate()
self.assertRaises(heat_ex.ResourceFailure,
scheduler.TaskRunner(rsrc.create))
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
scheduler.TaskRunner(rsrc.delete)()
self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state)
self.m.VerifyAll()
def test_execute_error(self):
@tools.screen_all_logs
def do_check(ex, status, code, message):
self.controller.reset_mock()
self.controller.fake_action.side_effect = ex
res = self.request.send(self.application)
self.assertEqual(status, res.status_code)
self.assertEqual('text/xml', res.content_type)
expected_xml = fakes.XML_ERROR_TEMPLATE % {
'code': code,
'message': message,
'request_id': self.fake_context.request_id
}
self.assertThat(res.body.decode("utf-8"),
matchers.XMLMatches(expected_xml))
self.controller.fake_action.assert_called_once_with(
self.fake_context, param='fake_param')
do_check(exception.EC2Exception('fake_msg'), 400, 'EC2Exception',
'fake_msg')
do_check(KeyError('fake_msg'), 500, 'KeyError',
'Unknown error occurred.')
do_check(exception.InvalidVpcIDNotFound('fake_msg'), 400,
'InvalidVpcID.NotFound', 'fake_msg')
do_check(nova_exception.BadRequest(400, message='fake_msg'), 400,
'BadRequest', 'fake_msg')
do_check(glance_exception.HTTPBadRequest(), 400, 'HTTPBadRequest',
'HTTP HTTPBadRequest')
do_check(cinder_exception.BadRequest(400, message='fake_msg'), 400,
'BadRequest', 'fake_msg')
do_check(neutron_exception.BadRequest(message='fake_msg'), 400,
'BadRequest', 'fake_msg')
do_check(keystone_exception.BadRequest(message='fake_msg'), 400,
'BadRequest', 'fake_msg (HTTP 400)')
do_check(
botocore_exceptions.ClientError(
{
'Error': {
'Code': '',
'Message': ''
},
'Code': 'FakeCode',
'Message': 'fake_msg'
}, 'register_image'), 400, 'FakeCode', 'fake_msg')
def test_attach_interface_with_bad_request_exception_raised(self):
instance = MagicMock()
attach_instance = pvcIns
attach_instance.interface_attach = \
MagicMock(side_effect=exceptions.BadRequest("Attach failed"))
vif = self._get_vif_instance()
pvc_driver = self._driver
pvc_driver._service._api = MagicMock()
pvc_driver._service._manager.get = \
MagicMock(return_value=attach_instance)
pvc_driver._service._api.get_pvc_port_uuid = \
MagicMock(return_value='')
pvc_driver._service._api.get_pvc_network_uuid = \
MagicMock(return_value='powervc-network-id-88888888')
self.assertRaises(exceptions.BadRequest, pvc_driver.attach_interface,
instance, {}, vif)
def test_delete_eip_successful_if_eip_associate_failed(self):
floating_ip = mox.IsA(object)
floating_ip.ip = '172.24.4.13'
floating_ip.id = '9037272b-6875-42e6-82e9-4342d5925da4'
self.m.StubOutWithMock(self.fc.floating_ips, 'create')
self.fc.floating_ips.create().AndReturn(floating_ip)
server = self.fc.servers.list()[0]
self._mock_server_get(mock_server=server, multiple=True)
self.m.StubOutWithMock(self.fc.servers, 'add_floating_ip')
self.fc.servers.add_floating_ip(
server, floating_ip.ip, None
).AndRaise(nova_exceptions.BadRequest(400))
self.m.StubOutWithMock(self.fc.servers, 'remove_floating_ip')
msg = ("ClientException: Floating ip 172.24.4.13 is not associated "
"with instance 1234.")
self.fc.servers.remove_floating_ip(
server, floating_ip.ip
).AndRaise(nova_exceptions.ClientException(422, msg))
self.m.StubOutWithMock(self.fc.floating_ips, 'delete')
self.fc.floating_ips.delete(mox.IsA(object))
self.m.ReplayAll()
t = template_format.parse(eip_template)
stack = utils.parse_stack(t)
resource_name = 'IPAddress'
resource_defns = stack.t.resource_definitions(stack)
rsrc = eip.ElasticIp(resource_name,
resource_defns[resource_name],
stack)
self.assertIsNone(rsrc.validate())
self.assertRaises(exception.ResourceFailure,
scheduler.TaskRunner(rsrc.create))
self.assertEqual((rsrc.CREATE, rsrc.FAILED), rsrc.state)
# to delete the eip
scheduler.TaskRunner(rsrc.delete)()
self.assertEqual((rsrc.DELETE, rsrc.COMPLETE), rsrc.state)
self.m.VerifyAll()
def test_get_failed_bad_request(self, mock_novaclient):
mock_novaclient.return_value.servers.get.side_effect = (
nova_exception.BadRequest(http.BAD_REQUEST, '400'))
self.assertRaises(exception.InvalidInput,
self.api.get_server, self.ctx, uuidsentinel.fake_server)
class NovaApiTestCase(test.TestCase):
def setUp(self):
super(NovaApiTestCase, self).setUp()
self.api = nova.API()
self.novaclient = FakeNovaClient()
self.ctx = context.get_admin_context()
self.mock_object(nova, 'novaclient',
mock.Mock(return_value=self.novaclient))
self.mock_object(nova, '_untranslate_server_summary_view',
lambda server: server)
def test_server_create(self):
result = self.api.server_create(self.ctx, 'server_name', 'fake_image',
'fake_flavor', None, None, None)
self.assertEqual('created_id', result['id'])
def test_server_delete(self):
self.mock_object(self.novaclient.servers, 'delete')
self.api.server_delete(self.ctx, 'id1')
self.novaclient.servers.delete.assert_called_once_with('id1')
def test_server_get(self):
instance_id = 'instance_id1'
result = self.api.server_get(self.ctx, instance_id)
self.assertEqual(instance_id, result['id'])
def test_server_get_by_name_or_id(self):
instance_id = 'instance_id1'
server = {'id': instance_id, 'fake_key': 'fake_value'}
self.mock_object(utils, 'find_resource',
mock.Mock(return_value=server))
result = self.api.server_get_by_name_or_id(self.ctx, instance_id)
self.assertEqual(instance_id, result['id'])
utils.find_resource.assert_called_once_with(mock.ANY, instance_id)
@ddt.data(
{
'nova_e': nova_exception.NotFound(404),
'manila_e': exception.InstanceNotFound
},
{
'nova_e': nova_exception.BadRequest(400),
'manila_e': exception.InvalidInput
},
)
@ddt.unpack
def test_server_get_failed(self, nova_e, manila_e):
nova.novaclient.side_effect = nova_e
instance_id = 'instance_id'
self.assertRaises(manila_e, self.api.server_get, self.ctx, instance_id)
def test_server_list(self):
self.assertEqual([{
'id': 'id1'
}, {
'id': 'id2'
}], self.api.server_list(self.ctx))
def test_server_pause(self):
self.mock_object(self.novaclient.servers, 'pause')
self.api.server_pause(self.ctx, 'id1')
self.novaclient.servers.pause.assert_called_once_with('id1')
def test_server_unpause(self):
self.mock_object(self.novaclient.servers, 'unpause')
self.api.server_unpause(self.ctx, 'id1')
self.novaclient.servers.unpause.assert_called_once_with('id1')
def test_server_suspend(self):
self.mock_object(self.novaclient.servers, 'suspend')
self.api.server_suspend(self.ctx, 'id1')
self.novaclient.servers.suspend.assert_called_once_with('id1')
def test_server_resume(self):
self.mock_object(self.novaclient.servers, 'resume')
self.api.server_resume(self.ctx, 'id1')
self.novaclient.servers.resume.assert_called_once_with('id1')
def test_server_reboot_hard(self):
self.mock_object(self.novaclient.servers, 'reboot')
self.api.server_reboot(self.ctx, 'id1')
self.novaclient.servers.reboot.assert_called_once_with(
'id1', nova_servers.REBOOT_HARD)
def test_server_reboot_soft(self):
self.mock_object(self.novaclient.servers, 'reboot')
self.api.server_reboot(self.ctx, 'id1', True)
self.novaclient.servers.reboot.assert_called_once_with(
'id1', nova_servers.REBOOT_SOFT)
def test_server_rebuild(self):
self.mock_object(self.novaclient.servers, 'rebuild')
self.api.server_rebuild(self.ctx, 'id1', 'fake_image')
self.novaclient.servers.rebuild.assert_called_once_with(
'id1', 'fake_image', None)
def test_instance_volume_attach(self):
self.mock_object(self.novaclient.volumes, 'create_server_volume')
self.api.instance_volume_attach(self.ctx, 'instance_id', 'vol_id',
'device')
self.novaclient.volumes.create_server_volume.\
assert_called_once_with('instance_id', 'vol_id', 'device')
def test_instance_volume_detach(self):
self.mock_object(self.novaclient.volumes, 'delete_server_volume')
self.api.instance_volume_detach(self.ctx, 'instance_id', 'att_id')
self.novaclient.volumes.delete_server_volume.\
assert_called_once_with('instance_id', 'att_id')
def test_instance_volumes_list(self):
self.mock_object(
self.novaclient.volumes, 'get_server_volumes',
mock.Mock(
return_value=[Volume('id1'), Volume('id2')]))
self.cinderclient = self.novaclient
self.mock_object(cinder, 'cinderclient',
mock.Mock(return_value=self.novaclient))
result = self.api.instance_volumes_list(self.ctx, 'instance_id')
self.assertEqual(2, len(result))
self.assertEqual('id1', result[0].id)
self.assertEqual('id2', result[1].id)
def test_server_update(self):
self.mock_object(self.novaclient.servers, 'update')
self.api.server_update(self.ctx, 'id1', 'new_name')
self.novaclient.servers.update.assert_called_once_with('id1',
name='new_name')
def test_update_server_volume(self):
self.mock_object(self.novaclient.volumes, 'update_server_volume')
self.api.update_server_volume(self.ctx, 'instance_id', 'att_id',
'new_vol_id')
self.novaclient.volumes.update_server_volume.\
assert_called_once_with('instance_id', 'att_id', 'new_vol_id')
def test_keypair_create(self):
self.mock_object(self.novaclient.keypairs, 'create')
self.api.keypair_create(self.ctx, 'keypair_name')
self.novaclient.keypairs.create.assert_called_once_with('keypair_name')
def test_keypair_import(self):
self.mock_object(self.novaclient.keypairs, 'create')
self.api.keypair_import(self.ctx, 'keypair_name', 'fake_pub_key')
self.novaclient.keypairs.create.\
assert_called_once_with('keypair_name', 'fake_pub_key')
def test_keypair_delete(self):
self.mock_object(self.novaclient.keypairs, 'delete')
self.api.keypair_delete(self.ctx, 'fake_keypair_id')
self.novaclient.keypairs.delete.\
assert_called_once_with('fake_keypair_id')
def test_keypair_list(self):
self.assertEqual([{
'id': 'id1'
}, {
'id': 'id2'
}], self.api.keypair_list(self.ctx))
def test_fixed_ip_get(self):
fixed_ip = 'fake_fixed_ip'
result = self.api.fixed_ip_get(self.ctx, fixed_ip)
self.assertIsInstance(result, dict)
self.assertEqual(fixed_ip, result['address'])
def test_fixed_ip_reserve(self):
fixed_ip = 'fake_fixed_ip'
result = self.api.fixed_ip_reserve(self.ctx, fixed_ip)
self.assertIsNone(result)
def test_fixed_ip_unreserve(self):
fixed_ip = 'fake_fixed_ip'
result = self.api.fixed_ip_unreserve(self.ctx, fixed_ip)
self.assertIsNone(result)
def test_network_get(self):
net_id = 'fake_net_id'
net = self.api.network_get(self.ctx, net_id)
self.assertIsInstance(net, dict)
self.assertEqual(net_id, net['id'])
def test_get_console_url_tolerate_unavailable(self):
msg = 'Unavailable console type %s.' % self.console_type
self.console_method.side_effect = nova_exceptions.BadRequest(
400, message=msg)
self._test_get_console_url_tolerate_exception(msg)
def create_vm(self,
name,
image,
flavor,
nics=None,
security_groups=None,
scheduler_hints=None,
**kwargs):
"""Mock'd version of novaclient...create_vm().
Create a Nova VM.
:param body: Dictionary with vm information.
:return: An updated copy of the 'body' that was passed in, with other
information populated.
"""
if len(self._vm_list) >= self._vm_limit:
raise nova_exc.OverLimit(413)
try:
flavor_id = flavor.id
except AttributeError:
flavor_id = flavor
try:
image_id = image.id
except AttributeError:
image_id = image
if flavor_id not in self._flavor_list:
raise nova_exc.BadRequest(400)
if image_id not in self._image_list:
raise nova_exc.BadRequest(400)
port_list = list()
if nics is not None:
neutron_client = client.neutron_client()
for nic in nics:
if 'net-id' in nic:
network_list = neutron_client.list_networks(
id=nic['net-id'])
if (not network_list or 'networks' not in network_list
or len(network_list['networks']) == 0):
raise nova_exc.BadRequest(400)
else:
body_value = {
"port": {
"admin_state_up": True,
"name": "test port",
"network_id": nic['net-id'],
}
}
port_info = neutron_client.create_port(body=body_value)
port_id = port_info['port']['id']
port_list.append(
InterfaceDetails(net_id=nic['net-id'],
port_id=port_id))
if 'port-id' in nic:
port_list.append(InterfaceDetails(port_id=nic['port-id']))
if security_groups is not None:
missing = set(security_groups) - set(self._security_group_list)
if missing:
raise nova_exc.BadRequest(400)
newVm = VmDetails(vm_id=uuid.uuid4(),
name=name,
flavor=flavor,
image=image,
port_list=port_list,
status='BUILDING')
if scheduler_hints is not None:
try:
group_id = scheduler_hints['group']
except AttributeError:
group_id = scheduler_hints
if group_id not in self._vm_group_list:
raise nova_exc.BadRequest(400)
newVm.host_id = str(uuid.uuid4())
self._vm_list[str(newVm.id)] = newVm
return newVm
class NovaApiTestCase(test.TestCase):
def setUp(self):
super(NovaApiTestCase, self).setUp()
self.api = nova.API()
self.novaclient = FakeNovaClient()
self.ctx = context.get_admin_context()
self.mock_object(nova, 'novaclient',
mock.Mock(return_value=self.novaclient))
self.mock_object(nova, '_untranslate_server_summary_view',
lambda server: server)
def test_image_list_novaclient_has_no_proxy(self):
image_list = ['fake', 'image', 'list']
class FakeGlanceClient(object):
def list(self):
return image_list
self.novaclient.glance = FakeGlanceClient()
result = self.api.image_list(self.ctx)
self.assertEqual(image_list, result)
def test_image_list_novaclient_has_proxy(self):
image_list1 = ['fake', 'image', 'list1']
image_list2 = ['fake', 'image', 'list2']
class FakeImagesClient(object):
def list(self):
return image_list1
class FakeGlanceClient(object):
def list(self):
return image_list2
self.novaclient.images = FakeImagesClient()
self.novaclient.glance = FakeGlanceClient()
result = self.api.image_list(self.ctx)
self.assertEqual(image_list1, result)
def test_server_create(self):
result = self.api.server_create(self.ctx, 'server_name', 'fake_image',
'fake_flavor', None, None, None)
self.assertEqual('created_id', result['id'])
def test_server_delete(self):
self.mock_object(self.novaclient.servers, 'delete')
self.api.server_delete(self.ctx, 'id1')
self.novaclient.servers.delete.assert_called_once_with('id1')
def test_server_get(self):
instance_id = 'instance_id1'
result = self.api.server_get(self.ctx, instance_id)
self.assertEqual(instance_id, result['id'])
def test_server_get_by_name_or_id(self):
instance_id = 'instance_id1'
server = {'id': instance_id, 'fake_key': 'fake_value'}
self.mock_object(utils, 'find_resource',
mock.Mock(return_value=server))
result = self.api.server_get_by_name_or_id(self.ctx, instance_id)
self.assertEqual(instance_id, result['id'])
utils.find_resource.assert_called_once_with(mock.ANY, instance_id)
def test_server_get_by_name_or_id_failed(self):
instance_id = 'instance_id1'
server = {'id': instance_id, 'fake_key': 'fake_value'}
self.mock_object(utils, 'find_resource',
mock.Mock(return_value=server,
side_effect=nova_exception.CommandError))
self.assertRaises(exception.ManilaException,
self.api.server_get_by_name_or_id,
self.ctx, instance_id)
utils.find_resource.assert_any_call(mock.ANY, instance_id)
utils.find_resource.assert_called_with(mock.ANY, instance_id,
all_tenants=True)
@ddt.data(
{'nova_e': nova_exception.NotFound(404),
'manila_e': exception.InstanceNotFound},
{'nova_e': nova_exception.BadRequest(400),
'manila_e': exception.InvalidInput},
)
@ddt.unpack
def test_server_get_failed(self, nova_e, manila_e):
nova.novaclient.side_effect = nova_e
instance_id = 'instance_id'
self.assertRaises(manila_e, self.api.server_get, self.ctx, instance_id)
def test_server_pause(self):
self.mock_object(self.novaclient.servers, 'pause')
self.api.server_pause(self.ctx, 'id1')
self.novaclient.servers.pause.assert_called_once_with('id1')
def test_server_unpause(self):
self.mock_object(self.novaclient.servers, 'unpause')
self.api.server_unpause(self.ctx, 'id1')
self.novaclient.servers.unpause.assert_called_once_with('id1')
def test_server_suspend(self):
self.mock_object(self.novaclient.servers, 'suspend')
self.api.server_suspend(self.ctx, 'id1')
self.novaclient.servers.suspend.assert_called_once_with('id1')
def test_server_resume(self):
self.mock_object(self.novaclient.servers, 'resume')
self.api.server_resume(self.ctx, 'id1')
self.novaclient.servers.resume.assert_called_once_with('id1')
def test_server_reboot_hard(self):
self.mock_object(self.novaclient.servers, 'reboot')
self.api.server_reboot(self.ctx, 'id1')
self.novaclient.servers.reboot.assert_called_once_with(
'id1', nova_servers.REBOOT_HARD)
def test_server_reboot_soft(self):
self.mock_object(self.novaclient.servers, 'reboot')
self.api.server_reboot(self.ctx, 'id1', True)
self.novaclient.servers.reboot.assert_called_once_with(
'id1', nova_servers.REBOOT_SOFT)
def test_server_rebuild(self):
self.mock_object(self.novaclient.servers, 'rebuild')
self.api.server_rebuild(self.ctx, 'id1', 'fake_image')
self.novaclient.servers.rebuild.assert_called_once_with('id1',
'fake_image',
None)
def test_instance_volume_attach(self):
self.mock_object(self.novaclient.volumes, 'create_server_volume')
self.api.instance_volume_attach(self.ctx, 'instance_id',
'vol_id', 'device')
(self.novaclient.volumes.create_server_volume.
assert_called_once_with('instance_id', 'vol_id', 'device'))
def test_instance_volume_detach(self):
self.mock_object(self.novaclient.volumes, 'delete_server_volume')
self.api.instance_volume_detach(self.ctx, 'instance_id',
'att_id')
(self.novaclient.volumes.delete_server_volume.
assert_called_once_with('instance_id', 'att_id'))
def test_instance_volumes_list(self):
self.mock_object(
self.novaclient.volumes, 'get_server_volumes',
mock.Mock(return_value=[Volume('id1'), Volume('id2')]))
self.cinderclient = self.novaclient
self.mock_object(cinder, 'cinderclient',
mock.Mock(return_value=self.novaclient))
result = self.api.instance_volumes_list(self.ctx, 'instance_id')
self.assertEqual(2, len(result))
self.assertEqual('id1', result[0].id)
self.assertEqual('id2', result[1].id)
def test_server_update(self):
self.mock_object(self.novaclient.servers, 'update')
self.api.server_update(self.ctx, 'id1', 'new_name')
self.novaclient.servers.update.assert_called_once_with('id1',
name='new_name')
def test_update_server_volume(self):
self.mock_object(self.novaclient.volumes, 'update_server_volume')
self.api.update_server_volume(self.ctx, 'instance_id', 'att_id',
'new_vol_id')
(self.novaclient.volumes.update_server_volume.
assert_called_once_with('instance_id', 'att_id', 'new_vol_id'))
def test_keypair_create(self):
self.mock_object(self.novaclient.keypairs, 'create')
self.api.keypair_create(self.ctx, 'keypair_name')
self.novaclient.keypairs.create.assert_called_once_with('keypair_name')
def test_keypair_import(self):
self.mock_object(self.novaclient.keypairs, 'create')
self.api.keypair_import(self.ctx, 'keypair_name', 'fake_pub_key')
(self.novaclient.keypairs.create.
assert_called_once_with('keypair_name', 'fake_pub_key'))
def test_keypair_delete(self):
self.mock_object(self.novaclient.keypairs, 'delete')
self.api.keypair_delete(self.ctx, 'fake_keypair_id')
(self.novaclient.keypairs.delete.
assert_called_once_with('fake_keypair_id'))
def test_keypair_list(self):
self.assertEqual([{'id': 'id1'}, {'id': 'id2'}],
self.api.keypair_list(self.ctx))
