def test_remove_interface_node_not_found(self):
node_id = 1
self.mox.StubOutWithMock(db, "bm_node_get")
db.bm_node_get(self.context, node_id).AndRaise(exception.NodeNotFound(node_id=node_id))
self.mox.ReplayAll()
body = {"remove_interface": {"address": "11:11:11:11:11:11"}}
self.assertRaises(exc.HTTPNotFound, self.controller._remove_interface, self.request, node_id, body)
def test_remove_interface_no_id_no_address(self):
node_id = 1
self.mox.StubOutWithMock(db, "bm_node_get")
db.bm_node_get(self.context, node_id)
self.mox.ReplayAll()
body = {"remove_interface": {}}
self.assertRaises(exc.HTTPBadRequest, self.controller._remove_interface, self.request, node_id, body)
def test_activate_and_deactivate_bootloader(self):
self._create_node()
flavor = {
'extra_specs': {
'baremetal:deploy_kernel_id': 'eeee',
'baremetal:deploy_ramdisk_id': 'ffff',
}
}
self.instance['uuid'] = 'fake-uuid'
self.mox.StubOutWithMock(self.driver.virtapi, 'flavor_get')
self.mox.StubOutWithMock(bm_utils, 'write_to_file')
self.mox.StubOutWithMock(bm_utils, 'create_link_without_raise')
self.mox.StubOutWithMock(bm_utils, 'unlink_without_raise')
self.mox.StubOutWithMock(bm_utils, 'rmtree_without_raise')
self.driver.virtapi.flavor_get(
self.context, self.instance['instance_type_id']).AndReturn(
flavor)
# create the config file
bm_utils.write_to_file(mox.StrContains('fake-uuid'),
mox.StrContains(CONF.baremetal.tftp_root))
# unlink and link the 2 interfaces
for i in range(2):
bm_utils.unlink_without_raise(mox.Or(
mox.StrContains('fake-uuid'),
mox.StrContains(CONF.baremetal.tftp_root)))
bm_utils.create_link_without_raise(
mox.StrContains('fake-uuid'),
mox.StrContains(CONF.baremetal.tftp_root))
# unlink all 2 interfaces, 4 images, and the config file
for i in range(7):
bm_utils.unlink_without_raise(mox.Or(
mox.StrContains('fake-uuid'),
mox.StrContains(CONF.baremetal.tftp_root)))
bm_utils.rmtree_without_raise(mox.StrContains('fake-uuid'))
self.mox.ReplayAll()
# activate and deactivate the bootloader
# and check the deployment task_state in the database
row = db.bm_node_get(self.context, 1)
self.assertIsNone(row['deploy_key'])
self.driver.activate_bootloader(self.context, self.node, self.instance,
network_info=self.test_network_info)
row = db.bm_node_get(self.context, 1)
self.assertIsNotNone(row['deploy_key'])
self.driver.deactivate_bootloader(self.context, self.node,
self.instance)
row = db.bm_node_get(self.context, 1)
self.assertIsNone(row['deploy_key'])
self.mox.VerifyAll()
def test_get(self):
self._create_nodes()
r = db.bm_node_get(self.context, self.ids[0])
self.assertEquals(r['pm_address'], '0')
r = db.bm_node_get(self.context, self.ids[1])
self.assertEquals(r['pm_address'], '1')
r = db.bm_node_get(self.context, -1)
self.assertTrue(r is None)
def test_show_no_interfaces(self):
node_id = 1
node = {"id": node_id}
self.mox.StubOutWithMock(db, "bm_node_get")
self.mox.StubOutWithMock(db, "bm_interface_get_all_by_bm_node_id")
db.bm_node_get(self.context, node_id).AndReturn(node)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).AndRaise(exception.NodeNotFound(node_id=node_id))
self.mox.ReplayAll()
res_dict = self.controller.show(self.request, node_id)
self.assertEqual(node_id, res_dict["node"]["id"])
self.assertEqual(0, len(res_dict["node"]["interfaces"]))
def test_get(self):
self._create_nodes()
r = db.bm_node_get(self.context, self.ids[0])
self.assertEquals(r["pm_address"], "0")
r = db.bm_node_get(self.context, self.ids[1])
self.assertEquals(r["pm_address"], "1")
r = db.bm_node_get(self.context, -1)
self.assertTrue(r is None)
def test_add_interface_invalid_address(self):
node_id = 1
body = {'add_interface': {'address': ''}}
self.mox.StubOutWithMock(db, 'bm_node_get')
db.bm_node_get(self.context, node_id)
self.mox.ReplayAll()
self.assertRaises(exc.HTTPBadRequest,
self.controller._add_interface,
self.request,
node_id,
body)
def test_remove_interface_node_not_found(self):
node_id = 1
self.mox.StubOutWithMock(db, 'bm_node_get')
db.bm_node_get(self.context, node_id).\
AndRaise(exception.NodeNotFound(node_id=node_id))
self.mox.ReplayAll()
body = {'remove_interface': {'address': '11:11:11:11:11:11'}}
self.assertRaises(exc.HTTPNotFound,
self.controller._remove_interface,
self.request,
node_id,
body)
def test_show(self):
node_id = 1
node = {"id": node_id}
interfaces = [{"id": 1, "address": "11:11:11:11:11:11"}, {"id": 2, "address": "22:22:22:22:22:22"}]
self.mox.StubOutWithMock(db, "bm_node_get")
self.mox.StubOutWithMock(db, "bm_interface_get_all_by_bm_node_id")
db.bm_node_get(self.context, node_id).AndReturn(node)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).AndReturn(interfaces)
self.mox.ReplayAll()
res_dict = self.controller.show(self.request, node_id)
self.assertEqual(node_id, res_dict["node"]["id"])
self.assertEqual(2, len(res_dict["node"]["interfaces"]))
def test_show_no_interfaces(self):
node_id = 1
node = {'id': node_id}
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
db.bm_node_get(self.context, node_id).AndReturn(node)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).\
AndRaise(exception.NodeNotFound(node_id=node_id))
self.mox.ReplayAll()
res_dict = self.controller.show(self.request, node_id)
self.assertEqual(node_id, res_dict['node']['id'])
self.assertEqual(0, len(res_dict['node']['interfaces']))
def test_remove_interface(self):
node_id = 1
interfaces = [{"id": 1}, {"id": 2}, {"id": 3}]
body = {"remove_interface": {"id": 2}}
self.mox.StubOutWithMock(db, "bm_node_get")
self.mox.StubOutWithMock(db, "bm_interface_get_all_by_bm_node_id")
self.mox.StubOutWithMock(db, "bm_interface_destroy")
db.bm_node_get(self.context, node_id)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).AndReturn(interfaces)
db.bm_interface_destroy(self.context, 2)
self.mox.ReplayAll()
self.controller._remove_interface(self.request, node_id, body)
def _test_show_no_interfaces(self, ext_status=False):
node_id = 1
node = {'id': node_id}
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
db.bm_node_get(self.context, node_id).AndReturn(node)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).\
AndRaise(exception.NodeNotFound(node_id=node_id))
self.ext_mgr.is_loaded('os-baremetal-ext-status').AndReturn(ext_status)
self.mox.ReplayAll()
res_dict = self.controller.show(self.request, node_id)
self.assertEqual(node_id, res_dict['node']['id'])
self.assertEqual(0, len(res_dict['node']['interfaces']))
def test_get(self):
self._create_nodes()
r = db.bm_node_get(self.context, self.ids[0])
self.assertEquals(r['pm_address'], '0')
r = db.bm_node_get(self.context, self.ids[1])
self.assertEquals(r['pm_address'], '1')
self.assertRaises(
exception.NodeNotFound,
db.bm_node_get,
self.context, -1)
def test_activate_and_deactivate_bootloader(self):
self._create_node()
extra_specs = {
'deploy_kernel_id': 'eeee',
'deploy_ramdisk_id': 'ffff',
}
self.instance['extra_specs'] = extra_specs
self.instance['uuid'] = 'fake-uuid'
self.mox.StubOutWithMock(bm_utils, 'write_to_file')
self.mox.StubOutWithMock(bm_utils, 'create_link_without_raise')
self.mox.StubOutWithMock(bm_utils, 'unlink_without_raise')
self.mox.StubOutWithMock(bm_utils, 'rmtree_without_raise')
# create the config file
bm_utils.write_to_file(mox.StrContains('fake-uuid'),
mox.StrContains(CONF.baremetal.tftp_root))
# unlink and link the 3 interfaces
for i in range(3):
bm_utils.unlink_without_raise(mox.Or(
mox.StrContains('fake-uuid'),
mox.StrContains(CONF.baremetal.tftp_root)))
bm_utils.create_link_without_raise(
mox.StrContains('fake-uuid'),
mox.StrContains(CONF.baremetal.tftp_root))
# unlink all 3 interfaces, 4 images, and the config file
for i in range(8):
bm_utils.unlink_without_raise(mox.Or(
mox.StrContains('fake-uuid'),
mox.StrContains(CONF.baremetal.tftp_root)))
bm_utils.rmtree_without_raise(mox.StrContains('fake-uuid'))
self.mox.ReplayAll()
# activate and deactivate the bootloader
# and check the deployment task_state in the database
row = db.bm_node_get(self.context, 1)
self.assertTrue(row['deploy_key'] is None)
self.driver.activate_bootloader(self.context, self.node,
self.instance)
row = db.bm_node_get(self.context, 1)
self.assertTrue(row['deploy_key'] is not None)
self.driver.deactivate_bootloader(self.context, self.node,
self.instance)
row = db.bm_node_get(self.context, 1)
self.assertTrue(row['deploy_key'] is None)
self.mox.VerifyAll()
def test_show(self):
node_id = 1
node = {'id': node_id}
interfaces = [{'id': 1, 'address': '11:11:11:11:11:11'},
{'id': 2, 'address': '22:22:22:22:22:22'},
]
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
db.bm_node_get(self.context, node_id).AndReturn(node)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).\
AndReturn(interfaces)
self.mox.ReplayAll()
res_dict = self.controller.show(self.request, node_id)
self.assertEqual(node_id, res_dict['node']['id'])
self.assertEqual(2, len(res_dict['node']['interfaces']))
def test_spawn_ok(self):
node = self._create_node()
self.driver.spawn(**node['spawn_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(row['task_state'], baremetal_states.ACTIVE)
self.assertEqual(row['instance_uuid'], node['instance']['uuid'])
self.assertEqual(row['instance_name'], node['instance']['hostname'])
def _test_rebuild(self, ephemeral):
node = self._create_node(ephemeral=ephemeral)
self.driver.spawn(**node['spawn_params'])
after_spawn = db.bm_node_get(self.context, node['node']['id'])
instance = node['rebuild_params']['instance']
instance.task_state = task_states.REBUILDING
instance.save(expected_task_state=[None])
self.driver.rebuild(preserve_ephemeral=ephemeral,
**node['rebuild_params'])
after_rebuild = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(after_rebuild['task_state'], baremetal_states.ACTIVE)
self.assertEqual(after_rebuild['preserve_ephemeral'], ephemeral)
self.assertEqual(after_spawn['instance_uuid'],
after_rebuild['instance_uuid'])
def test_spawn_prepared(self):
node = self._create_node()
def update_2prepared(context, node, instance, state):
row = db.bm_node_get(context, node['id'])
self.assertEqual(row['task_state'], baremetal_states.BUILDING)
db.bm_node_update(context, node['id'],
{'task_state': baremetal_states.PREPARED})
self.mox.StubOutWithMock(fake.FakeDriver, 'activate_node')
self.mox.StubOutWithMock(bm_driver, '_update_state')
bm_driver._update_state(
self.context, mox.IsA(node['node']), node['instance'],
baremetal_states.PREPARED).WithSideEffects(update_2prepared)
fake.FakeDriver.activate_node(self.context, mox.IsA(
node['node']), node['instance']).AndRaise(test.TestingException)
bm_driver._update_state(
self.context, mox.IsA(node['node']), node['instance'],
baremetal_states.ERROR).AndRaise(test.TestingException)
self.mox.ReplayAll()
self.assertRaises(test.TestingException, self.driver.spawn,
**node['spawn_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(row['task_state'], baremetal_states.PREPARED)
def _wait_for_deploy():
"""Called at an interval until the deployment completes."""
try:
row = db.bm_node_get(context, node['id'])
if instance['uuid'] != row.get('instance_uuid'):
locals['error'] = _("Node associated with another instance"
" while waiting for deploy of %s")
raise loopingcall.LoopingCallDone()
status = row.get('task_state')
if (status == baremetal_states.DEPLOYING
and locals['started'] == False):
LOG.info(
_("PXE deploy started for instance %s") %
instance['uuid'])
locals['started'] = True
elif status in (baremetal_states.DEPLOYDONE,
baremetal_states.ACTIVE):
LOG.info(
_("PXE deploy completed for instance %s") %
instance['uuid'])
raise loopingcall.LoopingCallDone()
elif status == baremetal_states.DEPLOYFAIL:
locals['error'] = _("PXE deploy failed for instance %s")
except exception.NodeNotFound:
locals['error'] = _("Baremetal node deleted while waiting "
"for deployment of instance %s")
if (CONF.baremetal.pxe_deploy_timeout
and timeutils.utcnow() > expiration):
locals['error'] = _("Timeout reached while waiting for "
"PXE deploy of instance %s")
if locals['error']:
raise loopingcall.LoopingCallDone()
def test_spawn_ok(self):
node = self._create_node()
self.driver.spawn(**node['spawn_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(row['task_state'], baremetal_states.ACTIVE)
self.assertEqual(row['instance_uuid'], node['instance']['uuid'])
self.assertEqual(row['instance_name'], node['instance']['hostname'])
def test_spawn_ok(self):
node = self._create_node()
self.driver.spawn(**node["spawn_params"])
row = db.bm_node_get(self.context, node["node"]["id"])
self.assertEqual(row["task_state"], baremetal_states.ACTIVE)
self.assertEqual(row["instance_uuid"], node["instance"]["uuid"])
self.assertEqual(row["instance_name"], node["instance"]["hostname"])
def activate_node(self, context, node, instance):
"""Wait for Tilera deployment to complete."""
locals = {"error": "", "started": False}
try:
row = db.bm_node_get(context, node["id"])
if instance["uuid"] != row.get("instance_uuid"):
locals["error"] = _("Node associated with another instance" " while waiting for deploy of %s")
status = row.get("task_state")
if status == baremetal_states.DEPLOYING and locals["started"] is False:
LOG.info(_("Tilera deploy started for instance %s") % instance["uuid"])
locals["started"] = True
elif status in (baremetal_states.DEPLOYDONE, baremetal_states.BUILDING, baremetal_states.ACTIVE):
LOG.info(_("Tilera deploy completed for instance %s") % instance["uuid"])
node_ip = node["pm_address"]
user_data = instance["user_data"]
try:
self._iptables_set(node_ip, user_data)
except Exception:
self.deactivate_bootloader(context, node, instance)
raise exception.NovaException(_("Node is " "unknown error state."))
elif status == baremetal_states.DEPLOYFAIL:
locals["error"] = _("Tilera deploy failed for instance %s")
except exception.NodeNotFound:
locals["error"] = _("Baremetal node deleted while waiting " "for deployment of instance %s")
if locals["error"]:
raise exception.InstanceDeployFailure(locals["error"] % instance["uuid"])
def show(self, req, id):
context = req.environ['nova.context']
authorize(context)
if _use_ironic():
# proxy command to Ironic
icli = _get_ironic_client()
try:
inode = icli.node.get(id)
except ironic_exc.NotFound:
msg = _("Node %s could not be found.") % id
raise webob.exc.HTTPNotFound(explanation=msg)
iports = icli.node.list_ports(id)
node = {'id': inode.uuid,
'interfaces': [],
'host': 'IRONIC MANAGED',
'task_state': inode.provision_state,
'cpus': inode.properties.get('cpus', 0),
'memory_mb': inode.properties.get('memory_mb', 0),
'disk_gb': inode.properties.get('local_gb', 0),
'instance_uuid': inode.instance_uuid}
for port in iports:
node['interfaces'].append({'address': port.address})
else:
# use nova baremetal
try:
node = db.bm_node_get(context, id)
except exception.NodeNotFound:
raise webob.exc.HTTPNotFound()
try:
ifs = db.bm_interface_get_all_by_bm_node_id(context, id)
except exception.NodeNotFound:
ifs = []
node = self._node_dict(node)
node['interfaces'] = [_interface_dict(i) for i in ifs]
return {'node': node}
def _collect_mac_addresses(self, context, node):
macs = set()
macs.add(db.bm_node_get(context, node['id'])['prov_mac_address'])
for nic in db.bm_interface_get_all_by_bm_node_id(context, node['id']):
if nic['address']:
macs.add(nic['address'])
return sorted(macs)
def test_remove_interface_by_address(self):
node_id = 1
interfaces = [
{"id": 1, "address": "11:11:11:11:11:11"},
{"id": 2, "address": "22:22:22:22:22:22"},
{"id": 3, "address": "33:33:33:33:33:33"},
]
self.mox.StubOutWithMock(db, "bm_node_get")
self.mox.StubOutWithMock(db, "bm_interface_get_all_by_bm_node_id")
self.mox.StubOutWithMock(db, "bm_interface_destroy")
db.bm_node_get(self.context, node_id)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).AndReturn(interfaces)
db.bm_interface_destroy(self.context, 2)
self.mox.ReplayAll()
body = {"remove_interface": {"address": "22:22:22:22:22:22"}}
self.controller._remove_interface(self.request, node_id, body)
def _collect_mac_addresses(self, context, node):
macs = set()
macs.add(db.bm_node_get(context, node["id"])["prov_mac_address"])
for nic in db.bm_interface_get_all_by_bm_node_id(context, node["id"]):
if nic["address"]:
macs.add(nic["address"])
return sorted(macs)
def test_add_interface(self):
node_id = 1
address = "11:22:33:44:55:66"
body = {"add_interface": {"address": address}}
self.mox.StubOutWithMock(db, "bm_node_get")
self.mox.StubOutWithMock(db, "bm_interface_create")
self.mox.StubOutWithMock(db, "bm_interface_get")
db.bm_node_get(self.context, node_id)
db.bm_interface_create(
self.context, bm_node_id=node_id, address=address, datapath_id=None, port_no=None
).AndReturn(12345)
db.bm_interface_get(self.context, 12345).AndReturn({"id": 12345, "address": address})
self.mox.ReplayAll()
res_dict = self.controller._add_interface(self.request, node_id, body)
self.assertEqual(12345, res_dict["interface"]["id"])
self.assertEqual(address, res_dict["interface"]["address"])
def test_remove_interface_by_address(self):
node_id = 1
interfaces = [{'id': 1, 'address': '11:11:11:11:11:11'},
{'id': 2, 'address': '22:22:22:22:22:22'},
{'id': 3, 'address': '33:33:33:33:33:33'},
]
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
self.mox.StubOutWithMock(db, 'bm_interface_destroy')
db.bm_node_get(self.context, node_id)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).\
AndReturn(interfaces)
db.bm_interface_destroy(self.context, 2)
self.mox.ReplayAll()
body = {'remove_interface': {'address': '22:22:22:22:22:22'}}
self.controller._remove_interface(self.request, node_id, body)
def show(self, req, id):
context = req.environ['nova.context']
authorize(context)
if _use_ironic():
# proxy command to Ironic
icli = _get_ironic_client()
inode = icli.node.get(id)
iports = icli.node.list_ports(id)
node = {
'id': inode.uuid,
'interfaces': [],
'host': 'IRONIC MANAGED',
'task_state': inode.provision_state,
'cpus': inode.properties['cpus'],
'memory_mb': inode.properties['memory_mb'],
'disk_gb': inode.properties['local_gb'],
'instance_uuid': inode.instance_uuid
}
for port in iports:
node['interfaces'].append({'address': port.address})
else:
# use nova baremetal
try:
node = db.bm_node_get(context, id)
except exception.NodeNotFound:
raise webob.exc.HTTPNotFound()
try:
ifs = db.bm_interface_get_all_by_bm_node_id(context, id)
except exception.NodeNotFound:
ifs = []
node = self._node_dict(node)
node['interfaces'] = [_interface_dict(i) for i in ifs]
return {'node': node}
def test_remove_interface(self):
node_id = 1
interfaces = [{'id': 1},
{'id': 2},
{'id': 3},
]
body = {'remove_interface': {'id': 2}}
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
self.mox.StubOutWithMock(db, 'bm_interface_destroy')
db.bm_node_get(self.context, node_id)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).\
AndReturn(interfaces)
db.bm_interface_destroy(self.context, 2)
self.mox.ReplayAll()
self.controller._remove_interface(self.request, node_id, body)
def test_spawn_prepared(self):
node = self._create_node()
def update_2prepared(context, node, instance, state):
row = db.bm_node_get(context, node['id'])
self.assertEqual(row['task_state'], baremetal_states.BUILDING)
db.bm_node_update(
context, node['id'],
{'task_state': baremetal_states.PREPARED})
self.mox.StubOutWithMock(fake.FakeDriver, 'activate_node')
self.mox.StubOutWithMock(bm_driver, '_update_state')
bm_driver._update_state(
self.context,
mox.IsA(node['node']),
node['instance'],
baremetal_states.PREPARED).WithSideEffects(update_2prepared)
fake.FakeDriver.activate_node(
self.context,
mox.IsA(node['node']),
node['instance']).AndRaise(test.TestingException)
bm_driver._update_state(
self.context,
mox.IsA(node['node']),
node['instance'],
baremetal_states.ERROR).AndRaise(test.TestingException)
self.mox.ReplayAll()
self.assertRaises(test.TestingException,
self.driver.spawn, **node['spawn_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(row['task_state'], baremetal_states.PREPARED)
def _test_rebuild(self, ephemeral):
node = self._create_node(ephemeral=ephemeral)
self.driver.spawn(**node['spawn_params'])
after_spawn = db.bm_node_get(self.context, node['node']['id'])
instance = node['rebuild_params']['instance']
instance.task_state = task_states.REBUILDING
instance.save(expected_task_state=[None])
self.driver.rebuild(preserve_ephemeral=ephemeral,
**node['rebuild_params'])
after_rebuild = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(after_rebuild['task_state'], baremetal_states.ACTIVE)
self.assertEqual(after_rebuild['preserve_ephemeral'], ephemeral)
self.assertEqual(after_spawn['instance_uuid'],
after_rebuild['instance_uuid'])
def _wait_for_deploy():
"""Called at an interval until the deployment completes."""
try:
row = db.bm_node_get(context, node['id'])
if instance['uuid'] != row.get('instance_uuid'):
locals['error'] = _("Node associated with another instance"
" while waiting for deploy of %s")
raise loopingcall.LoopingCallDone()
status = row.get('task_state')
if (status == baremetal_states.DEPLOYING
and locals['started'] == False):
LOG.info(_("PXE deploy started for instance %s")
% instance['uuid'])
locals['started'] = True
elif status in (baremetal_states.DEPLOYDONE,
baremetal_states.ACTIVE):
LOG.info(_("PXE deploy completed for instance %s")
% instance['uuid'])
raise loopingcall.LoopingCallDone()
elif status == baremetal_states.DEPLOYFAIL:
locals['error'] = _("PXE deploy failed for instance %s")
except exception.NodeNotFound:
locals['error'] = _("Baremetal node deleted while waiting "
"for deployment of instance %s")
if (CONF.baremetal.pxe_deploy_timeout and
timeutils.utcnow() > expiration):
locals['error'] = _("Timeout reached while waiting for "
"PXE deploy of instance %s")
if locals['error']:
raise loopingcall.LoopingCallDone()
def test_activate_and_deactivate_bootloader(self):
self._create_node()
flavor = objects.Flavor(
context=self.context,
extra_specs={"baremetal:deploy_kernel_id": "eeee", "baremetal:deploy_ramdisk_id": "ffff"},
)
self.instance["uuid"] = "fake-uuid"
self.mox.StubOutWithMock(objects.Flavor, "get_by_id")
self.mox.StubOutWithMock(bm_utils, "write_to_file")
self.mox.StubOutWithMock(bm_utils, "create_link_without_raise")
self.mox.StubOutWithMock(bm_utils, "unlink_without_raise")
self.mox.StubOutWithMock(bm_utils, "rmtree_without_raise")
objects.Flavor.get_by_id(self.context, self.instance["instance_type_id"]).AndReturn(flavor)
# create the config file
bm_utils.write_to_file(mox.StrContains("fake-uuid"), mox.StrContains(CONF.baremetal.tftp_root))
# unlink and link the 2 interfaces
for i in range(2):
bm_utils.unlink_without_raise(
mox.Or(mox.StrContains("fake-uuid"), mox.StrContains(CONF.baremetal.tftp_root))
)
bm_utils.create_link_without_raise(mox.StrContains("fake-uuid"), mox.StrContains(CONF.baremetal.tftp_root))
# unlink all 2 interfaces, 4 images, and the config file
for i in range(7):
bm_utils.unlink_without_raise(
mox.Or(mox.StrContains("fake-uuid"), mox.StrContains(CONF.baremetal.tftp_root))
)
bm_utils.rmtree_without_raise(mox.StrContains("fake-uuid"))
self.mox.ReplayAll()
# activate and deactivate the bootloader
# and check the deployment task_state in the database
row = db.bm_node_get(self.context, 1)
self.assertIsNone(row["deploy_key"])
self.driver.activate_bootloader(self.context, self.node, self.instance, network_info=self.test_network_info)
row = db.bm_node_get(self.context, 1)
self.assertIsNotNone(row["deploy_key"])
self.driver.deactivate_bootloader(self.context, self.node, self.instance)
row = db.bm_node_get(self.context, 1)
self.assertIsNone(row["deploy_key"])
self.mox.VerifyAll()
def spawn(self,
context,
instance,
image_meta,
injected_files,
admin_password,
network_info=None,
block_device_info=None):
nodename = None
for m in instance['system_metadata']:
if m['key'] == 'node':
nodename = m['value']
break
if nodename is None:
raise NodeNotSpecified()
node_id = int(nodename)
node = bmdb.bm_node_get(context, node_id)
if not node:
raise NodeNotFound(nodename=nodename)
if node['instance_uuid']:
raise NodeInUse(nodename=nodename, instance_uuid=instance['uuid'])
_update_baremetal_state(context, node, instance,
baremetal_states.BUILDING)
var = self.baremetal_nodes.define_vars(instance, network_info,
block_device_info)
self._plug_vifs(instance, network_info, context=context)
self._firewall_driver.setup_basic_filtering(instance, network_info)
self._firewall_driver.prepare_instance_filter(instance, network_info)
self.baremetal_nodes.create_image(var,
context,
image_meta,
node,
instance,
injected_files=injected_files,
admin_password=admin_password)
self.baremetal_nodes.activate_bootloader(var, context, node, instance)
pm = get_power_manager(node)
state = pm.activate_node()
_update_baremetal_state(context, node, instance, state)
self.baremetal_nodes.activate_node(var, context, node, instance)
self._firewall_driver.apply_instance_filter(instance, network_info)
block_device_mapping = driver.block_device_info_get_mapping(
block_device_info)
for vol in block_device_mapping:
connection_info = vol['connection_info']
mountpoint = vol['mount_device']
self.attach_volume(connection_info, instance['name'], mountpoint)
if node['terminal_port']:
pm.start_console(node['terminal_port'], node['id'])
def _test_show(self, node, ext_status=False):
interfaces = [fake_interface(id=1, address='11:11:11:11:11:11'),
fake_interface(id=2, address='22:22:22:22:22:22'),
]
node.update(interfaces=interfaces)
response = node.copy()
del response['pm_password']
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
db.bm_node_get(self.context, node['id']).AndReturn(node)
db.bm_interface_get_all_by_bm_node_id(self.context, node['id']).\
AndReturn(interfaces)
self.ext_mgr.is_loaded('os-baremetal-ext-status').AndReturn(ext_status)
self.mox.ReplayAll()
res_dict = self.controller.show(self.request, node['id'])
self.assertEqual({'node': response}, res_dict)
self.assertEqual(2, len(res_dict['node']['interfaces']))
def test_ok(self):
self.instance['system_metadata'] = [
_system_metadata('node', str(self.node_id)),
]
self.driver.spawn(**self.kwargs)
node = db.bm_node_get(self.context, self.node_id)
self.assertEqual(node['instance_uuid'], self.instance['uuid'])
self.assertEqual(node['task_state'], baremetal_states.ACTIVE)
def test_ok(self):
self.instance['system_metadata'] = [
_system_metadata('node', str(self.node_id)),
]
self.driver.spawn(**self.kwargs)
node = db.bm_node_get(self.context, self.node_id)
self.assertEqual(node['instance_uuid'], self.instance['uuid'])
self.assertEqual(node['task_state'], baremetal_states.ACTIVE)
def get_available_node_resource(self, nodename):
context = nova_context.get_admin_context()
node_id = int(nodename)
node = bmdb.bm_node_get(context, node_id)
if not node:
raise NodeNotFound(nodename=nodename)
dic = self._node_resource(node)
return dic
def _test_show(self, node, ext_status=False):
interfaces = [fake_interface(id=1, address='11:11:11:11:11:11'),
fake_interface(id=2, address='22:22:22:22:22:22'),
]
node.update(interfaces=interfaces)
response = node.copy()
del response['pm_password']
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
db.bm_node_get(self.context, node['id']).AndReturn(node)
db.bm_interface_get_all_by_bm_node_id(self.context, node['id']).\
AndReturn(interfaces)
self.ext_mgr.is_loaded('os-baremetal-ext-status').AndReturn(ext_status)
self.mox.ReplayAll()
res_dict = self.controller.show(self.request, node['id'])
self.assertEqual({'node': response}, res_dict)
self.assertEqual(2, len(res_dict['node']['interfaces']))
def test_destroy_ok(self):
node = self._create_node()
self.driver.spawn(**node['spawn_params'])
self.driver.destroy(**node['destroy_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(row['task_state'], baremetal_states.DELETED)
self.assertIsNone(row['instance_uuid'])
self.assertIsNone(row['instance_name'])
def test_spawn_node_not_found(self):
self._create_node()
db.bm_node_update(self.context, self.node['id'], {'id': 9876})
self.assertRaises(exception.NovaException, self.driver.spawn,
**self.spawn_params)
row = db.bm_node_get(self.context, 9876)
self.assertEqual(row['task_state'], None)
def test_spawn_node_not_found(self):
node = self._create_node()
db.bm_node_update(self.context, node['node']['id'],
{'uuid': 'hide-this-node'})
self.assertRaises(exception.NovaException, self.driver.spawn,
**node['spawn_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertIsNone(row['task_state'])
def test_destroy(self):
self._create_nodes()
db.bm_node_destroy(self.context, self.ids[0])
r = db.bm_node_get(self.context, self.ids[0])
self.assertTrue(r is None)
r = db.bm_node_get_all(self.context)
self.assertEquals(len(r), 5)
def test_spawn_node_in_use(self):
self._create_node()
db.bm_node_update(self.context, self.node['id'],
{'instance_uuid': '1234-5678'})
self.assertRaises(exception.NovaException,
self.driver.spawn, **self.spawn_params)
row = db.bm_node_get(self.context, self.node['id'])
self.assertEqual(row['task_state'], None)
def test_spawn_node_already_associated(self):
node = self._create_node()
db.bm_node_update(self.context, node['node']['id'],
{'instance_uuid': '1234-5678'})
self.assertRaises(exception.NovaException, self.driver.spawn,
**node['spawn_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertIsNone(row['task_state'])
def test_spawn_no_ephemeral_ok(self):
node = self._create_node(ephemeral=False)
self.driver.spawn(**node['spawn_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(row['task_state'], baremetal_states.ACTIVE)
self.assertEqual(row['instance_uuid'], node['instance']['uuid'])
self.assertEqual(row['instance_name'], node['instance']['hostname'])
instance = main_db.instance_get_by_uuid(self.context,
node['instance']['uuid'])
self.assertEqual(instance['default_ephemeral_device'], None)
def test_add_interface(self):
node_id = 1
address = '11:22:33:ab:cd:ef'
body = {'add_interface': {'address': address}}
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_create')
self.mox.StubOutWithMock(db, 'bm_interface_get')
db.bm_node_get(self.context, node_id)
db.bm_interface_create(self.context,
bm_node_id=node_id,
address=address,
datapath_id=None,
port_no=None).\
AndReturn(12345)
db.bm_interface_get(self.context, 12345).\
AndReturn({'id': 12345, 'address': address})
self.mox.ReplayAll()
res_dict = self.controller._add_interface(self.request, node_id, body)
self.assertEqual(12345, res_dict['interface']['id'])
self.assertEqual(address, res_dict['interface']['address'])
def test_spawn_destroy_images_on_deploy(self):
node = self._create_node()
self.driver.driver.destroy_images = mock.MagicMock()
self.driver.spawn(**node['spawn_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(row['task_state'], baremetal_states.ACTIVE)
self.assertEqual(row['instance_uuid'], node['instance']['uuid'])
self.assertEqual(row['instance_name'], node['instance']['hostname'])
instance = main_db.instance_get_by_uuid(self.context,
node['instance']['uuid'])
self.assertIsNotNone(instance)
self.assertEqual(1, self.driver.driver.destroy_images.call_count)
def post(self, environ, start_response):
LOG.info(_("post: environ=%s"), environ)
inpt = environ['wsgi.input']
length = int(environ.get('CONTENT_LENGTH', 0))
x = inpt.read(length)
q = dict(cgi.parse_qsl(x))
try:
node_id = q['i']
deploy_key = q['k']
address = q['a']
port = q.get('p', '3260')
iqn = q['n']
lun = q.get('l', '1')
err_msg = q.get('e')
except KeyError as e:
start_response('400 Bad Request', [('Content-type', 'text/plain')])
return "parameter '%s' is not defined" % e
if err_msg:
LOG.error(_('Deploy agent error message: %s'), err_msg)
context = nova_context.get_admin_context()
d = db.bm_node_get(context, node_id)
if d['deploy_key'] != deploy_key:
start_response('400 Bad Request', [('Content-type', 'text/plain')])
return 'key is not match'
params = {
'address': address,
'port': port,
'iqn': iqn,
'lun': lun,
'image_path': d['image_path'],
'pxe_config_path': d['pxe_config_path'],
'root_mb': int(d['root_mb']),
'swap_mb': int(d['swap_mb']),
'ephemeral_mb': int(d['ephemeral_mb']),
'preserve_ephemeral': d['preserve_ephemeral'],
}
# Restart worker, if needed
if not self.worker.isAlive():
self.worker = Worker()
self.worker.start()
LOG.info(_("request is queued: node %(node_id)s, params %(params)s"), {
'node_id': node_id,
'params': params
})
QUEUE.put((node_id, params))
# Requests go to Worker.run()
start_response('200 OK', [('Content-type', 'text/plain')])
return ''
def test_spawn_fails(self):
node = self._create_node()
self.mox.StubOutWithMock(fake.FakePowerManager, 'activate_node')
fake.FakePowerManager.activate_node().AndRaise(test.TestingException)
self.mox.ReplayAll()
self.assertRaises(test.TestingException, self.driver.spawn,
**node['spawn_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(row['task_state'], baremetal_states.DELETED)
def test_show(self):
node_id = 1
node = {'id': node_id}
interfaces = [
{
'id': 1,
'address': '11:11:11:11:11:11'
},
{
'id': 2,
'address': '22:22:22:22:22:22'
},
]
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
db.bm_node_get(self.context, node_id).AndReturn(node)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).\
AndReturn(interfaces)
self.mox.ReplayAll()
res_dict = self.controller.show(self.request, node_id)
self.assertEqual(node_id, res_dict['node']['id'])
self.assertEqual(2, len(res_dict['node']['interfaces']))
def show(self, req, id):
context = req.environ['nova.context']
authorize(context)
try:
node = db.bm_node_get(context, id)
except exception.NodeNotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
try:
ifs = db.bm_interface_get_all_by_bm_node_id(context, id)
except exception.NodeNotFound:
ifs = []
node = _node_dict(node)
node['interfaces'] = [_interface_dict(i) for i in ifs]
return {'node': node}
def show(self, req, id):
context = req.environ['nova.context']
authorize(context)
try:
node = db.bm_node_get(context, id)
except exception.InstanceNotFound:
raise webob.exc.HTTPNotFound
try:
ifs = db.bm_interface_get_all_by_bm_node_id(context, id)
except exception.InstanceNotFound:
ifs = []
node = _node_dict(node)
node['interfaces'] = [_interface_dict(i) for i in ifs]
return {'node': node}
def test_activate_and_deactivate_bootloader(self):
self._create_node()
self.instance['uuid'] = 'fake-uuid'
tilera_path = tilera.get_tilera_nfs_path(self.instance)
image_path = tilera.get_image_file_path(self.instance)
self.mox.ReplayAll()
# activate and deactivate the bootloader
# and check the deployment task_state in the database
row = db.bm_node_get(self.context, 1)
self.assertTrue(row['deploy_key'] is None)
self.driver.activate_bootloader(self.context, self.node, self.instance)
row = db.bm_node_get(self.context, 1)
self.assertTrue(row['deploy_key'] is not None)
self.driver.deactivate_bootloader(self.context, self.node,
self.instance)
row = db.bm_node_get(self.context, 1)
self.assertTrue(row['deploy_key'] is None)
self.mox.VerifyAll()
def test_remove_interface(self):
node_id = 1
interfaces = [
{
'id': 1
},
{
'id': 2
},
{
'id': 3
},
]
body = {'remove_interface': {'id': 2}}
self.mox.StubOutWithMock(db, 'bm_node_get')
self.mox.StubOutWithMock(db, 'bm_interface_get_all_by_bm_node_id')
self.mox.StubOutWithMock(db, 'bm_interface_destroy')
db.bm_node_get(self.context, node_id)
db.bm_interface_get_all_by_bm_node_id(self.context, node_id).\
AndReturn(interfaces)
db.bm_interface_destroy(self.context, 2)
self.mox.ReplayAll()
self.controller._remove_interface(self.request, node_id, body)
def test_destroy_fails(self):
node = self._create_node()
self.mox.StubOutWithMock(fake.FakePowerManager, 'deactivate_node')
fake.FakePowerManager.deactivate_node().AndReturn(None)
fake.FakePowerManager.deactivate_node().AndRaise(test.TestingException)
self.mox.ReplayAll()
self.driver.spawn(**node['spawn_params'])
self.assertRaises(test.TestingException, self.driver.destroy,
**node['destroy_params'])
row = db.bm_node_get(self.context, node['node']['id'])
self.assertEqual(row['task_state'], baremetal_states.ERROR)
self.assertEqual(row['instance_uuid'], node['instance']['uuid'])
def activate_node(self, context, node, instance):
"""Wait for Tilera deployment to complete."""
locals = {'error': '', 'started': False}
try:
row = db.bm_node_get(context, node['id'])
if instance['uuid'] != row.get('instance_uuid'):
locals['error'] = _("Node associated with another instance"
" while waiting for deploy of %s")
status = row.get('task_state')
if (status == baremetal_states.DEPLOYING
and locals['started'] == False):
LOG.info(
_('Tilera deploy started for instance %s') %
instance['uuid'])
locals['started'] = True
elif status in (baremetal_states.DEPLOYDONE,
baremetal_states.BUILDING,
baremetal_states.ACTIVE):
LOG.info(
_("Tilera deploy completed for instance %s") %
instance['uuid'])
node_ip = node['pm_address']
user_data = instance['user_data']
try:
self._iptables_set(node_ip, user_data)
except Exception:
self.deactivate_bootloader(context, node, instance)
raise exception.NovaException(
_("Node is "
"unknown error state."))
elif status == baremetal_states.DEPLOYFAIL:
locals['error'] = _("Tilera deploy failed for instance %s")
except exception.NodeNotFound:
locals['error'] = _("Baremetal node deleted while waiting "
"for deployment of instance %s")
if locals['error']:
raise exception.InstanceDeployFailure(locals['error'] %
instance['uuid'])
def _check_node_exists(self, context, node_id):
try:
db.bm_node_get(context, node_id)
except exception.NodeNotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
def update_2prepared(context, node, instance, state):
row = db.bm_node_get(context, node['id'])
self.assertEqual(row['task_state'], baremetal_states.BUILDING)
db.bm_node_update(context, node['id'],
{'task_state': baremetal_states.PREPARED})
