def test_get_nodeinfo_list_provision(self, mock_utcnow):
past = datetime.datetime(2000, 1, 1, 0, 0)
next = past + datetime.timedelta(minutes=8)
present = past + datetime.timedelta(minutes=10)
mock_utcnow.return_value = past
# node with provision_updated timeout
n1 = utils.get_test_node(id=1, uuid=ironic_utils.generate_uuid(),
provision_updated_at=past)
# node with None in provision_updated_at
n2 = utils.get_test_node(id=2, uuid=ironic_utils.generate_uuid(),
provision_state=states.DEPLOYWAIT)
# node without timeout
n3 = utils.get_test_node(id=3, uuid=ironic_utils.generate_uuid(),
provision_updated_at=next)
self.dbapi.create_node(n1)
self.dbapi.create_node(n2)
self.dbapi.create_node(n3)
mock_utcnow.return_value = present
res = self.dbapi.get_nodeinfo_list(filters={'provisioned_before': 300})
self.assertEqual([1], [r[0] for r in res])
res = self.dbapi.get_nodeinfo_list(filters={'provision_state':
states.DEPLOYWAIT})
self.assertEqual([2], [r[0] for r in res])
def test_get_nodeinfo_list_with_filters(self):
n1 = utils.get_test_node(id=1, driver='driver-one',
instance_uuid=ironic_utils.generate_uuid(),
reservation='fake-host',
uuid=ironic_utils.generate_uuid())
n2 = utils.get_test_node(id=2, driver='driver-two',
uuid=ironic_utils.generate_uuid(),
maintenance=True)
self.dbapi.create_node(n1)
self.dbapi.create_node(n2)
res = self.dbapi.get_nodeinfo_list(filters={'driver': 'driver-one'})
self.assertEqual([1], [r[0] for r in res])
res = self.dbapi.get_nodeinfo_list(filters={'driver': 'bad-driver'})
self.assertEqual([], [r[0] for r in res])
res = self.dbapi.get_nodeinfo_list(filters={'associated': True})
self.assertEqual([1], [r[0] for r in res])
res = self.dbapi.get_nodeinfo_list(filters={'associated': False})
self.assertEqual([2], [r[0] for r in res])
res = self.dbapi.get_nodeinfo_list(filters={'reserved': True})
self.assertEqual([1], [r[0] for r in res])
res = self.dbapi.get_nodeinfo_list(filters={'reserved': False})
self.assertEqual([2], [r[0] for r in res])
res = self.dbapi.get_node_list(filters={'maintenance': True})
self.assertEqual([2], [r.id for r in res])
res = self.dbapi.get_node_list(filters={'maintenance': False})
self.assertEqual([1], [r.id for r in res])
def test_update_node_name_duplicate(self):
node1 = utils.create_test_node(uuid=ironic_utils.generate_uuid(),
name='spam')
node2 = utils.create_test_node(uuid=ironic_utils.generate_uuid())
self.assertRaises(exception.DuplicateName,
self.dbapi.update_node,
node2.id,
{'name': node1.name})
def test_node_by_instance_uuid_wrong_uuid(self):
obj_utils.create_test_node(self.context, uuid=utils.generate_uuid(),
instance_uuid=utils.generate_uuid())
wrong_uuid = utils.generate_uuid()
data = self.get_json('/nodes?instance_uuid=%s' % wrong_uuid)
self.assertThat(data['nodes'], HasLength(0))
def test_create_node_instance_already_associated(self):
instance = ironic_utils.generate_uuid()
utils.create_test_node(uuid=ironic_utils.generate_uuid(),
instance_uuid=instance)
self.assertRaises(exception.InstanceAssociated,
utils.create_test_node,
uuid=ironic_utils.generate_uuid(),
instance_uuid=instance)
def test_node_by_instance_uuid_wrong_uuid(self):
ndict = dbutils.get_test_node(uuid=utils.generate_uuid(),
instance_uuid=utils.generate_uuid())
self.dbapi.create_node(ndict)
wrong_uuid = utils.generate_uuid()
data = self.get_json('/nodes?instance_uuid=%s' % wrong_uuid)
self.assertThat(data['nodes'], HasLength(0))
def test_update_node_instance_already_associated(self):
node1 = utils.create_test_node(uuid=ironic_utils.generate_uuid())
new_i_uuid = ironic_utils.generate_uuid()
self.dbapi.update_node(node1.id, {'instance_uuid': new_i_uuid})
node2 = utils.create_test_node(uuid=ironic_utils.generate_uuid())
self.assertRaises(exception.InstanceAssociated,
self.dbapi.update_node,
node2.id,
{'instance_uuid': new_i_uuid})
def test_update_node_already_assosicated(self):
n = self._create_test_node()
new_i_uuid_one = ironic_utils.generate_uuid()
self.dbapi.update_node(n['id'], {'instance_uuid': new_i_uuid_one})
new_i_uuid_two = ironic_utils.generate_uuid()
self.assertRaises(exception.NodeAssociated,
self.dbapi.update_node,
n['id'],
{'instance_uuid': new_i_uuid_two})
def test_update_node_instance_already_associated(self):
n = self._create_test_node(id=1, uuid=ironic_utils.generate_uuid())
new_i_uuid = ironic_utils.generate_uuid()
self.dbapi.update_node(n['id'], {'instance_uuid': new_i_uuid})
n = self._create_test_node(id=2, uuid=ironic_utils.generate_uuid())
self.assertRaises(exception.InstanceAssociated,
self.dbapi.update_node,
n['id'],
{'instance_uuid': new_i_uuid})
def test_create_node_instance_already_associated(self):
instance = ironic_utils.generate_uuid()
n1 = utils.get_test_node(id=1, uuid=ironic_utils.generate_uuid(),
instance_uuid=instance)
self.dbapi.create_node(n1)
n2 = utils.get_test_node(id=2, uuid=ironic_utils.generate_uuid(),
instance_uuid=instance)
self.assertRaises(exception.InstanceAssociated,
self.dbapi.create_node, n2)
def _check_3bea56f25597(self, engine, data):
nodes = db_utils.get_table(engine, 'nodes')
instance_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
data = {'driver': 'fake',
'uuid': utils.generate_uuid(),
'instance_uuid': instance_uuid}
nodes.insert().values(data).execute()
data['uuid'] = utils.generate_uuid()
self.assertRaises(sqlalchemy.exc.IntegrityError,
nodes.insert().execute, data)
def _check_3bea56f25597(self, engine, data):
nodes = db_utils.get_table(engine, "nodes")
instance_uuid = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
data = {"driver": "fake", "uuid": utils.generate_uuid(), "instance_uuid": instance_uuid}
nodes.insert().values(data).execute()
data["uuid"] = utils.generate_uuid()
# TODO(viktors): Remove check on sqlalchemy.exc.IntegrityError, when
# Ironic will use oslo.db 0.4.0 or higher.
# See bug #1214341 for details.
self.assertRaises((sqlalchemy.exc.IntegrityError, exception.DBDuplicateEntry), nodes.insert().execute, data)
def test_node_by_instance_uuid(self):
node = obj_utils.create_test_node(self.context,
uuid=utils.generate_uuid(),
instance_uuid=utils.generate_uuid())
instance_uuid = node.instance_uuid
data = self.get_json('/nodes?instance_uuid=%s' % instance_uuid)
self.assertThat(data['nodes'], HasLength(1))
self.assertEqual(node['instance_uuid'],
data['nodes'][0]["instance_uuid"])
def test_node_by_instance_uuid(self):
ndict = dbutils.get_test_node(uuid=utils.generate_uuid(),
instance_uuid=utils.generate_uuid())
node = self.dbapi.create_node(ndict)
instance_uuid = node['instance_uuid']
data = self.get_json('/nodes?instance_uuid=%s' % instance_uuid)
self.assertThat(data['nodes'], HasLength(1))
self.assertEqual(node['instance_uuid'],
data['nodes'][0]["instance_uuid"])
def test__get_node_vif_ids_two_ports(self):
port1 = self._create_test_port(node_id=self.node.id, id=6,
address='aa:bb:cc',
uuid=utils.generate_uuid(),
extra={'vif_port_id': 'test-vif-A'})
port2 = self._create_test_port(node_id=self.node.id, id=7,
address='dd:ee:ff',
uuid=utils.generate_uuid(),
extra={'vif_port_id': 'test-vif-B'})
expected = {port1.uuid: 'test-vif-A', port2.uuid: 'test-vif-B'}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = pxe._get_node_vif_ids(task)
self.assertEqual(expected, result)
def test__get_nodes_mac_addresses(self):
self._create_test_port(node_id=self.node.id,
address='aa:bb:cc',
uuid=utils.generate_uuid(),
id=6)
self._create_test_port(node_id=self.node.id,
address='dd:ee:ff',
uuid=utils.generate_uuid(),
id=7)
expected = ['aa:bb:cc', 'dd:ee:ff']
with task_manager.acquire(self.context, self.node.uuid) as task:
node_macs = pxe._get_node_mac_addresses(task, self.node)
self.assertEqual(expected, node_macs)
def _pre_upgrade_5674c57409b9(self, engine):
# add some nodes in various states so we can assert that "None"
# was replaced by "available", and nothing else changed.
nodes = db_utils.get_table(engine, 'nodes')
data = [{'uuid': utils.generate_uuid(),
'provision_state': 'fake state'},
{'uuid': utils.generate_uuid(),
'provision_state': 'active'},
{'uuid': utils.generate_uuid(),
'provision_state': 'deleting'},
{'uuid': utils.generate_uuid(),
'provision_state': None}]
nodes.insert().values(data).execute()
return data
def _check_3bea56f25597(self, engine, data):
nodes = db_utils.get_table(engine, 'nodes')
instance_uuid = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
data = {'driver': 'fake',
'uuid': utils.generate_uuid(),
'instance_uuid': instance_uuid}
nodes.insert().values(data).execute()
data['uuid'] = utils.generate_uuid()
# TODO(viktors): Remove check on sqlalchemy.exc.IntegrityError, when
# Ironic will use oslo_db 0.4.0 or higher.
# See bug #1214341 for details.
self.assertRaises(
(sqlalchemy.exc.IntegrityError, db_exc.DBDuplicateEntry),
nodes.insert().execute, data)
def test_detail_with_instance_uuid(self):
ndict = dbutils.get_test_node(uuid=utils.generate_uuid(),
instance_uuid=utils.generate_uuid())
node = self.dbapi.create_node(ndict)
instance_uuid = node['instance_uuid']
data = self.get_json('/nodes/detail?instance_uuid=%s' % instance_uuid)
self.assertEqual(node['instance_uuid'],
data['nodes'][0]["instance_uuid"])
self.assertIn('driver', data['nodes'][0])
self.assertIn('driver_info', data['nodes'][0])
self.assertIn('extra', data['nodes'][0])
self.assertIn('properties', data['nodes'][0])
self.assertIn('chassis_id', data['nodes'][0])
def test_JSONEncodedDict_default_value(self):
# Create chassis w/o extra specified.
ch1_id = ironic_utils.generate_uuid()
self.dbapi.create_chassis({'uuid': ch1_id})
# Get chassis manually to test SA types in isolation from UOM.
ch1 = sa_api.model_query(models.Chassis).filter_by(uuid=ch1_id).one()
self.assertEqual({}, ch1.extra)
# Create chassis with extra specified.
ch2_id = ironic_utils.generate_uuid()
extra = {'foo1': 'test', 'foo2': 'other extra'}
self.dbapi.create_chassis({'uuid': ch2_id, 'extra': extra})
# Get chassis manually to test SA types in isolation from UOM.
ch2 = sa_api.model_query(models.Chassis).filter_by(uuid=ch2_id).one()
self.assertEqual(extra, ch2.extra)
def test_node_power_action_set_power_failure(self):
"""Test if an exception is thrown when the set_power call fails."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
driver='fake',
power_state=states.POWER_OFF)
task = task_manager.TaskManager(self.context, node.uuid)
with mock.patch.object(self.driver.power,
'get_power_state') as get_power_mock:
with mock.patch.object(self.driver.power,
'set_power_state') as set_power_mock:
get_power_mock.return_value = states.POWER_OFF
set_power_mock.side_effect = exception.IronicException()
self.assertRaises(
exception.IronicException,
conductor_utils.node_power_action,
task,
states.POWER_ON)
node.refresh()
get_power_mock.assert_called_once_with(mock.ANY)
set_power_mock.assert_called_once_with(mock.ANY,
states.POWER_ON)
self.assertEqual(states.POWER_OFF, node['power_state'])
self.assertIsNone(node['target_power_state'])
self.assertIsNotNone(node['last_error'])
def post(self, node):
"""Create a new node.
:param node: a node within the request body.
"""
if self._from_chassis:
raise exception.OperationNotPermitted
# NOTE(deva): get_topic_for checks if node.driver is in the hash ring
# and raises NoValidHost if it is not.
# We need to ensure that node has a UUID before it can
# be mapped onto the hash ring.
if not node.uuid:
node.uuid = utils.generate_uuid()
try:
pecan.request.rpcapi.get_topic_for(node)
except exception.NoValidHost as e:
# NOTE(deva): convert from 404 to 400 because client can see
# list of available drivers and shouldn't request
# one that doesn't exist.
e.code = 400
raise e
new_node = pecan.request.dbapi.create_node(node.as_dict())
return Node.convert_with_links(new_node)
def create_chassis(self, values):
if not values.get('uuid'):
values['uuid'] = utils.generate_uuid()
chassis = models.Chassis()
chassis.update(values)
chassis.save()
return chassis
def test_update_node_associate_and_disassociate(self):
n = self._create_test_node()
new_i_uuid = ironic_utils.generate_uuid()
res = self.dbapi.update_node(n['id'], {'instance_uuid': new_i_uuid})
self.assertEqual(new_i_uuid, res.instance_uuid)
res = self.dbapi.update_node(n['id'], {'instance_uuid': None})
self.assertIsNone(res.instance_uuid)
def test_node_power_action_invalid_driver_info(self):
"""Test if an exception is thrown when the driver validation
fails.
"""
ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON)
node = self.dbapi.create_node(ndict)
task = task_manager.TaskManager(self.context, node.uuid)
with mock.patch.object(self.driver.power, 'validate') \
as validate_mock:
validate_mock.side_effect = exception.InvalidParameterValue(
'wrong power driver info')
self.assertRaises(exception.InvalidParameterValue,
conductor_utils.node_power_action,
task,
task.node,
states.POWER_ON)
node.refresh(self.context)
validate_mock.assert_called_once_with(mock.ANY, mock.ANY)
self.assertEqual(node['power_state'], states.POWER_ON)
self.assertIsNone(node['target_power_state'])
self.assertIsNotNone(node['last_error'])
def test_node_power_action_in_same_state(self):
"""Test setting node state to its present state.
Test that we don't try to set the power state if the requested
state is the same as the current state.
"""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
driver='fake',
last_error='anything but None',
power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid)
with mock.patch.object(self.driver.power,
'get_power_state') as get_power_mock:
get_power_mock.return_value = states.POWER_ON
with mock.patch.object(self.driver.power,
'set_power_state') as set_power_mock:
conductor_utils.node_power_action(task, states.POWER_ON)
node.refresh()
get_power_mock.assert_called_once_with(mock.ANY)
self.assertFalse(set_power_mock.called,
"set_power_state unexpectedly called")
self.assertEqual(states.POWER_ON, node['power_state'])
self.assertIsNone(node['target_power_state'])
self.assertIsNone(node['last_error'])
def test_node_power_action_invalid_state(self):
"""Test for exception when changing to an invalid power state."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid)
with mock.patch.object(self.driver.power,
'get_power_state') as get_power_mock:
get_power_mock.return_value = states.POWER_ON
self.assertRaises(exception.InvalidParameterValue,
conductor_utils.node_power_action,
task,
"INVALID_POWER_STATE")
node.refresh()
get_power_mock.assert_called_once_with(mock.ANY)
self.assertEqual(states.POWER_ON, node['power_state'])
self.assertIsNone(node['target_power_state'])
self.assertIsNotNone(node['last_error'])
# last_error is cleared when a new transaction happens
conductor_utils.node_power_action(task, states.POWER_OFF)
node.refresh()
self.assertEqual(states.POWER_OFF, node['power_state'])
self.assertIsNone(node['target_power_state'])
self.assertIsNone(node['last_error'])
def _create_many_test_nodes(self):
uuids = []
for i in range(1, 6):
n = self._create_test_node(id=i, uuid=ironic_utils.generate_uuid())
uuids.append(n['uuid'])
uuids.sort()
return uuids
def test_create_port_duplicated_address(self):
self.dbapi.create_port(self.p)
dup_address = self.p['address']
p2 = db_utils.get_test_port(id=123, uuid=ironic_utils.generate_uuid(),
node_id=self.n.id, address=dup_address)
self.assertRaises(exception.MACAlreadyExists,
self.dbapi.create_port, p2)
def test_remove_multi(self):
extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"}
chassis = obj_utils.create_test_chassis(self.context, extra=extra,
description="foobar",
uuid=utils.generate_uuid(),
id=1)
# Removing one item from the collection
response = self.patch_json('/chassis/%s' % chassis.uuid,
[{'path': '/extra/foo2', 'op': 'remove'}])
self.assertEqual('application/json', response.content_type)
self.assertEqual(200, response.status_code)
result = self.get_json('/chassis/%s' % chassis.uuid)
extra.pop("foo2")
self.assertEqual(extra, result['extra'])
# Removing the collection
response = self.patch_json('/chassis/%s' % chassis.uuid,
[{'path': '/extra', 'op': 'remove'}])
self.assertEqual('application/json', response.content_type)
self.assertEqual(200, response.status_code)
result = self.get_json('/chassis/%s' % chassis.uuid)
self.assertEqual({}, result['extra'])
# Assert nothing else was changed
self.assertEqual(chassis.uuid, result['uuid'])
self.assertEqual(chassis.description, result['description'])
def test_nodes_subresource(self):
chassis = obj_utils.create_test_chassis(self.context)
for id_ in range(2):
obj_utils.create_test_node(self.context,
chassis_id=chassis.id,
uuid=utils.generate_uuid())
data = self.get_json('/chassis/%s/nodes' % chassis.uuid)
self.assertEqual(2, len(data['nodes']))
self.assertNotIn('next', data.keys())
# Test collection pagination
data = self.get_json('/chassis/%s/nodes?limit=1' % chassis.uuid)
self.assertEqual(1, len(data['nodes']))
self.assertIn('next', data.keys())
def test_node_set_boot_device_valid(self):
mgr_utils.mock_the_extension_manager(driver="fake_ipmitool")
self.driver = driver_factory.get_driver("fake_ipmitool")
ipmi_info = utils.get_test_ipmi_info()
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
driver='fake_ipmitool',
driver_info=ipmi_info)
task = task_manager.TaskManager(self.context, node.uuid)
with mock.patch.object(self.driver.management,
'set_boot_device') as mock_sbd:
conductor_utils.node_set_boot_device(task, device='pxe')
mock_sbd.assert_called_once_with(task,
device='pxe',
persistent=False)
def test_replace_multi(self):
extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"}
cdict = dbutils.get_test_chassis(extra=extra,
uuid=utils.generate_uuid(),
id=None)
self.dbapi.create_chassis(cdict)
new_value = 'new value'
response = self.patch_json('/chassis/%s' % cdict['uuid'],
[{'path': '/extra/foo2',
'value': new_value, 'op': 'replace'}])
self.assertEqual('application/json', response.content_type)
self.assertEqual(200, response.status_code)
result = self.get_json('/chassis/%s' % cdict['uuid'])
extra["foo2"] = new_value
self.assertEqual(extra, result['extra'])
def test_node_power_action_power_reboot(self):
"""Test for reboot a node."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid)
with mock.patch.object(self.driver.power, 'reboot') as reboot_mock:
conductor_utils.node_power_action(task, states.REBOOT)
node.refresh()
reboot_mock.assert_called_once_with(mock.ANY)
self.assertEqual(states.POWER_ON, node['power_state'])
self.assertIsNone(node['target_power_state'])
self.assertIsNone(node['last_error'])
def test__get_port_ip_address_with_exception(self, mock_gnvi, mock_gfia):
expected = "192.168.1.3"
port = object_utils.create_test_port(
self.context,
node_id=self.node.id,
address='aa:bb:cc',
uuid=utils.generate_uuid(),
extra={'vif_port_id': 'test-vif-A'},
driver='fake')
mock_gnvi.return_value = None
mock_gfia.return_value = expected
with task_manager.acquire(self.context, self.node.uuid) as task:
api = dhcp_factory.DHCPFactory().provider
self.assertRaises(exception.FailedToGetIPAddressOnPort,
api._get_port_ip_address, task, port,
mock.sentinel.client)
mock_gnvi.assert_called_once_with(task)
def test_maintenance_nodes(self):
nodes = []
for id in range(5):
ndict = dbutils.get_test_node(id=id, uuid=utils.generate_uuid(),
maintenance=id % 2)
node = self.dbapi.create_node(ndict)
nodes.append(node)
data = self.get_json('/nodes?maintenance=true')
uuids = [n['uuid'] for n in data['nodes']]
test_uuids_1 = [n.uuid for n in nodes if n.maintenance]
self.assertEqual(sorted(test_uuids_1), sorted(uuids))
data = self.get_json('/nodes?maintenance=false')
uuids = [n['uuid'] for n in data['nodes']]
test_uuids_0 = [n.uuid for n in nodes if not n.maintenance]
self.assertEqual(sorted(test_uuids_0), sorted(uuids))
def test__get_port_ip_address(self, mock_gnvi, mock_gfia):
expected = "192.168.1.3"
port = object_utils.create_test_port(
self.context,
node_id=self.node.id,
id=6,
address='aa:bb:cc',
uuid=utils.generate_uuid(),
extra={'vif_port_id': 'test-vif-A'},
driver='fake')
mock_gnvi.return_value = {port.uuid: 'vif-uuid'}
mock_gfia.return_value = expected
with task_manager.acquire(self.context, self.node.uuid) as task:
api = dhcp_factory.DHCPFactory(token=task.context.auth_token)
api = api.provider
result = api._get_port_ip_address(task, port.uuid)
self.assertEqual(expected, result)
def test_refresh(self):
uuid = self.fake_chassis['uuid']
new_uuid = ironic_utils.generate_uuid()
returns = [
dict(self.fake_chassis, uuid=uuid),
dict(self.fake_chassis, uuid=new_uuid)
]
expected = [mock.call(uuid), mock.call(uuid)]
with mock.patch.object(self.dbapi,
'get_chassis',
side_effect=returns,
autospec=True) as mock_get_chassis:
c = objects.Chassis.get_by_uuid(self.context, uuid)
self.assertEqual(uuid, c.uuid)
c.refresh()
self.assertEqual(new_uuid, c.uuid)
self.assertEqual(expected, mock_get_chassis.call_args_list)
def test_nodes_subresource(self):
cdict = dbutils.get_test_chassis()
self.dbapi.create_chassis(cdict)
for id in range(2):
obj_utils.create_test_node(self.context, id=id,
chassis_id=cdict['id'],
uuid=utils.generate_uuid())
data = self.get_json('/chassis/%s/nodes' % cdict['uuid'])
self.assertEqual(2, len(data['nodes']))
self.assertNotIn('next', data.keys())
# Test collection pagination
data = self.get_json('/chassis/%s/nodes?limit=1' % cdict['uuid'])
self.assertEqual(1, len(data['nodes']))
self.assertIn('next', data.keys())
def test_node_set_boot_device_valid(self):
mgr_utils.mock_the_extension_manager(driver="fake_ipmitool")
self.driver = driver_factory.get_driver("fake_ipmitool")
ipmi_info = utils.get_test_ipmi_info()
ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(),
driver='fake_ipmitool',
driver_info=ipmi_info)
node = self.dbapi.create_node(ndict)
task = task_manager.TaskManager(self.context, node.uuid)
with mock.patch.object(self.driver.vendor,
'vendor_passthru') as driver_vpassthru:
conductor_utils.node_set_boot_device(task, task.node, device='pxe')
driver_vpassthru.assert_called_once_with(task,
task.node,
device='pxe',
persistent=False,
method='set_boot_device')
def test_ports_subresource(self):
ndict = dbutils.get_test_node()
self.dbapi.create_node(ndict)
for id in range(2):
pdict = dbutils.get_test_port(id=id, node_id=ndict['id'],
uuid=utils.generate_uuid(),
address='52:54:00:cf:2d:3%s' % id)
self.dbapi.create_port(pdict)
data = self.get_json('/nodes/%s/ports' % ndict['uuid'])
self.assertEqual(2, len(data['ports']))
self.assertNotIn('next', data.keys())
# Test collection pagination
data = self.get_json('/nodes/%s/ports?limit=1' % ndict['uuid'])
self.assertEqual(1, len(data['ports']))
self.assertIn('next', data.keys())
def test_remove_singular(self):
chassis = obj_utils.create_test_chassis(self.context,
extra={'a': 'b'},
uuid=utils.generate_uuid(),
id=1)
response = self.patch_json('/chassis/%s' % chassis.uuid,
[{
'path': '/description',
'op': 'remove'
}])
self.assertEqual('application/json', response.content_type)
self.assertEqual(200, response.status_code)
result = self.get_json('/chassis/%s' % chassis.uuid)
self.assertIsNone(result['description'])
# Assert nothing else was changed
self.assertEqual(chassis.uuid, result['uuid'])
self.assertEqual(chassis.extra, result['extra'])
def test_excl_nested_acquire(self, get_ports_mock, get_driver_mock,
reserve_mock, release_mock, node_get_mock):
node2 = obj_utils.create_test_node(self.context,
id=2,
uuid=utils.generate_uuid(),
driver='fake')
reserve_mock.return_value = self.node
get_ports_mock.return_value = mock.sentinel.ports1
get_driver_mock.return_value = mock.sentinel.driver1
with task_manager.TaskManager(self.context, 'node-id1') as task:
reserve_mock.return_value = node2
get_ports_mock.return_value = mock.sentinel.ports2
get_driver_mock.return_value = mock.sentinel.driver2
with task_manager.TaskManager(self.context, 'node-id2') as task2:
self.assertEqual(self.context, task.context)
self.assertEqual(self.node, task.node)
self.assertEqual(mock.sentinel.ports1, task.ports)
self.assertEqual(mock.sentinel.driver1, task.driver)
self.assertFalse(task.shared)
self.assertEqual(self.context, task2.context)
self.assertEqual(node2, task2.node)
self.assertEqual(mock.sentinel.ports2, task2.ports)
self.assertEqual(mock.sentinel.driver2, task2.driver)
self.assertFalse(task2.shared)
self.assertEqual([
mock.call(self.context, self.host, 'node-id1'),
mock.call(self.context, self.host, 'node-id2')
], reserve_mock.call_args_list)
self.assertEqual([
mock.call(self.context, self.node.id),
mock.call(self.context, node2.id)
], get_ports_mock.call_args_list)
self.assertEqual(
[mock.call(self.node.driver),
mock.call(node2.driver)], get_driver_mock.call_args_list)
# release should be in reverse order
self.assertEqual([
mock.call(self.context, self.host, node2.id),
mock.call(self.context, self.host, self.node.id)
], release_mock.call_args_list)
self.assertFalse(node_get_mock.called)
def create_node(self, values):
# ensure defaults are present for new nodes
if not values.get('uuid'):
values['uuid'] = utils.generate_uuid()
if not values.get('power_state'):
values['power_state'] = states.NOSTATE
if not values.get('provision_state'):
values['provision_state'] = states.NOSTATE
node = models.Node()
node.update(values)
try:
node.save()
except db_exc.DBDuplicateEntry as exc:
if 'instance_uuid' in exc.columns:
raise exception.InstanceAssociated(
instance_uuid=values['instance_uuid'], node=values['uuid'])
raise exception.NodeAlreadyExists(uuid=values['uuid'])
return node
def test_node_power_action_power_off(self):
"""Test node_power_action to turn node power off."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid)
with mock.patch.object(self.driver.power,
'get_power_state') as get_power_mock:
get_power_mock.return_value = states.POWER_ON
conductor_utils.node_power_action(task, states.POWER_OFF)
node.refresh()
get_power_mock.assert_called_once_with(mock.ANY)
self.assertEqual(states.POWER_OFF, node['power_state'])
self.assertIsNone(node['target_power_state'])
self.assertIsNone(node['last_error'])
def convert_nova_ports(ports):
ironic_ports = []
for n_port in ports:
i_port = ironic_models.Port()
i_port.id = n_port.id
i_port.uuid = utils.generate_uuid()
i_port.address = n_port.address
i_port.node_id = n_port.bm_node_id
i_port.extra = {}
if n_port.vif_uuid:
i_port.extra['vif_uuid'] = n_port.vif_uuid
ironic_ports.append(i_port)
return ironic_ports
def test_replace_multi(self):
extra = {"foo1": "bar1", "foo2": "bar2", "foo3": "bar3"}
pdict = dbutils.get_test_port(extra=extra,
address="AA:BB:CC:DD:EE:FF",
uuid=utils.generate_uuid())
self.dbapi.create_port(pdict)
new_value = 'new value'
response = self.patch_json('/ports/%s' % pdict['uuid'],
[{
'path': '/extra/foo2',
'value': new_value,
'op': 'replace'
}])
self.assertEqual('application/json', response.content_type)
self.assertEqual(200, response.status_code)
result = self.get_json('/ports/%s' % pdict['uuid'])
extra["foo2"] = new_value
self.assertEqual(extra, result['extra'])
def test_node_power_action_already_being_processed(self):
"""The target_power_state is expected to be None so it isn't
checked in the code. This is what happens if it is not None.
(Eg, if a conductor had died during a previous power-off
attempt and left the target_power_state set to states.POWER_OFF,
and the user is attempting to power-off again.)
"""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON,
target_power_state=states.POWER_OFF)
task = task_manager.TaskManager(self.context, node.uuid)
conductor_utils.node_power_action(task, states.POWER_OFF)
node.refresh()
self.assertEqual(states.POWER_OFF, node['power_state'])
self.assertEqual(states.NOSTATE, node['target_power_state'])
self.assertIsNone(node['last_error'])
def test_replace_address_already_exist(self, mock_upd):
address = 'aa:aa:aa:aa:aa:aa'
dup = dbutils.get_test_port(address=address,
uuid=utils.generate_uuid(),
id=None)
self.dbapi.create_port(dup)
mock_upd.side_effect = exception.MACAlreadyExists(mac=address)
response = self.patch_json('/ports/%s' % self.port.uuid,
[{
'path': '/address',
'value': address,
'op': 'replace'
}],
expect_errors=True)
self.assertEqual('application/json', response.content_type)
self.assertEqual(409, response.status_code)
self.assertTrue(response.json['error_message'])
self.assertTrue(mock_upd.called)
kargs = mock_upd.call_args[0][1]
self.assertEqual(address, kargs.address)
def test_node_power_action_failed_getting_state(self):
"""Test for exception when we can't get the current power state."""
node = obj_utils.create_test_node(self.context,
uuid=cmn_utils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON)
task = task_manager.TaskManager(self.context, node.uuid)
with mock.patch.object(self.driver.power,
'get_power_state') as get_power_state_mock:
get_power_state_mock.side_effect = (
exception.InvalidParameterValue('failed getting power state'))
self.assertRaises(exception.InvalidParameterValue,
conductor_utils.node_power_action, task,
states.POWER_ON)
node.refresh()
get_power_state_mock.assert_called_once_with(mock.ANY)
self.assertEqual(states.POWER_ON, node['power_state'])
self.assertIsNone(node['target_power_state'])
self.assertIsNotNone(node['last_error'])
def test__sync_power_state_node_no_power_state(self):
self.service.start()
self.config(force_power_state_during_sync=False, group='conductor')
# create three nodes
nodes = []
for i in range(0, 3):
n = utils.get_test_node(id=i,
uuid=ironic_utils.generate_uuid(),
driver='fake',
power_state=states.POWER_OFF)
self.dbapi.create_node(n)
nodes.append(n['uuid'])
# cannot get power state of node 2; only nodes 1 & 3 have
# their power states changed.
with mock.patch.object(self.driver.power,
'get_power_state') as get_power_mock:
returns = [
states.POWER_ON,
exception.InvalidParameterValue("invalid"), states.POWER_ON
]
def side_effect(*args):
result = returns.pop(0)
if isinstance(result, Exception):
raise result
return result
get_power_mock.side_effect = side_effect
self.service._sync_power_states(self.context)
self.assertThat(returns, HasLength(0))
final = [states.POWER_ON, states.POWER_OFF, states.POWER_ON]
for i in range(0, 3):
n = self.dbapi.get_node(nodes[i])
self.assertEqual(n.power_state, final[i])
def test_node_power_action_invalid_driver_info(self):
"""Test if an exception is thrown when the driver validation
fails.
"""
ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(),
driver='fake',
power_state=states.POWER_ON)
node = self.dbapi.create_node(ndict)
task = task_manager.TaskManager(self.context, node.uuid)
with mock.patch.object(self.driver.power, 'validate') \
as validate_mock:
validate_mock.side_effect = exception.InvalidParameterValue(
'wrong power driver info')
self.assertRaises(exception.InvalidParameterValue,
conductor_utils.node_power_action, task,
task.node, states.POWER_ON)
node.refresh(self.context)
validate_mock.assert_called_once_with(mock.ANY, mock.ANY)
self.assertEqual(states.POWER_ON, node['power_state'])
self.assertIsNone(node['target_power_state'])
self.assertIsNotNone(node['last_error'])
def test_update_node_not_found(self):
node_uuid = ironic_utils.generate_uuid()
new_extra = {'foo': 'bar'}
self.assertRaises(exception.NodeNotFound, self.dbapi.update_node,
node_uuid, {'extra': new_extra})
def test_create_chassis_already_exists(self):
uuid = ironic_utils.generate_uuid()
self._create_test_chassis(id=1, uuid=uuid)
self.assertRaises(exception.ChassisAlreadyExists,
self._create_test_chassis,
id=2, uuid=uuid)
def test_get_nodeinfo_list_defaults(self):
for i in range(1, 6):
n = utils.get_test_node(id=i, uuid=ironic_utils.generate_uuid())
self.dbapi.create_node(n)
res = [i[0] for i in self.dbapi.get_nodeinfo_list()]
self.assertEqual(sorted(res), sorted(range(1, 6)))
def test_delete_chassis_not_found(self):
uuid = utils.generate_uuid()
response = self.delete('/chassis/%s' % uuid, expect_errors=True)
self.assertEqual(404, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertTrue(response.json['error_message'])
def test_update_chassis_that_does_not_exist(self):
new_uuid = ironic_utils.generate_uuid()
self.assertRaises(exception.ChassisNotFound,
self.dbapi.update_chassis, 666, {'uuid': new_uuid})
def test_create_port_duplicated_address(self):
self.assertRaises(exception.MACAlreadyExists,
db_utils.create_test_port,
uuid=ironic_utils.generate_uuid(),
node_id=self.node.id,
address=self.port.address)
def create_fake_node(i):
dbh = dbapi.get_instance()
node = utils.get_test_node(id=i, uuid=ironic_utils.generate_uuid())
dbh.create_node(node)
return node['uuid']
def test_generate_uuid(self):
uuid_string = utils.generate_uuid()
self.assertIsInstance(uuid_string, str)
self.assertEqual(36, len(uuid_string))
# make sure there are 4 dashes
self.assertEqual(32, len(uuid_string.replace('-', '')))
