def fake_compute_get_empty(*args, **kwargs):
inst = fakes.stub_instance(1,
uuid=UUID3,
host="",
vm_state=vm_states.ACTIVE,
availability_zone='fakeaz')
return fake_instance.fake_instance_obj(args[1], **inst)
def test_destroy_trigger_undeploy_fail(self, fake_validate, mock_sps):
node_uuid = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
node = ironic_utils.get_test_node(driver="fake", uuid=node_uuid, provision_state=ironic_states.ACTIVE)
fake_validate.return_value = node
instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid)
mock_sps.side_effect = exception.NovaException()
self.assertRaises(exception.NovaException, self.driver.destroy, self.ctx, instance, None, None)
def test__cleanup_deploy_good(self, mock_update):
node = ironic_utils.get_test_node(driver='fake', instance_uuid='fake-id')
instance = fake_instance.fake_instance_obj(self.ctx,
node=node.uuid)
self.driver._cleanup_deploy(node, instance, None)
expected_patch = [{'path': '/instance_uuid', 'op': 'remove'}]
mock_update.assert_called_once_with(node.uuid, expected_patch)
def test__plug_vifs(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(uuid=node_uuid)
port = ironic_utils.get_test_port()
mock_uvifs = mock.patch.object(self.driver, '_unplug_vifs').start()
self.addCleanup(mock_uvifs.stop)
mock_port_udt = mock.patch.object(FAKE_CLIENT.port, 'update').start()
self.addCleanup(mock_port_udt.stop)
with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp:
mock_lp.return_value = [port]
instance = fake_instance.fake_instance_obj(self.ctx,
node=node_uuid)
network_info = utils.get_test_network_info()
port_id = unicode(network_info[0]['id'])
expected_patch = [{'op': 'add',
'path': '/extra/vif_port_id',
'value': port_id}]
self.driver._plug_vifs(node, instance, network_info)
# asserts
mock_uvifs.assert_called_once_with(node, instance, network_info)
mock_lp.assert_called_once_with(node_uuid)
mock_port_udt.assert_called_with(port.uuid, expected_patch)
def test_allocate_for_instance_handles_macs_passed(self):
# If a macs argument is supplied to the 'nova-network' API, it is just
# ignored. This test checks that the call down to the rpcapi layer
# doesn't pass macs down: nova-network doesn't support hypervisor
# mac address limits (today anyhow).
macs = set(['ab:cd:ef:01:23:34'])
self.mox.StubOutWithMock(self.network_api.network_rpcapi,
"allocate_for_instance")
kwargs = dict(
zip([
'host', 'instance_id', 'project_id', 'requested_networks',
'rxtx_factor', 'vpn', 'macs', 'dhcp_options'
], itertools.repeat(mox.IgnoreArg())))
self.network_api.network_rpcapi.allocate_for_instance(
mox.IgnoreArg(), **kwargs).AndReturn([])
self.mox.ReplayAll()
flavor = flavors.get_default_flavor()
flavor['rxtx_factor'] = 0
sys_meta = flavors.save_flavor_info({}, flavor)
instance = dict(id=1,
uuid='uuid',
project_id='project_id',
host='host',
system_metadata=utils.dict_to_metadata(sys_meta))
instance = fake_instance.fake_instance_obj(
self.context, expected_attrs=['system_metadata'], **instance)
self.network_api.allocate_for_instance(self.context,
instance,
'vpn',
'requested_networks',
macs=macs)
def test_ensure_filtering_rules_for_instance(self, mock_pif, mock_sbf):
instance = fake_instance.fake_instance_obj(self.ctx)
network_info = utils.get_test_network_info()
self.driver.ensure_filtering_rules_for_instance(instance,
network_info)
mock_sbf.assert_called_once_with(instance, network_info)
mock_pif.assert_called_once_with(instance, network_info)
def test_instance_exists(self, mock_call):
instance_uuid = 'fake-uuid'
instance = fake_instance.fake_instance_obj(self.ctx,
uuid=instance_uuid)
self.assertTrue(self.driver.instance_exists(instance))
mock_call.assert_called_once_with('node.get_by_instance_uuid',
instance_uuid)
def test__plug_vifs_count_mismatch(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(uuid=node_uuid)
port = ironic_utils.get_test_port()
mock_uvifs = mock.patch.object(self.driver, '_unplug_vifs').start()
self.addCleanup(mock_uvifs.stop)
mock_port_udt = mock.patch.object(FAKE_CLIENT.port, 'update').start()
self.addCleanup(mock_port_udt.stop)
with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp:
mock_lp.return_value = [port]
instance = fake_instance.fake_instance_obj(self.ctx,
node=node_uuid)
# len(network_info) > len(ports)
network_info = (utils.get_test_network_info() +
utils.get_test_network_info())
self.assertRaises(exception.NovaException, self.driver._plug_vifs,
node, instance, network_info)
# asserts
mock_uvifs.assert_called_once_with(node, instance, network_info)
mock_lp.assert_called_once_with(node_uuid)
# assert port.update() was not called
assert not mock_port_udt.called
def test_list_resizing_instances(self):
instances = [{
'image_ref': '1',
'host': CONF.host,
'id': '1',
'uuid': '123',
'vm_state': vm_states.RESIZED,
'task_state': None
}]
all_instances = [
fake_instance.fake_instance_obj(None, **instance)
for instance in instances
]
image_cache_manager = imagecache.ImageCacheManager()
running = image_cache_manager._list_running_instances(
None, all_instances)
self.assertEqual(1, len(running['used_images']))
self.assertEqual((1, 0, ['instance-00000001']),
running['used_images']['1'])
self.assertEqual(
set([
'instance-00000001', '123', 'instance-00000001_resize',
'123_resize'
]), running['instance_names'])
self.assertEqual(1, len(running['image_popularity']))
self.assertEqual(1, running['image_popularity']['1'])
def test_numa_topology_filter_pass_set_limit(self):
self.flags(cpu_allocation_ratio=21)
self.flags(ram_allocation_ratio=1.3)
instance_topology = hardware.VirtNUMAInstanceTopology(cells=[
hardware.VirtNUMATopologyCell(0, set([1]), 512),
hardware.VirtNUMATopologyCell(1, set([3]), 512)
])
instance = fake_instance.fake_instance_obj(self.context)
instance.numa_topology = (
objects.InstanceNUMATopology.obj_from_topology(instance_topology))
filter_properties = {
'request_spec': {
'instance_properties':
jsonutils.to_primitive(obj_base.obj_to_primitive(instance))
}
}
host = fakes.FakeHostState('host1', 'node1',
{'numa_topology': fakes.NUMA_TOPOLOGY})
filt_cls = self.class_map['NUMATopologyFilter']()
self.assertTrue(filt_cls.host_passes(host, filter_properties))
limits_topology = hardware.VirtNUMALimitTopology.from_json(
host.limits['numa_topology'])
self.assertEqual(limits_topology.cells[0].cpu_limit, 42)
self.assertEqual(limits_topology.cells[1].cpu_limit, 42)
self.assertEqual(limits_topology.cells[0].memory_limit, 665)
self.assertEqual(limits_topology.cells[1].memory_limit, 665)
def setUp(self):
super(ServerPasswordTest, self).setUp()
fakes.stub_out_nw_api(self.stubs)
self.stubs.Set(
compute.api.API, 'get',
lambda self, ctxt, *a, **kw:
fake_instance.fake_instance_obj(
ctxt,
system_metadata={},
expected_attrs=['system_metadata']))
self.password = '******'
def fake_extract_password(instance):
return self.password
def fake_convert_password(context, password):
self.password = password
return {}
self.stubs.Set(password, 'extract_password', fake_extract_password)
self.stubs.Set(password, 'convert_password', fake_convert_password)
self.flags(
osapi_compute_extension=[
'nova.api.openstack.compute.contrib.select_extensions'],
osapi_compute_ext_list=['Server_password'])
def test_create_vm_invalid_guestid(self, mock_log_warn):
"""Ensure we warn when create_vm() fails after we passed an
unrecognised guestId
"""
found = [False]
def fake_log_warn(msg, values):
if not isinstance(values, dict):
return
if values.get('ostype') == 'invalid_os_type':
found[0] = True
mock_log_warn.side_effect = fake_log_warn
instance_values = {'id': 7, 'name': 'fake-name',
'uuid': uuidutils.generate_uuid(),
'vcpus': 2, 'memory_mb': 2048}
instance = fake_instance.fake_instance_obj(
context.RequestContext('fake', 'fake', is_admin=False),
**instance_values)
session = driver.VMwareAPISession()
config_spec = vm_util.get_vm_create_spec(
session.vim.client.factory,
instance, instance.name, 'fake-datastore', [],
os_type='invalid_os_type')
self.assertRaises(vexc.VMwareDriverException,
vm_util.create_vm, session, instance, 'folder',
config_spec, 'res-pool')
self.assertTrue(found[0])
def test_spawn(self, mock_sf, mock_pvifs, mock_adf, mock_cli,
mock_fg_bid, mock_node, mock_save):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid)
instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid)
fake_flavor = { 'ephemeral_gb': 0 }
mock_node.get.return_value = node
mock_node.validate.return_value = ironic_utils.get_test_validation()
mock_node.get_by_instance_uuid.return_value = node
mock_node.set_provision_state.return_value = mock.MagicMock()
mock_fg_bid.return_value = fake_flavor
node.provision_state = ironic_states.ACTIVE
mock_cli.return_value = FAKE_CLIENT
self.driver.spawn(self.ctx, instance, None, [], None)
mock_node.get.assert_called_once_with(node_uuid)
mock_node.validate.assert_called_once_with(node_uuid)
mock_fg_bid.assert_called_once_with(self.ctx,
instance['instance_type_id'])
mock_adf.assert_called_once_with(node, instance, None, fake_flavor)
mock_pvifs.assert_called_once_with(node, instance, None)
mock_sf.assert_called_once_with(instance, None)
mock_node.set_provision_state.assert_called_once_with(node_uuid, 'active')
self.assertIsNone(instance['default_ephemeral_device'])
self.assertFalse(mock_save.called)
def test__cleanup_deploy_fail(self, mock_update):
mock_update.side_effect = ironic_exception.HTTPBadRequest()
node = ironic_utils.get_test_node(driver='fake',
instance_uuid='fake-id')
instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid)
self.assertRaises(exception.InstanceTerminationFailure,
self.driver._cleanup_deploy, node, instance, None)
def test_macs_for_instance_http_not_found(self, mock_get):
mock_get.side_effect = ironic_exception.NotFound()
instance = fake_instance.fake_instance_obj(
self.ctx, node=uuidutils.generate_uuid())
result = self.driver.macs_for_instance(instance)
self.assertEqual([], result)
def test_spawn_node_trigger_deploy_fail2(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid)
instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid)
mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start()
mock_get.return_value = node
self.addCleanup(mock_get.stop)
mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start()
mock_validate.return_value = ironic_utils.get_test_validation()
self.addCleanup(mock_validate.stop)
mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start()
self.addCleanup(mock_fg_bid.stop)
mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start()
self.addCleanup(mock_pvifs.stop)
mock_sf = mock.patch.object(self.driver, '_start_firewall').start()
self.addCleanup(mock_sf.stop)
mock_cleanup_deploy = mock.patch.object(self.driver,
'_cleanup_deploy').start()
self.addCleanup(mock_cleanup_deploy.stop)
with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \
as mock_sps:
mock_sps.side_effect = ironic_exception.HTTPBadRequest
self.assertRaises(exception.InstanceDeployFailure,
self.driver.spawn, self.ctx, instance, None, [],
None)
mock_get.assert_called_once_with(node_uuid)
mock_validate.assert_called_once_with(node_uuid)
mock_fg_bid.assert_called_once_with(self.ctx,
instance['instance_type_id'])
mock_cleanup_deploy.assert_called_once_with(node, instance, None)
def test_unplug_vifs_no_network_info(self, mock_update):
instance = fake_instance.fake_instance_obj(self.ctx)
network_info = []
self.driver.unplug_vifs(instance, network_info)
# assert port.update() was not called
self.assertFalse(mock_update.called)
def _group_filter_with_filter_not_configured(self, policy):
self.flags(scheduler_default_filters=['f1', 'f2'])
sched = fakes.FakeFilterScheduler()
instance = fake_instance.fake_instance_obj(self.context,
params={'host': 'hostA'})
group = objects.InstanceGroup()
group.uuid = str(uuid.uuid4())
group.members = [instance.uuid]
group.policies = [policy]
filter_properties = {
'scheduler_hints': {
'group': group.uuid,
},
}
with contextlib.nested(
mock.patch.object(objects.InstanceGroup,
'get_by_uuid',
return_value=group),
mock.patch.object(objects.InstanceGroup,
'get_hosts',
return_value=['hostA']),
) as (get_group, get_hosts):
self.assertRaises(exception.NoValidHost,
sched._setup_instance_group, self.context,
filter_properties)
def test_migrate_disk_and_power_off(self, mock_check_flavor, mock_migrate_disk_files):
instance = fake_instance.fake_instance_obj(self.context)
flavor = mock.MagicMock()
network_info = mock.MagicMock()
disk_files = [mock.MagicMock()]
volume_drives = [mock.MagicMock()]
mock_get_vm_st_path = self._migrationops._vmutils.get_vm_storage_paths
mock_get_vm_st_path.return_value = (disk_files, volume_drives)
self._migrationops.migrate_disk_and_power_off(
self.context,
instance,
mock.sentinel.FAKE_DEST,
flavor,
network_info,
None,
self._FAKE_TIMEOUT,
self._FAKE_RETRY_INTERVAL,
)
mock_check_flavor.assert_called_once_with(instance, flavor)
self._migrationops._vmops.power_off.assert_called_once_with(
instance, self._FAKE_TIMEOUT, self._FAKE_RETRY_INTERVAL
)
mock_get_vm_st_path.assert_called_once_with(instance.name)
mock_migrate_disk_files.assert_called_once_with(instance.name, disk_files, mock.sentinel.FAKE_DEST)
self._migrationops._vmops.destroy.assert_called_once_with(instance, destroy_disks=False)
def test_macs_for_instance_http_not_found(self, mock_get):
mock_get.side_effect = ironic_exception.NotFound()
instance = fake_instance.fake_instance_obj(
self.ctx, node=uuidutils.generate_uuid())
result = self.driver.macs_for_instance(instance)
self.assertEqual([], result)
def _test_power_off(self, timeout):
instance = fake_instance.fake_instance_obj(self.context)
with mock.patch.object(self._vmops, '_set_vm_state') as mock_set_state:
self._vmops.power_off(instance, timeout)
mock_set_state.assert_called_once_with(
instance, constants.HYPERV_VM_STATE_DISABLED)
def test_deallocate_for_instance_with_expected_networks(self):
instance = fake_instance.fake_instance_obj(context.get_admin_context())
self._test_network_api('deallocate_for_instance',
rpc_method='call',
instance=instance,
requested_networks={},
version='1.11')
def test_spawn_disk_invalid_disk_size(self,
mock_get_datacenter_ref_and_name,
mock_get_datastore,
mock_get_res_pool_ref):
image = {
'id': 'c1c8ce3d-c2e0-4247-890c-ccf5cc1c004c',
'disk_format': 'vmdk',
'size': 999999999 * units.Gi,
}
self._context = context.RequestContext('fake_user', 'fake_project')
instance = fake_instance.fake_instance_obj(
self._context,
image_ref=nova.tests.image.fake.get_valid_image_id(),
uuid='fake_uuid',
root_gb=1,
node='respool-1001(MyResPoolName)')
ops = vmops.VMwareVMOps(mock.Mock(), mock.Mock(), mock.Mock())
self.assertRaises(exception.InstanceUnacceptable,
ops.spawn,
mock.Mock(),
instance,
image,
injected_files=[],
admin_password=None,
network_info=None,
block_device_info=None)
def test_spawn_node_trigger_deploy_fail2(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid)
instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid)
mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start()
mock_get.return_value = node
self.addCleanup(mock_get.stop)
mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start()
mock_validate.return_value = ironic_utils.get_test_validation()
self.addCleanup(mock_validate.stop)
mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start()
self.addCleanup(mock_fg_bid.stop)
mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start()
self.addCleanup(mock_pvifs.stop)
mock_sf = mock.patch.object(self.driver, '_start_firewall').start()
self.addCleanup(mock_sf.stop)
mock_cleanup_deploy = mock.patch.object(
self.driver, '_cleanup_deploy').start()
self.addCleanup(mock_cleanup_deploy.stop)
with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \
as mock_sps:
mock_sps.side_effect = ironic_exception.BadRequest
self.assertRaises(exception.InstanceDeployFailure,
self.driver.spawn,
self.ctx, instance, None, [], None)
mock_get.assert_called_once_with(node_uuid)
mock_validate.assert_called_once_with(node_uuid)
mock_fg_bid.assert_called_once_with(self.ctx,
instance['instance_type_id'])
mock_cleanup_deploy.assert_called_once_with(node, instance, None)
def setUp(self):
super(ServerPasswordTest, self).setUp()
fakes.stub_out_nw_api(self.stubs)
self.stubs.Set(
compute.api.API, 'get',
lambda self, ctxt, *a, **kw:
fake_instance.fake_instance_obj(
ctxt,
system_metadata={},
expected_attrs=['system_metadata']))
self.password = '******'
def fake_extract_password(instance):
return self.password
def fake_convert_password(context, password):
self.password = password
return {}
self.stubs.Set(password, 'extract_password', fake_extract_password)
self.stubs.Set(password, 'convert_password', fake_convert_password)
self.flags(
osapi_compute_extension=[
'nova.api.openstack.compute.contrib.select_extensions'],
osapi_compute_ext_list=['Server_password'])
def test_unplug_vifs(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(uuid=node_uuid)
port = ironic_utils.get_test_port()
mock_update = mock.patch.object(FAKE_CLIENT.port, 'update').start()
self.addCleanup(mock_update.stop)
mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start()
mock_get.return_value = node
self.addCleanup(mock_get.stop)
with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp:
mock_lp.return_value = [port]
instance = fake_instance.fake_instance_obj(self.ctx,
node=node_uuid)
expected_patch = [{'op': 'remove', 'path':
'/extra/vif_port_id'}]
self.driver.unplug_vifs(instance,
utils.get_test_network_info())
# asserts
mock_get.assert_called_once_with(node_uuid)
mock_lp.assert_called_once_with(node_uuid)
mock_update.assert_called_once_with(port.uuid, expected_patch)
def fake_compute_get(*args, **kwargs):
inst = fakes.stub_instance(1,
uuid=UUID3,
host="host-fake",
node="node-fake")
return fake_instance.fake_instance_obj(
args[1], expected_attrs=instance_obj.INSTANCE_DEFAULT_FIELDS, **inst)
def test_pxe_get_deploy_patch_fail_no_kr_id(self):
self.flavor = ironic_utils.get_test_flavor(extra_specs={})
node = ironic_utils.get_test_node(driver='pxe_fake')
instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid)
self.assertRaises(exception.InvalidParameterValue,
patcher.create(node).get_deploy_patch, instance,
self.image_meta, self.flavor)
def _group_filter_with_filter_not_configured(self, policy):
self.flags(scheduler_default_filters=['f1', 'f2'])
sched = fakes.FakeFilterScheduler()
instance = fake_instance.fake_instance_obj(self.context,
params={'host': 'hostA'})
group = objects.InstanceGroup()
group.uuid = str(uuid.uuid4())
group.members = [instance.uuid]
group.policies = [policy]
filter_properties = {
'scheduler_hints': {
'group': group.uuid,
},
}
with contextlib.nested(
mock.patch.object(objects.InstanceGroup, 'get_by_uuid',
return_value=group),
mock.patch.object(objects.InstanceGroup, 'get_hosts',
return_value=['hostA']),
) as (get_group, get_hosts):
self.assertRaises(exception.NoValidHost,
sched._setup_instance_group, self.context,
filter_properties)
def test__cleanup_deploy_good(self, mock_update):
node = ironic_utils.get_test_node(driver='fake',
instance_uuid='fake-id')
instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid)
self.driver._cleanup_deploy(node, instance, None)
expected_patch = [{'path': '/instance_uuid', 'op': 'remove'}]
mock_update.assert_called_once_with(node.uuid, expected_patch)
def test_spawn(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = get_test_node(driver='fake', uuid=node_uuid)
instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid)
fake_flavor = 'fake-flavor'
mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start()
mock_get.return_value = node
self.addCleanup(mock_get.stop)
mock_fg = mock.patch.object(self.driver.virtapi, 'flavor_get').start()
mock_fg.return_value = fake_flavor
self.addCleanup(mock_fg.stop)
mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start()
mock_validate.return_value = get_test_validation()
self.addCleanup(mock_validate.stop)
mock_adf = mock.patch.object(self.driver, '_add_driver_fields').start()
self.addCleanup(mock_adf.stop)
mock_pvifs = mock.patch.object(self.driver, 'plug_vifs').start()
self.addCleanup(mock_pvifs.stop)
mock_sf = mock.patch.object(self.driver, '_start_firewall').start()
self.addCleanup(mock_pvifs.stop)
with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \
as mock_sps:
self.driver.spawn(self.ctx, instance, None, [], None)
mock_get.assert_called_once_with(node_uuid)
mock_validate.assert_called_once_with(node_uuid)
mock_fg.assert_called_once_with(self.ctx,
instance['instance_type_id'])
mock_adf.assert_called_once_with(node, instance, None, fake_flavor)
mock_pvifs.assert_called_once_with(instance, None)
mock_sf.assert_called_once_with(instance, None)
mock_sps.assert_called_once_with(node_uuid, 'active')
def test_spawn_node_prepare_for_deploy_fail(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid)
instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid)
mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start()
mock_get.return_value = node
self.addCleanup(mock_get.stop)
mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start()
mock_validate.return_value = ironic_utils.get_test_validation()
self.addCleanup(mock_validate.stop)
mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start()
self.addCleanup(mock_fg_bid.stop)
mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start()
self.addCleanup(mock_pvifs.stop)
mock_cleanup_deploy = mock.patch.object(self.driver,
'_cleanup_deploy').start()
self.addCleanup(mock_cleanup_deploy.stop)
class TestException(Exception):
pass
with mock.patch.object(self.driver, '_start_firewall') as mock_sf:
mock_sf.side_effect = TestException()
self.assertRaises(TestException, self.driver.spawn, self.ctx,
instance, None, [], None)
mock_get.assert_called_once_with(node_uuid)
mock_validate.assert_called_once_with(node_uuid)
mock_fg_bid.assert_called_once_with(self.ctx,
instance['instance_type_id'])
mock_cleanup_deploy.assert_called_with(node, instance, None)
def test_spawn_setting_instance_uuid_fail(self):
instance = fake_instance.fake_instance_obj(self.ctx,
node=uuidutils.generate_uuid())
with mock.patch.object(FAKE_CLIENT.node, 'update') as mock_update:
mock_update.side_effect = ironic_exception.HTTPBadRequest()
self.assertRaises(exception.NovaException, self.driver.spawn,
self.ctx, instance, None, [], None)
def test__plug_vifs(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(uuid=node_uuid)
port = ironic_utils.get_test_port()
mock_uvifs = mock.patch.object(self.driver, '_unplug_vifs').start()
self.addCleanup(mock_uvifs.stop)
mock_port_udt = mock.patch.object(FAKE_CLIENT.port, 'update').start()
self.addCleanup(mock_port_udt.stop)
with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp:
mock_lp.return_value = [port]
instance = fake_instance.fake_instance_obj(self.ctx,
node=node_uuid)
network_info = utils.get_test_network_info()
port_id = unicode(network_info[0]['id'])
expected_patch = [{
'op': 'add',
'path': '/extra/vif_port_id',
'value': port_id
}]
self.driver._plug_vifs(node, instance, network_info)
# asserts
mock_uvifs.assert_called_once_with(node, instance, network_info)
mock_lp.assert_called_once_with(node_uuid)
mock_port_udt.assert_called_with(port.uuid, expected_patch)
def test_spawn_node_driver_validation_fail(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = get_test_node(driver='fake', uuid=node_uuid)
instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid)
fake_flavor = 'fake-flavor'
mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start()
mock_get.return_value = node
self.addCleanup(mock_get.stop)
mock_fg = mock.patch.object(self.driver.virtapi, 'flavor_get').start()
mock_fg.return_value = fake_flavor
self.addCleanup(mock_fg.stop)
mock_adf = mock.patch.object(self.driver, '_add_driver_fields').start()
self.addCleanup(mock_adf.stop)
with mock.patch.object(FAKE_CLIENT.node, 'validate') as mock_validate:
mock_validate.return_value = get_test_validation(power=False,
deploy=False)
self.assertRaises(exception.ValidationError, self.driver.spawn,
self.ctx, instance, None, [], None)
mock_get.assert_called_once_with(node_uuid)
mock_validate.assert_called_once_with(node_uuid)
mock_fg.assert_called_once_with(self.ctx,
instance['instance_type_id'])
mock_adf.assert_called_once_with(node, instance, None, fake_flavor)
def fake_compute_get(*args, **kwargs):
inst = fakes.stub_instance(1,
uuid=UUID3,
task_state="kayaking",
vm_state="slightly crunchy",
power_state=1)
return fake_instance.fake_instance_obj(args[1], **inst)
def test_spawn_node_trigger_deploy_fail(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = get_test_node(driver='fake', uuid=node_uuid)
instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid)
mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start()
mock_get.return_value = node
self.addCleanup(mock_get.stop)
mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start()
mock_validate.return_value = get_test_validation()
self.addCleanup(mock_validate.stop)
mock_fg = mock.patch.object(self.driver.virtapi, 'flavor_get').start()
self.addCleanup(mock_fg.stop)
mock_pvifs = mock.patch.object(self.driver, 'plug_vifs').start()
self.addCleanup(mock_pvifs.stop)
mock_sf = mock.patch.object(self.driver, '_start_firewall').start()
self.addCleanup(mock_sf.stop)
mock_upvifs = mock.patch.object(self.driver, 'unplug_vifs').start()
self.addCleanup(mock_upvifs.stop)
mock_stof = mock.patch.object(self.driver, '_stop_firewall').start()
self.addCleanup(mock_stof.stop)
with mock.patch.object(FAKE_CLIENT.node, 'set_provision_state') \
as mock_sps:
mock_sps.side_effect = ironic_driver.MaximumRetriesReached
self.assertRaises(exception.NovaException, self.driver.spawn,
self.ctx, instance, None, [], None)
mock_get.assert_called_once_with(node_uuid)
mock_validate.assert_called_once_with(node_uuid)
mock_fg.assert_called_once_with(self.ctx,
instance['instance_type_id'])
mock_upvifs.assert_called_once_with(instance, None)
mock_stof.assert_called_once_with(instance, None)
def test_group_details_in_filter_properties(self):
sched = fakes.FakeFilterScheduler()
instance = fake_instance.fake_instance_obj(self.context,
params={'host': 'hostA'})
group = instance_group_obj.InstanceGroup()
group.uuid = str(uuid.uuid4())
group.members = [instance.uuid]
group.policies = ['anti-affinity']
filter_properties = {
'scheduler_hints': {
'group': group.uuid,
},
}
with contextlib.nested(
mock.patch.object(instance_group_obj.InstanceGroup, 'get_by_uuid',
return_value=group),
mock.patch.object(instance_group_obj.InstanceGroup, 'get_hosts',
return_value=['hostA']),
) as (get_group, get_hosts):
update_group_hosts = sched._setup_instance_group(self.context,
filter_properties)
self.assertTrue(update_group_hosts)
self.assertEqual(set(['hostA']), filter_properties['group_hosts'])
self.assertEqual(['anti-affinity'],
filter_properties['group_policies'])
def test_power_off(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
instance = fake_instance.fake_instance_obj(self.ctx,
node=node_uuid)
with mock.patch.object(FAKE_CLIENT.node, 'set_power_state') as mock_sp:
self.driver.power_off(instance)
mock_sp.assert_called_once_with(node_uuid, 'off')
def test_rebuild_failures(self, mock_save, mock_get, mock_driver_fields,
mock_fg_bid, mock_set_pstate):
node_uuid = uuidutils.generate_uuid()
instance_uuid = uuidutils.generate_uuid()
node = ironic_utils.get_test_node(uuid=node_uuid,
instance_uuid=instance_uuid,
instance_type_id=5)
mock_get.return_value = node
image_meta = ironic_utils.get_test_image_meta()
flavor_id = 5
flavor = {'id': flavor_id, 'name': 'baremetal'}
mock_fg_bid.return_value = flavor
instance = fake_instance.fake_instance_obj(self.ctx,
uuid=instance_uuid,
node=node_uuid,
instance_type_id=flavor_id)
exceptions = [
exception.NovaException(),
ironic_exception.BadRequest(),
ironic_exception.InternalServerError(),
]
for e in exceptions:
mock_set_pstate.side_effect = e
self.assertRaises(exception.InstanceDeployFailure,
self.driver.rebuild,
context=self.ctx, instance=instance, image_meta=image_meta,
injected_files=None, admin_password=None, bdms=None,
detach_block_devices=None, attach_block_devices=None)
def test_plug_vifs_no_network_info(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = get_test_node(uuid=node_uuid)
port = get_test_port()
mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start()
mock_get.return_value = node
self.addCleanup(mock_get.stop)
mock_uvifs = mock.patch.object(self.driver, 'unplug_vifs').start()
self.addCleanup(mock_uvifs.stop)
mock_update = mock.patch.object(FAKE_CLIENT.port, 'update').start()
self.addCleanup(mock_update.stop)
with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp:
mock_lp.return_value = [port]
instance = fake_instance.fake_instance_obj(self.ctx,
node=node_uuid)
network_info = []
self.driver.plug_vifs(instance, network_info)
# asserts
mock_uvifs.assert_called_once_with(instance, network_info)
mock_get.assert_called_once_with(node_uuid)
mock_lp.assert_called_once_with(node_uuid)
# assert port.update() was not called
assert not mock_update.called
def test_unplug_vifs_no_network_info(self, mock_update):
instance = fake_instance.fake_instance_obj(self.ctx)
network_info = []
self.driver.unplug_vifs(instance, network_info)
# assert port.update() was not called
self.assertFalse(mock_update.called)
def test_blank_attach_volume(self):
no_blank_volume = self.blank_bdm.copy()
no_blank_volume['volume_id'] = None
test_bdm = self.driver_classes['blank'](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 contextlib.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',
'')
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_deallocate_for_instance(self):
instance = fake_instance.fake_instance_obj(context.get_admin_context())
self._test_network_api('deallocate_for_instance',
rpc_method='call',
requested_networks=self.DefaultArg(None),
instance=instance,
version='1.11')
def test_spawn_disk_invalid_disk_size(self,
mock_get_datacenter_ref_and_name,
mock_get_datastore,
mock_get_res_pool_ref):
image = {
'id': 'c1c8ce3d-c2e0-4247-890c-ccf5cc1c004c',
'disk_format': 'vmdk',
'size': 999999999 * units.Gi,
}
self._context = context.RequestContext('fake_user', 'fake_project')
instance = fake_instance.fake_instance_obj(self._context,
image_ref=nova.tests.image.fake.get_valid_image_id(),
uuid='fake_uuid',
root_gb=1,
node='respool-1001(MyResPoolName)'
)
ops = vmops.VMwareVMOps(mock.Mock(), mock.Mock(), mock.Mock())
self.assertRaises(exception.InstanceUnacceptable,
ops.spawn,
mock.Mock(),
instance,
image,
injected_files=[],
admin_password=None,
network_info=None,
block_device_info=None)
def test_instance_exists(self, mock_call):
instance_uuid = 'fake-uuid'
instance = fake_instance.fake_instance_obj(self.ctx,
uuid=instance_uuid)
self.assertTrue(self.driver.instance_exists(instance))
mock_call.assert_called_once_with('node.get_by_instance_uuid',
instance_uuid)
def fake_compute_api_get(self, context, instance_id, **kwargs):
want_objects = kwargs.get('want_objects')
if want_objects:
return fake_instance.fake_instance_obj(
context, **{'uuid': instance_id})
else:
return {'uuid': instance_id}
def test_spawn_node_prepare_for_deploy_fail(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid)
instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid)
mock_get = mock.patch.object(FAKE_CLIENT.node, 'get').start()
mock_get.return_value = node
self.addCleanup(mock_get.stop)
mock_validate = mock.patch.object(FAKE_CLIENT.node, 'validate').start()
mock_validate.return_value = ironic_utils.get_test_validation()
self.addCleanup(mock_validate.stop)
mock_fg_bid = mock.patch.object(flavor_obj, 'get_by_id').start()
self.addCleanup(mock_fg_bid.stop)
mock_pvifs = mock.patch.object(self.driver, '_plug_vifs').start()
self.addCleanup(mock_pvifs.stop)
mock_cleanup_deploy = mock.patch.object(
self.driver, '_cleanup_deploy').start()
self.addCleanup(mock_cleanup_deploy.stop)
class TestException(Exception):
pass
with mock.patch.object(self.driver, '_start_firewall') as mock_sf:
mock_sf.side_effect = TestException()
self.assertRaises(TestException, self.driver.spawn,
self.ctx, instance, None, [], None)
mock_get.assert_called_once_with(node_uuid)
mock_validate.assert_called_once_with(node_uuid)
mock_fg_bid.assert_called_once_with(self.ctx,
instance['instance_type_id'])
mock_cleanup_deploy.assert_called_with(node, instance, None)
def test_rebuild_instance(self, _record_action_start,
_checks_for_create_and_rebuild,
_check_auto_disk_config, _get_image,
bdm_get_by_instance_uuid, get_flavor,
instance_save):
orig_system_metadata = {}
instance = fake_instance.fake_instance_obj(
self.context,
vm_state=vm_states.ACTIVE,
cell_name='fake-cell',
launched_at=timeutils.utcnow(),
system_metadata=orig_system_metadata,
expected_attrs=['system_metadata'])
get_flavor.return_value = ''
image_href = ''
image = {
"min_ram": 10,
"min_disk": 1,
"properties": {
'architecture': 'x86_64'
}
}
admin_pass = ''
files_to_inject = []
bdms = []
_get_image.return_value = (None, image)
bdm_get_by_instance_uuid.return_value = bdms
self.compute_api.rebuild(self.context, instance, image_href,
admin_pass, files_to_inject)
self.assertTrue(self.cells_rpcapi.rebuild_instance.called)
def test_reboot(self, mock_val_inst, mock_set_power):
node = ironic_utils.get_test_node()
mock_val_inst.return_value = node
instance = fake_instance.fake_instance_obj(self.ctx,
node=node.uuid)
self.driver.reboot(self.ctx, instance, None, None)
mock_set_power.assert_called_once_with(node.uuid, 'reboot')
def test_blank_attach_volume(self):
no_blank_volume = self.blank_bdm.copy()
no_blank_volume['volume_id'] = None
test_bdm = self.driver_classes['blank'](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 contextlib.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',
'')
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__plug_vifs_count_mismatch(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(uuid=node_uuid)
port = ironic_utils.get_test_port()
mock_uvifs = mock.patch.object(self.driver, '_unplug_vifs').start()
self.addCleanup(mock_uvifs.stop)
mock_port_udt = mock.patch.object(FAKE_CLIENT.port, 'update').start()
self.addCleanup(mock_port_udt.stop)
with mock.patch.object(FAKE_CLIENT.node, 'list_ports') as mock_lp:
mock_lp.return_value = [port]
instance = fake_instance.fake_instance_obj(self.ctx,
node=node_uuid)
# len(network_info) > len(ports)
network_info = (utils.get_test_network_info() +
utils.get_test_network_info())
self.assertRaises(exception.NovaException,
self.driver._plug_vifs, node, instance,
network_info)
# asserts
mock_uvifs.assert_called_once_with(node, instance, network_info)
mock_lp.assert_called_once_with(node_uuid)
# assert port.update() was not called
assert not mock_port_udt.called
def fake_compute_api_get(self, context, instance_id, **kwargs):
want_objects = kwargs.get('want_objects')
if want_objects:
return fake_instance.fake_instance_obj(context,
**{'uuid': instance_id})
else:
return {'uuid': instance_id}
def _test_power_off(self, timeout):
instance = fake_instance.fake_instance_obj(self.context)
with mock.patch.object(self._vmops, '_set_vm_state') as mock_set_state:
self._vmops.power_off(instance, timeout)
mock_set_state.assert_called_once_with(
instance, constants.HYPERV_VM_STATE_DISABLED)
def test_get_info(self):
instance_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
properties = {'memory_mb': 512, 'cpus': 2}
power_state = ironic_states.POWER_ON
node = ironic_utils.get_test_node(instance_uuid=instance_uuid,
properties=properties,
power_state=power_state)
with mock.patch.object(FAKE_CLIENT.node, 'get_by_instance_uuid') \
as mock_gbiu:
mock_gbiu.return_value = node
# ironic_states.POWER_ON should me be mapped to
# nova_states.RUNNING
expected = {
'state': nova_states.RUNNING,
'max_mem': properties['memory_mb'],
'mem': properties['memory_mb'],
'num_cpu': properties['cpus'],
'cpu_time': 0
}
instance = fake_instance.fake_instance_obj('fake-context',
uuid=instance_uuid)
result = self.driver.get_info(instance)
self.assertEqual(expected, result)
def test_pxe_get_deploy_patch(self):
node = ironic_utils.get_test_node(driver='pxe_fake')
instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid)
extra_specs = self.flavor['extra_specs']
expected = [{
'path': '/driver_info/pxe_deploy_kernel',
'value': extra_specs['baremetal:deploy_kernel_id'],
'op': 'add'
}, {
'path': '/driver_info/pxe_deploy_ramdisk',
'value': extra_specs['baremetal:deploy_ramdisk_id'],
'op': 'add'
}, {
'path': '/driver_info/pxe_image_source',
'value': self.image_meta['id'],
'op': 'add'
}, {
'path': '/driver_info/pxe_root_gb',
'value': str(instance['root_gb']),
'op': 'add'
}, {
'path': '/driver_info/pxe_swap_mb',
'value': str(self.flavor['swap']),
'op': 'add'
}]
patch = patcher.create(node).get_deploy_patch(instance,
self.image_meta,
self.flavor)
self.assertEqual(sorted(expected), sorted(patch))
def test__add_driver_fields_fail(self, mock_update):
mock_update.side_effect = ironic_exception.HTTPBadRequest()
node = ironic_utils.get_test_node(driver='fake')
instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid)
self.assertRaises(exception.InstanceDeployFailure,
self.driver._add_driver_fields, node, instance, None,
None)
def test_group_details_in_filter_properties(self):
sched = fakes.FakeFilterScheduler()
instance = fake_instance.fake_instance_obj(self.context,
params={'host': 'hostA'})
group = instance_group_obj.InstanceGroup()
group.uuid = str(uuid.uuid4())
group.members = [instance.uuid]
group.policies = ['anti-affinity']
filter_properties = {
'scheduler_hints': {
'group': group.uuid,
},
}
with contextlib.nested(
mock.patch.object(instance_group_obj.InstanceGroup,
'get_by_uuid',
return_value=group),
mock.patch.object(instance_group_obj.InstanceGroup,
'get_hosts',
return_value=['hostA']),
) as (get_group, get_hosts):
update_group_hosts = sched._setup_instance_group(
self.context, filter_properties)
self.assertTrue(update_group_hosts)
self.assertEqual(set(['hostA']), filter_properties['group_hosts'])
self.assertEqual(['anti-affinity'],
filter_properties['group_policies'])
def test__cleanup_deploy_good(self, mock_update, mock_flavor):
mock_flavor.return_value = ironic_utils.get_test_flavor(extra_specs={})
node = ironic_utils.get_test_node(driver="fake", instance_uuid="fake-id")
instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid)
self.driver._cleanup_deploy(node, instance, None)
expected_patch = [{"path": "/instance_uuid", "op": "remove"}]
mock_update.assert_called_once_with(node.uuid, expected_patch)
