def test__node_resources_unavailable(self):
node_dicts = [
# a node in maintenance /w no instance and power OFF
{
'uuid': uuidutils.generate_uuid(),
'maintenance': True,
'power_state': ironic_states.POWER_OFF
},
# a node in maintenance /w no instance and ERROR power state
{
'uuid': uuidutils.generate_uuid(),
'maintenance': True,
'power_state': ironic_states.ERROR
},
# a node not in maintenance /w no instance and bad power state
{
'uuid': uuidutils.generate_uuid(),
'power_state': ironic_states.NOSTATE
},
]
for n in node_dicts:
node = ironic_utils.get_test_node(**n)
self.assertTrue(self.driver._node_resources_unavailable(node))
avail_node = ironic_utils.get_test_node(
power_state=ironic_states.POWER_OFF)
self.assertFalse(self.driver._node_resources_unavailable(avail_node))
def test__node_resources_unavailable(self):
node_dicts = [
# a node in maintenance /w no instance and power OFF
{"uuid": uuidutils.generate_uuid(), "maintenance": True, "power_state": ironic_states.POWER_OFF},
# a node in maintenance /w no instance and ERROR power state
{"uuid": uuidutils.generate_uuid(), "maintenance": True, "power_state": ironic_states.ERROR},
# a node not in maintenance /w no instance and bad power state
{"uuid": uuidutils.generate_uuid(), "power_state": ironic_states.NOSTATE},
]
for n in node_dicts:
node = ironic_utils.get_test_node(**n)
self.assertTrue(self.driver._node_resources_unavailable(node))
avail_node = ironic_utils.get_test_node(power_state=ironic_states.POWER_OFF)
self.assertFalse(self.driver._node_resources_unavailable(avail_node))
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)
def test_spawn(
self, mock_sf, mock_pvifs, mock_adf, mock_wait_active, mock_fg_bid, mock_node, mock_looping, 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
fake_looping_call = FakeLoopingCall()
mock_looping.return_value = fake_looping_call
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)
mock_looping.assert_called_once_with(mock_wait_active, FAKE_CLIENT_WRAPPER, instance)
fake_looping_call.start.assert_called_once_with(interval=CONF.ironic.api_retry_interval)
fake_looping_call.wait.assert_called_once()
def test__node_resource_malformed_capabilities(self):
props = _get_properties()
props["capabilities"] = "test:capability,:no_key,no_val:"
node = ironic_utils.get_test_node(properties=props)
result = self.driver._node_resource(node)
stats = jsonutils.loads(result["stats"])
self.assertEqual("capability", stats.get("test"))
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_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 test_pxe_get_cleanup_patch(self):
driver_info = {'pxe_image_source': 'fake-image-id',
'pxe_deploy_kernel': 'fake-kernel-id',
'pxe_deploy_ramdisk': 'fake-ramdisk-id',
'pxe_root_gb': '1024',
'pxe_swap_mb': '512',
'pxe_preserve_ephemeral': True,
'pxe_ephemeral_format': 'fake-format'}
node = ironic_utils.get_test_node(driver='pxe_fake',
driver_info=driver_info)
instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid)
patch = patcher.create(node).get_cleanup_patch(instance, None)
expected = [{'path': '/driver_info/pxe_image_source',
'op': 'remove'},
{'path': '/driver_info/pxe_deploy_kernel',
'op': 'remove'},
{'path': '/driver_info/pxe_deploy_ramdisk',
'op': 'remove'},
{'path': '/driver_info/pxe_root_gb',
'op': 'remove'},
{'path': '/driver_info/pxe_swap_mb',
'op': 'remove'},
{'path': '/driver_info/pxe_preserve_ephemeral',
'op': 'remove'},
{'path': '/driver_info/pxe_ephemeral_format',
'op': 'remove'}]
self.assertEqual(sorted(expected), sorted(patch))
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_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 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__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__node_resource_no_instance_uuid(self):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
cpus = 2
mem = 512
disk = 10
arch = 'x86_64'
properties = {
'cpus': cpus,
'memory_mb': mem,
'local_gb': disk,
'cpu_arch': arch
}
node = ironic_utils.get_test_node(uuid=node_uuid,
instance_uuid=None,
properties=properties)
result = self.driver._node_resource(node)
self.assertEqual(cpus, result['vcpus'])
self.assertEqual(0, result['vcpus_used'])
self.assertEqual(mem, result['memory_mb'])
self.assertEqual(0, result['memory_mb_used'])
self.assertEqual(disk, result['local_gb'])
self.assertEqual(0, result['local_gb_used'])
self.assertEqual(node_uuid, result['hypervisor_hostname'])
self.assertEqual(
'{"cpu_arch": "x86_64", "ironic_driver": "'
'ironic.nova.virt.ironic.driver.IronicDriver", '
'"test_spec": "test_value"}', result['stats'])
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_get_available_nodes(self, mock_list):
node_dicts = [
# a node in maintenance /w no instance and power OFF
{
'uuid': uuidutils.generate_uuid(),
'maintenance': True,
'power_state': ironic_states.POWER_OFF
},
# a node /w instance and power ON
{
'uuid': uuidutils.generate_uuid(),
'instance_uuid': uuidutils.generate_uuid(),
'power_state': ironic_states.POWER_ON
},
# a node not in maintenance /w no instance and bad power state
{
'uuid': uuidutils.generate_uuid(),
'power_state': ironic_states.ERROR
},
]
nodes = [ironic_utils.get_test_node(**n) for n in node_dicts]
mock_list.return_value = nodes
available_nodes = self.driver.get_available_nodes()
expected_uuids = [n['uuid'] for n in node_dicts]
self.assertEqual(sorted(expected_uuids), sorted(available_nodes))
def test__node_resource_unavailable_node_res(self, mock_res_unavail):
mock_res_unavail.return_value = True
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
cpus = 2
mem = 512
disk = 10
arch = 'x86_64'
properties = {'cpus': cpus, 'memory_mb': mem,
'local_gb': disk, 'cpu_arch': arch}
node = ironic_utils.get_test_node(uuid=node_uuid,
instance_uuid=None,
properties=properties)
result = self.driver._node_resource(node)
self.assertEqual(0, result['vcpus'])
self.assertEqual(0, result['vcpus_used'])
self.assertEqual(0, result['memory_mb'])
self.assertEqual(0, result['memory_mb_used'])
self.assertEqual(0, result['local_gb'])
self.assertEqual(0, result['local_gb_used'])
self.assertEqual(node_uuid, result['hypervisor_hostname'])
self.assertEqual('{"cpu_arch": "x86_64", "ironic_driver": "'
'ironic.nova.virt.ironic.driver.IronicDriver", '
'"test_spec": "test_value"}',
result['stats'])
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__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_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 test_node_is_available(self, mock_get):
no_guid = None
any_guid = uuidutils.generate_uuid()
in_maintenance = True
is_available = True
not_in_maintenance = False
not_available = False
power_off = ironic_states.POWER_OFF
not_power_off = ironic_states.POWER_ON
testing_set = {
(no_guid, not_in_maintenance, power_off): is_available,
(no_guid, not_in_maintenance, not_power_off): not_available,
(no_guid, in_maintenance, power_off): not_available,
(no_guid, in_maintenance, not_power_off): not_available,
(any_guid, not_in_maintenance, power_off): not_available,
(any_guid, not_in_maintenance, not_power_off): not_available,
(any_guid, in_maintenance, power_off): not_available,
(any_guid, in_maintenance, not_power_off): not_available
}
for key in testing_set.keys():
node = ironic_utils.get_test_node(instance_uuid=key[0],
maintenance=key[1],
power_state=key[2])
mock_get.return_value = node
expected = testing_set[key]
observed = self.driver.node_is_available("dummy_nodename")
self.assertEqual(expected, observed)
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_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 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__node_resource_malformed_capabilities(self):
props = _get_properties()
props['capabilities'] = 'test:capability,:no_key,no_val:'
node = ironic_utils.get_test_node(properties=props)
result = self.driver._node_resource(node)
stats = jsonutils.loads(result['stats'])
self.assertEqual('capability', stats.get('test'))
def test__node_resource_malformed_capabilities(self):
props = _get_properties()
props['capabilities'] = 'test:capability,:no_key,no_val:'
node = ironic_utils.get_test_node(properties=props)
result = self.driver._node_resource(node)
stats = jsonutils.loads(result['stats'])
self.assertEqual('capability', stats.get('test'))
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_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__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_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__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__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__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_node_is_available(self, mock_get):
no_guid = None
any_guid = uuidutils.generate_uuid()
in_maintenance = True
is_available = True
not_in_maintenance = False
not_available = False
power_off = ironic_states.POWER_OFF
not_power_off = ironic_states.POWER_ON
testing_set = {(no_guid, not_in_maintenance, power_off):is_available,
(no_guid, not_in_maintenance, not_power_off):not_available,
(no_guid, in_maintenance, power_off):not_available,
(no_guid, in_maintenance, not_power_off):not_available,
(any_guid, not_in_maintenance, power_off):not_available,
(any_guid, not_in_maintenance, not_power_off):not_available,
(any_guid, in_maintenance, power_off):not_available,
(any_guid, in_maintenance, not_power_off):not_available}
for key in testing_set.keys():
node = ironic_utils.get_test_node(instance_uuid=key[0],
maintenance=key[1],
power_state=key[2])
mock_get.return_value = node
expected = testing_set[key]
observed = self.driver.node_is_available("dummy_nodename")
self.assertEqual(expected, observed)
def test_reboot(self, mock_val_inst, mock_set_power, mock_cli):
node = ironic_utils.get_test_node()
mock_val_inst.return_value = node
instance = fake_instance.fake_instance_obj(self.ctx,
node=node.uuid)
mock_cli.return_value = FAKE_CLIENT
self.driver.reboot(self.ctx, instance, None, None)
mock_set_power.assert_called_once_with(node.uuid, 'reboot')
def test__node_resource_exposes_capabilities(self):
props = _get_properties()
props["capabilities"] = "test:capability"
node = ironic_utils.get_test_node(properties=props)
result = self.driver._node_resource(node)
stats = jsonutils.loads(result["stats"])
self.assertIsNone(stats.get("capabilities"))
self.assertEqual("capability", stats.get("test"))
def test__node_resource_exposes_capabilities(self):
props = _get_properties()
props['capabilities'] = 'test:capability'
node = ironic_utils.get_test_node(properties=props)
result = self.driver._node_resource(node)
stats = jsonutils.loads(result['stats'])
self.assertIsNone(stats.get('capabilities'))
self.assertEqual('capability', stats.get('test'))
def test_list_instances(self):
num_nodes = 2
nodes = []
for n in range(num_nodes):
nodes.append(ironic_utils.get_test_node(
instance_uuid=uuidutils.generate_uuid()))
# append a node w/o instance_uuid which shouldn't be listed
nodes.append(ironic_utils.get_test_node(instance_uuid=None))
with mock.patch.object(cw.IronicClientWrapper, 'call') as mock_list:
mock_list.return_value = nodes
expected = [n for n in nodes if n.instance_uuid]
instances = self.driver.list_instances()
mock_list.assert_called_with("node.list")
self.assertEqual(sorted(expected), sorted(instances))
self.assertEqual(num_nodes, len(instances))
def test_node_is_available(self, mock_get):
node = ironic_utils.get_test_node()
mock_get.return_value = node
self.assertTrue(self.driver.node_is_available(node.uuid))
mock_get.assert_called_with(node.uuid)
mock_get.side_effect = ironic_exception.NotFound
self.assertFalse(self.driver.node_is_available(node.uuid))
def test_get_available_resource(self, mock_nr, mock_get):
node = ironic_utils.get_test_node()
fake_resource = 'fake-resource'
mock_get.return_value = node
mock_nr.return_value = fake_resource
result = self.driver.get_available_resource(node.uuid)
self.assertEqual(fake_resource, result)
mock_nr.assert_called_once_with(node)
def test__node_resource_exposes_capabilities(self):
props = _get_properties()
props['capabilities'] = 'test:capability'
node = ironic_utils.get_test_node(properties=props)
result = self.driver._node_resource(node)
stats = jsonutils.loads(result['stats'])
self.assertIsNone(stats.get('capabilities'))
self.assertEqual('capability', stats.get('test'))
def test__cleanup_deploy_fail(self, mock_update):
mock_update.side_effect = ironic_exception.BadRequest()
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__add_driver_fields_fail(self, mock_update):
mock_update.side_effect = ironic_exception.BadRequest()
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_node_is_available(self, mock_get):
node = ironic_utils.get_test_node()
mock_get.return_value = node
self.assertTrue(self.driver.node_is_available(node.uuid))
mock_get.assert_called_with(node.uuid)
mock_get.side_effect = ironic_exception.NotFound
self.assertFalse(self.driver.node_is_available(node.uuid))
def test__add_driver_fields_good(self, mock_update):
node = ironic_utils.get_test_node(driver='fake')
instance = fake_instance.fake_instance_obj(self.ctx,
node=node.uuid)
self.driver._add_driver_fields(node, instance, None, None)
expected_patch = [{'path': '/instance_uuid', 'op': 'add',
'value': instance['uuid']}]
mock_update.assert_called_once_with(node.uuid, expected_patch)
def test_pxe_get_cleanup_patch_no_flavor_kernel_ramdisk_ids(self):
self.flavor = ironic_utils.get_test_flavor(extra_specs={})
node = ironic_utils.get_test_node(driver='pxe_fake')
patch = patcher.create(node).get_cleanup_patch(self.instance, None,
self.flavor)
# If there's no extra_specs patch should be exactly like a
# generic patch
self.assertEqual(self._expected_cleanup_patch, patch)
def test_pxe_get_deploy_patch_no_flavor_kernel_ramdisk_ids(self):
flavor = ironic_utils.get_test_flavor(extra_specs={})
node = ironic_utils.get_test_node(driver='pxe_fake')
patch = patcher.create(node).get_deploy_patch(
self.instance, self.image_meta, flavor)
# If there's no extra_specs patch should be exactly like a
# generic patch
self.assertEqual(sorted(self._expected_deploy_patch), sorted(patch))
def test_get_available_resource(self, mock_nr, mock_get):
node = ironic_utils.get_test_node()
fake_resource = 'fake-resource'
mock_get.return_value = node
mock_nr.return_value = fake_resource
result = self.driver.get_available_resource(node.uuid)
self.assertEqual(fake_resource, result)
mock_nr.assert_called_once_with(node)
def test__add_driver_fields_good(self, mock_update, mock_cli):
node = ironic_utils.get_test_node(driver='fake')
instance = fake_instance.fake_instance_obj(self.ctx,
node=node.uuid)
mock_cli.return_value = FAKE_CLIENT
self.driver._add_driver_fields(node, instance, None, None)
expected_patch = [{'path': '/instance_uuid', 'op': 'add',
'value': instance['uuid']}]
mock_update.assert_called_once_with(node.uuid, expected_patch)
def test_macs_for_instance(self, mock_node):
node = ironic_utils.get_test_node()
port = ironic_utils.get_test_port()
mock_node.get.return_value = node
mock_node.list_ports.return_value = [port]
instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid)
result = self.driver.macs_for_instance(instance)
self.assertEqual([port.address], result)
mock_node.list_ports.assert_called_once_with(node.uuid)
def test_get_available_nodes(self):
num_nodes = 2
nodes = []
for n in range(num_nodes):
nodes.append(ironic_utils.get_test_node(
uuid=uuidutils.generate_uuid(),
power_state=ironic_states.POWER_OFF))
# append a node w/o power_state which shouldn't be listed
nodes.append(ironic_utils.get_test_node(power_state=None))
with mock.patch.object(cw.IronicClientWrapper, 'call') as mock_list:
mock_list.return_value = nodes
expected = [n.uuid for n in nodes if n.power_state]
available_nodes = self.driver.get_available_nodes()
mock_list.assert_called_with("node.list")
self.assertEqual(sorted(expected), sorted(available_nodes))
self.assertEqual(num_nodes, len(available_nodes))
def test_list_instances(self):
num_nodes = 2
nodes = []
for n in range(num_nodes):
nodes.append(
ironic_utils.get_test_node(
instance_uuid=uuidutils.generate_uuid()))
# append a node w/o instance_uuid which shouldn't be listed
nodes.append(ironic_utils.get_test_node(instance_uuid=None))
with mock.patch.object(cw.IronicClientWrapper, 'call') as mock_list:
mock_list.return_value = nodes
expected = [n for n in nodes if n.instance_uuid]
instances = self.driver.list_instances()
mock_list.assert_called_with("node.list")
self.assertEqual(sorted(expected), sorted(instances))
self.assertEqual(num_nodes, len(instances))
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_get_available_nodes(self):
num_nodes = 2
nodes = []
for n in range(num_nodes):
nodes.append(
ironic_utils.get_test_node(
uuid=uuidutils.generate_uuid(),
power_state=ironic_states.POWER_OFF))
# append a node w/o power_state which shouldn't be listed
nodes.append(ironic_utils.get_test_node(power_state=None))
with mock.patch.object(cw.IronicClientWrapper, 'call') as mock_list:
mock_list.return_value = nodes
expected = [n.uuid for n in nodes if n.power_state]
available_nodes = self.driver.get_available_nodes()
mock_list.assert_called_with("node.list")
self.assertEqual(sorted(expected), sorted(available_nodes))
self.assertEqual(num_nodes, len(available_nodes))
def test_plug_vifs(self, mock__plug_vifs, mock_get):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(uuid=node_uuid)
mock_get.return_value = node
instance = fake_instance.fake_instance_obj(self.ctx, node=node_uuid)
network_info = utils.get_test_network_info()
self.driver.plug_vifs(instance, network_info)
mock_get.assert_called_once_with(node_uuid)
mock__plug_vifs.assert_called_once_with(node, instance, network_info)
def test_power_off(self, mock_sp, fake_validate):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
node = ironic_utils.get_test_node(driver='fake', uuid=node_uuid)
fake_validate.return_value = node
instance_uuid = uuidutils.generate_uuid()
instance = fake_instance.fake_instance_obj(self.ctx,
node=instance_uuid)
self.driver.power_off(instance)
mock_sp.assert_called_once_with(node_uuid, 'off')
def test_list_instance_uuids(self, mock_call):
num_nodes = 2
nodes = []
for n in range(num_nodes):
nodes.append(ironic_utils.get_test_node(
instance_uuid=uuidutils.generate_uuid()))
mock_call.return_value = nodes
uuids = self.driver.list_instance_uuids()
mock_call.assert_called_with('node.list', associated=True)
expected = [n.instance_uuid for n in nodes]
self.assertEquals(sorted(expected), sorted(uuids))
def test_validate_instance_and_node(self, mock_gbiui):
node_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
instance_uuid = uuidutils.generate_uuid()
node = ironic_utils.get_test_node(uuid=node_uuid,
instance_uuid=instance_uuid)
instance = fake_instance.fake_instance_obj(self.ctx,
uuid=instance_uuid)
icli = cw.IronicClientWrapper()
mock_gbiui.return_value = node
result = ironic_driver.validate_instance_and_node(icli, instance)
self.assertEqual(result.uuid, node_uuid)
def test_pxe_get_cleanup_patch_no_flavor_kernel_ramdisk_ids(self):
self.flavor = ironic_utils.get_test_flavor(extra_specs={})
driver_info = {
'pxe_deploy_kernel': 'fake-kernel-id',
'pxe_deploy_ramdisk': 'fake-ramdisk-id'
}
node = ironic_utils.get_test_node(driver='pxe_fake',
driver_info=driver_info)
instance = fake_instance.fake_instance_obj(self.ctx, node=node.uuid)
patch = patcher.create(node).get_cleanup_patch(instance, None,
self.flavor)
self.assertEqual([], patch)
