Remove nova specific tests
This tests for nova components cannot be started in Ironic. test_ironic_deploy_helper moved, two incompatible tests disabled. Change-Id: I456034bf7bbe3e86630c82ed0d1474c15a9aeee6
This commit is contained in:
Yuriy Zveryanskyy
parent
9cf2e3dd34
commit
9879fd707c
@ -1,329 +0,0 @@
|
||||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
# coding=utf-8
|
||||
|
||||
# Copyright 2012 Hewlett-Packard Development Company, L.P.
|
||||
# Copyright (c) 2012 NTT DOCOMO, INC.
|
||||
# Copyright (c) 2011 University of Southern California / ISI
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
# not use this file except in compliance with the License. You may obtain
|
||||
# a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
"""Tests for the base baremetal driver class."""
|
||||
|
||||
from oslo.config import cfg
|
||||
|
||||
from nova import exception
|
||||
from nova import test
|
||||
from nova.tests.baremetal.db import base as bm_db_base
|
||||
from nova.tests.baremetal.db import utils as bm_db_utils
|
||||
from nova.tests.image import fake as fake_image
|
||||
from nova.tests import utils
|
||||
from nova.virt.baremetal import baremetal_states
|
||||
from nova.virt.baremetal import db
|
||||
from nova.virt.baremetal import driver as bm_driver
|
||||
from nova.virt.baremetal import fake
|
||||
|
||||
|
||||
CONF = cfg.CONF
|
||||
|
||||
COMMON_CONFIG = dict(
|
||||
firewall_driver='nova.virt.baremetal.fake.FakeFirewallDriver',
|
||||
host='test_host',
|
||||
)
|
||||
|
||||
BAREMETAL_CONFIG = dict(
|
||||
driver='nova.virt.baremetal.fake.FakeDriver',
|
||||
instance_type_extra_specs=['cpu_arch:test', 'test_spec:test_value'],
|
||||
power_manager='nova.virt.baremetal.fake.FakePowerManager',
|
||||
vif_driver='nova.virt.baremetal.fake.FakeVifDriver',
|
||||
volume_driver='nova.virt.baremetal.fake.FakeVolumeDriver',
|
||||
group='baremetal',
|
||||
)
|
||||
|
||||
|
||||
class BareMetalDriverNoDBTestCase(test.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(BareMetalDriverNoDBTestCase, self).setUp()
|
||||
self.config(**COMMON_CONFIG)
|
||||
self.config(**BAREMETAL_CONFIG)
|
||||
self.driver = bm_driver.BareMetalDriver(None)
|
||||
|
||||
def test_validate_driver_loading(self):
|
||||
self.assertTrue(isinstance(self.driver.driver,
|
||||
fake.FakeDriver))
|
||||
self.assertTrue(isinstance(self.driver.vif_driver,
|
||||
fake.FakeVifDriver))
|
||||
self.assertTrue(isinstance(self.driver.volume_driver,
|
||||
fake.FakeVolumeDriver))
|
||||
self.assertTrue(isinstance(self.driver.firewall_driver,
|
||||
fake.FakeFirewallDriver))
|
||||
|
||||
|
||||
class BareMetalDriverWithDBTestCase(bm_db_base.BMDBTestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(BareMetalDriverWithDBTestCase, self).setUp()
|
||||
self.config(**COMMON_CONFIG)
|
||||
self.config(**BAREMETAL_CONFIG)
|
||||
|
||||
fake_image.stub_out_image_service(self.stubs)
|
||||
self.context = utils.get_test_admin_context()
|
||||
self.driver = bm_driver.BareMetalDriver(None)
|
||||
self.addCleanup(fake_image.FakeImageService_reset)
|
||||
|
||||
def _create_node(self, node_info=None, nic_info=None):
|
||||
result = {}
|
||||
if node_info is None:
|
||||
node_info = bm_db_utils.new_bm_node(
|
||||
id=123,
|
||||
service_host='test_host',
|
||||
cpus=2,
|
||||
memory_mb=2048,
|
||||
)
|
||||
if nic_info is None:
|
||||
nic_info = [
|
||||
{'address': '01:23:45:67:89:01', 'datapath_id': '0x1',
|
||||
'port_no': 1},
|
||||
{'address': '01:23:45:67:89:02', 'datapath_id': '0x2',
|
||||
'port_no': 2},
|
||||
]
|
||||
result['node_info'] = node_info
|
||||
result['nic_info'] = nic_info
|
||||
result['node'] = db.bm_node_create(self.context, node_info)
|
||||
|
||||
for nic in nic_info:
|
||||
db.bm_interface_create(
|
||||
self.context,
|
||||
result['node']['id'],
|
||||
nic['address'],
|
||||
nic['datapath_id'],
|
||||
nic['port_no'],
|
||||
)
|
||||
result['instance'] = utils.get_test_instance()
|
||||
result['instance']['node'] = result['node']['uuid']
|
||||
result['spawn_params'] = dict(
|
||||
admin_password='test_pass',
|
||||
block_device_info=None,
|
||||
context=self.context,
|
||||
image_meta=utils.get_test_image_info(
|
||||
None, result['instance']),
|
||||
injected_files=[('/fake/path', 'hello world')],
|
||||
instance=result['instance'],
|
||||
network_info=utils.get_test_network_info(),
|
||||
)
|
||||
result['destroy_params'] = dict(
|
||||
instance=result['instance'],
|
||||
network_info=result['spawn_params']['network_info'],
|
||||
block_device_info=result['spawn_params']['block_device_info'],
|
||||
)
|
||||
|
||||
return result
|
||||
|
||||
def test_get_host_stats(self):
|
||||
node = self._create_node()
|
||||
stats = self.driver.get_host_stats()
|
||||
self.assertTrue(isinstance(stats, list))
|
||||
self.assertEqual(len(stats), 1)
|
||||
stats = stats[0]
|
||||
self.assertEqual(stats['cpu_arch'], 'test')
|
||||
self.assertEqual(stats['test_spec'], 'test_value')
|
||||
self.assertEqual(stats['hypervisor_type'], 'baremetal')
|
||||
self.assertEqual(stats['hypervisor_hostname'], node['node']['uuid'])
|
||||
self.assertEqual(stats['host'], 'test_host')
|
||||
self.assertEqual(stats['vcpus'], 2)
|
||||
self.assertEqual(stats['host_memory_total'], 2048)
|
||||
|
||||
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_macs_from_nic_for_instance(self):
|
||||
node = self._create_node()
|
||||
expected = set([nic['address'] for nic in node['nic_info']])
|
||||
self.assertEqual(
|
||||
expected, self.driver.macs_for_instance(node['instance']))
|
||||
|
||||
def test_macs_for_instance_after_spawn(self):
|
||||
node = self._create_node()
|
||||
self.driver.spawn(**node['spawn_params'])
|
||||
|
||||
expected = set([nic['address'] for nic in node['nic_info']])
|
||||
self.assertEqual(
|
||||
expected, self.driver.macs_for_instance(node['instance']))
|
||||
|
||||
def test_macs_for_instance(self):
|
||||
node = self._create_node()
|
||||
expected = set(['01:23:45:67:89:01', '01:23:45:67:89:02'])
|
||||
self.assertEqual(
|
||||
expected, self.driver.macs_for_instance(node['instance']))
|
||||
|
||||
def test_macs_for_instance_no_interfaces(self):
|
||||
# Nodes cannot boot with no MACs, so we raise an error if that happens.
|
||||
node = self._create_node(nic_info=[])
|
||||
self.assertRaises(exception.NovaException,
|
||||
self.driver.macs_for_instance, node['instance'])
|
||||
|
||||
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.assertEqual(row['task_state'], None)
|
||||
|
||||
def test_spawn_node_in_use(self):
|
||||
node = self._create_node()
|
||||
|
||||
self.driver.spawn(**node['spawn_params'])
|
||||
self.assertRaises(exception.NovaException,
|
||||
self.driver.spawn, **node['spawn_params'])
|
||||
|
||||
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.assertEqual(row['task_state'], None)
|
||||
|
||||
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_spawn_fails_to_cleanup(self):
|
||||
node = self._create_node()
|
||||
|
||||
self.mox.StubOutWithMock(fake.FakePowerManager, 'activate_node')
|
||||
self.mox.StubOutWithMock(fake.FakePowerManager, 'deactivate_node')
|
||||
fake.FakePowerManager.activate_node().AndRaise(test.TestingException)
|
||||
fake.FakePowerManager.deactivate_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.ERROR)
|
||||
|
||||
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.assertEqual(row['instance_uuid'], None)
|
||||
self.assertEqual(row['instance_name'], None)
|
||||
|
||||
def test_destroy_fails(self):
|
||||
node = self._create_node()
|
||||
|
||||
self.mox.StubOutWithMock(fake.FakePowerManager, 'deactivate_node')
|
||||
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 test_get_available_resources(self):
|
||||
node = self._create_node()
|
||||
|
||||
resources = self.driver.get_available_resource(node['node']['uuid'])
|
||||
self.assertEqual(resources['memory_mb'],
|
||||
node['node_info']['memory_mb'])
|
||||
self.assertEqual(resources['memory_mb_used'], 0)
|
||||
|
||||
self.driver.spawn(**node['spawn_params'])
|
||||
resources = self.driver.get_available_resource(node['node']['uuid'])
|
||||
self.assertEqual(resources['memory_mb_used'],
|
||||
node['node_info']['memory_mb'])
|
||||
|
||||
self.driver.destroy(**node['destroy_params'])
|
||||
resources = self.driver.get_available_resource(node['node']['uuid'])
|
||||
self.assertEqual(resources['memory_mb_used'], 0)
|
||||
|
||||
def test_get_available_nodes(self):
|
||||
self.assertEqual(0, len(self.driver.get_available_nodes()))
|
||||
|
||||
node1 = self._create_node()
|
||||
self.assertEqual(1, len(self.driver.get_available_nodes()))
|
||||
|
||||
node1['instance']['hostname'] = 'test-host-1'
|
||||
self.driver.spawn(**node1['spawn_params'])
|
||||
self.assertEqual(1, len(self.driver.get_available_nodes()))
|
||||
self.assertEqual([node1['node']['uuid']],
|
||||
self.driver.get_available_nodes())
|
||||
|
||||
def test_list_instances(self):
|
||||
self.assertEqual([], self.driver.list_instances())
|
||||
|
||||
node1 = self._create_node()
|
||||
self.assertEqual([], self.driver.list_instances())
|
||||
|
||||
node_info = bm_db_utils.new_bm_node(
|
||||
id=456,
|
||||
service_host='test_host',
|
||||
cpus=2,
|
||||
memory_mb=2048,
|
||||
)
|
||||
nic_info = [
|
||||
{'address': 'cc:cc:cc', 'datapath_id': '0x1',
|
||||
'port_no': 1},
|
||||
{'address': 'dd:dd:dd', 'datapath_id': '0x2',
|
||||
'port_no': 2},
|
||||
]
|
||||
node2 = self._create_node(node_info=node_info, nic_info=nic_info)
|
||||
self.assertEqual([], self.driver.list_instances())
|
||||
|
||||
node1['instance']['hostname'] = 'test-host-1'
|
||||
node2['instance']['hostname'] = 'test-host-2'
|
||||
|
||||
self.driver.spawn(**node1['spawn_params'])
|
||||
self.assertEqual(['test-host-1'],
|
||||
self.driver.list_instances())
|
||||
|
||||
self.driver.spawn(**node2['spawn_params'])
|
||||
self.assertEqual(['test-host-1', 'test-host-2'],
|
||||
self.driver.list_instances())
|
||||
|
||||
self.driver.destroy(**node1['destroy_params'])
|
||||
self.assertEqual(['test-host-2'],
|
||||
self.driver.list_instances())
|
||||
|
||||
self.driver.destroy(**node2['destroy_params'])
|
||||
self.assertEqual([], self.driver.list_instances())
|
||||
@ -1,389 +0,0 @@
|
||||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
# coding=utf-8
|
||||
|
||||
# Copyright (c) 2011-2013 University of Southern California / ISI
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
# not use this file except in compliance with the License. You may obtain
|
||||
# a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
"""Tests for baremetal tilera driver."""
|
||||
|
||||
import os
|
||||
|
||||
from oslo.config import cfg
|
||||
|
||||
from nova import exception
|
||||
from ironic.openstack.common.db import exception as db_exc
|
||||
from nova.tests.baremetal.db import base as bm_db_base
|
||||
from nova.tests.baremetal.db import utils as bm_db_utils
|
||||
from nova.tests.image import fake as fake_image
|
||||
from nova.tests import utils
|
||||
from nova.virt.baremetal import baremetal_states
|
||||
from nova.virt.baremetal import db
|
||||
from nova.virt.baremetal import tilera
|
||||
from nova.virt.baremetal import utils as bm_utils
|
||||
from nova.virt.disk import api as disk_api
|
||||
from nova.virt import fake as fake_virt
|
||||
|
||||
CONF = cfg.CONF
|
||||
|
||||
COMMON_CONFIG = dict(
|
||||
firewall_driver='nova.virt.baremetal.fake.FakeFirewallDriver',
|
||||
host='test_host',
|
||||
)
|
||||
|
||||
BAREMETAL_CONFIG = dict(
|
||||
driver='nova.virt.baremetal.tilera.Tilera',
|
||||
instance_type_extra_specs=['cpu_arch:test', 'test_spec:test_value'],
|
||||
power_manager='nova.virt.baremetal.fake.FakePowerManager',
|
||||
vif_driver='nova.virt.baremetal.fake.FakeVifDriver',
|
||||
volume_driver='nova.virt.baremetal.fake.FakeVolumeDriver',
|
||||
group='baremetal',
|
||||
)
|
||||
|
||||
|
||||
class BareMetalTileraTestCase(bm_db_base.BMDBTestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(BareMetalTileraTestCase, self).setUp()
|
||||
self.config(**COMMON_CONFIG)
|
||||
self.config(**BAREMETAL_CONFIG)
|
||||
self.driver = tilera.Tilera(fake_virt.FakeVirtAPI())
|
||||
|
||||
fake_image.stub_out_image_service(self.stubs)
|
||||
self.addCleanup(fake_image.FakeImageService_reset)
|
||||
self.context = utils.get_test_admin_context()
|
||||
self.test_block_device_info = None,
|
||||
self.instance = utils.get_test_instance()
|
||||
self.test_network_info = utils.get_test_network_info(),
|
||||
self.node_info = bm_db_utils.new_bm_node(
|
||||
service_host='test_host',
|
||||
cpus=4,
|
||||
memory_mb=2048,
|
||||
prov_mac_address='11:11:11:11:11:11',
|
||||
)
|
||||
self.nic_info = [
|
||||
{'address': '22:22:22:22:22:22', 'datapath_id': '0x1',
|
||||
'port_no': 1},
|
||||
{'address': '33:33:33:33:33:33', 'datapath_id': '0x2',
|
||||
'port_no': 2},
|
||||
]
|
||||
|
||||
def _create_node(self):
|
||||
self.node = db.bm_node_create(self.context, self.node_info)
|
||||
for nic in self.nic_info:
|
||||
db.bm_interface_create(
|
||||
self.context,
|
||||
self.node['id'],
|
||||
nic['address'],
|
||||
nic['datapath_id'],
|
||||
nic['port_no'],
|
||||
)
|
||||
self.instance['node'] = self.node['id']
|
||||
self.spawn_params = dict(
|
||||
admin_password='test_pass',
|
||||
block_device_info=self.test_block_device_info,
|
||||
context=self.context,
|
||||
image_meta=utils.get_test_image_info(None,
|
||||
self.instance),
|
||||
injected_files=[('/fake/path', 'hello world')],
|
||||
instance=self.instance,
|
||||
network_info=self.test_network_info,
|
||||
)
|
||||
|
||||
|
||||
class TileraClassMethodsTestCase(BareMetalTileraTestCase):
|
||||
|
||||
def test_build_network_config(self):
|
||||
net = utils.get_test_network_info(1)
|
||||
config = tilera.build_network_config(net)
|
||||
self.assertIn('eth0', config)
|
||||
self.assertNotIn('eth1', config)
|
||||
|
||||
net = utils.get_test_network_info(2)
|
||||
config = tilera.build_network_config(net)
|
||||
self.assertIn('eth0', config)
|
||||
self.assertIn('eth1', config)
|
||||
|
||||
def test_build_network_config_dhcp(self):
|
||||
self.config(
|
||||
net_config_template='$pybasedir/nova/virt/baremetal/'
|
||||
'net-dhcp.ubuntu.template',
|
||||
group='baremetal',
|
||||
)
|
||||
net = utils.get_test_network_info()
|
||||
net[0][1]['ips'][0]['ip'] = '1.2.3.4'
|
||||
config = tilera.build_network_config(net)
|
||||
self.assertIn('iface eth0 inet dhcp', config)
|
||||
self.assertNotIn('address 1.2.3.4', config)
|
||||
|
||||
def test_build_network_config_static(self):
|
||||
self.config(
|
||||
net_config_template='$pybasedir/nova/virt/baremetal/'
|
||||
'net-static.ubuntu.template',
|
||||
group='baremetal',
|
||||
)
|
||||
net = utils.get_test_network_info()
|
||||
net[0][1]['ips'][0]['ip'] = '1.2.3.4'
|
||||
config = tilera.build_network_config(net)
|
||||
self.assertIn('iface eth0 inet static', config)
|
||||
self.assertIn('address 1.2.3.4', config)
|
||||
|
||||
def test_image_dir_path(self):
|
||||
self.assertEqual(
|
||||
tilera.get_image_dir_path(self.instance),
|
||||
os.path.join(CONF.instances_path, 'instance-00000001'))
|
||||
|
||||
def test_image_file_path(self):
|
||||
self.assertEqual(
|
||||
tilera.get_image_file_path(self.instance),
|
||||
os.path.join(
|
||||
CONF.instances_path, 'instance-00000001', 'disk'))
|
||||
|
||||
def test_tilera_nfs_path(self):
|
||||
self._create_node()
|
||||
self.node['id'] = '123'
|
||||
tilera_nfs_dir = "fs_" + self.node['id']
|
||||
self.assertEqual(
|
||||
tilera.get_tilera_nfs_path(self.node['id']),
|
||||
os.path.join(CONF.baremetal.tftp_root,
|
||||
tilera_nfs_dir))
|
||||
|
||||
def test_get_partition_sizes(self):
|
||||
# default "kinda.big" instance
|
||||
sizes = tilera.get_partition_sizes(self.instance)
|
||||
self.assertEqual(sizes[0], 40960)
|
||||
self.assertEqual(sizes[1], 1024)
|
||||
|
||||
def test_swap_not_zero(self):
|
||||
# override swap to 0
|
||||
instance_type = utils.get_test_instance_type(self.context)
|
||||
instance_type['swap'] = 0
|
||||
self.instance = utils.get_test_instance(self.context, instance_type)
|
||||
|
||||
sizes = tilera.get_partition_sizes(self.instance)
|
||||
self.assertEqual(sizes[0], 40960)
|
||||
self.assertEqual(sizes[1], 1)
|
||||
|
||||
def test_get_tftp_image_info(self):
|
||||
# Tilera case needs only kernel_id.
|
||||
self.instance['kernel_id'] = 'aaaa'
|
||||
self.instance['uuid'] = 'fake-uuid'
|
||||
|
||||
# Here, we confirm both that kernel_id was set
|
||||
# and that the proper paths are getting set for all of them
|
||||
base = os.path.join(CONF.baremetal.tftp_root, self.instance['uuid'])
|
||||
res = tilera.get_tftp_image_info(self.instance)
|
||||
expected = {
|
||||
'kernel': ['aaaa', os.path.join(base, 'kernel')],
|
||||
}
|
||||
self.assertEqual(res, expected)
|
||||
|
||||
|
||||
class TileraPrivateMethodsTestCase(BareMetalTileraTestCase):
|
||||
|
||||
def test_collect_mac_addresses(self):
|
||||
self._create_node()
|
||||
address_list = [nic['address'] for nic in self.nic_info]
|
||||
address_list.sort()
|
||||
macs = self.driver._collect_mac_addresses(self.context, self.node)
|
||||
self.assertEqual(macs, address_list)
|
||||
|
||||
def test_cache_tftp_images(self):
|
||||
self.instance['kernel_id'] = 'aaaa'
|
||||
image_info = tilera.get_tftp_image_info(self.instance)
|
||||
|
||||
self.mox.StubOutWithMock(os, 'makedirs')
|
||||
self.mox.StubOutWithMock(os.path, 'exists')
|
||||
os.makedirs(os.path.join(CONF.baremetal.tftp_root,
|
||||
self.instance['uuid'])).AndReturn(True)
|
||||
for uuid, path in [image_info[label] for label in image_info]:
|
||||
os.path.exists(path).AndReturn(True)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.driver._cache_tftp_images(
|
||||
self.context, self.instance, image_info)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_cache_image(self):
|
||||
self.mox.StubOutWithMock(os, 'makedirs')
|
||||
self.mox.StubOutWithMock(os.path, 'exists')
|
||||
os.makedirs(tilera.get_image_dir_path(self.instance)).\
|
||||
AndReturn(True)
|
||||
os.path.exists(tilera.get_image_file_path(self.instance)).\
|
||||
AndReturn(True)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
image_meta = utils.get_test_image_info(
|
||||
self.context, self.instance)
|
||||
self.driver._cache_image(
|
||||
self.context, self.instance, image_meta)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_inject_into_image(self):
|
||||
self._create_node()
|
||||
files = []
|
||||
self.instance['hostname'] = 'fake hostname'
|
||||
files.append(('/etc/hostname', 'fake hostname'))
|
||||
self.instance['key_data'] = 'fake ssh key'
|
||||
net_info = utils.get_test_network_info(1)
|
||||
net = tilera.build_network_config(net_info)
|
||||
admin_password = 'fake password'
|
||||
|
||||
self.mox.StubOutWithMock(disk_api, 'inject_data')
|
||||
disk_api.inject_data(
|
||||
admin_password=admin_password,
|
||||
image=tilera.get_image_file_path(self.instance),
|
||||
key='fake ssh key',
|
||||
metadata=None,
|
||||
partition=None,
|
||||
net=net,
|
||||
files=files,
|
||||
).AndReturn(True)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.driver._inject_into_image(
|
||||
self.context, self.node, self.instance,
|
||||
network_info=net_info,
|
||||
admin_password=admin_password,
|
||||
injected_files=None)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
|
||||
class TileraPublicMethodsTestCase(BareMetalTileraTestCase):
|
||||
|
||||
def test_cache_images(self):
|
||||
self._create_node()
|
||||
self.mox.StubOutWithMock(tilera, "get_tftp_image_info")
|
||||
self.mox.StubOutWithMock(self.driver, "_cache_tftp_images")
|
||||
self.mox.StubOutWithMock(self.driver, "_cache_image")
|
||||
self.mox.StubOutWithMock(self.driver, "_inject_into_image")
|
||||
|
||||
tilera.get_tftp_image_info(self.instance).AndReturn([])
|
||||
self.driver._cache_tftp_images(self.context, self.instance, [])
|
||||
self.driver._cache_image(self.context, self.instance, [])
|
||||
self.driver._inject_into_image(self.context, self.node, self.instance,
|
||||
self.test_network_info, None, '')
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.driver.cache_images(
|
||||
self.context, self.node, self.instance,
|
||||
admin_password='',
|
||||
image_meta=[],
|
||||
injected_files=None,
|
||||
network_info=self.test_network_info,
|
||||
)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_destroy_images(self):
|
||||
self._create_node()
|
||||
self.mox.StubOutWithMock(bm_utils, 'unlink_without_raise')
|
||||
self.mox.StubOutWithMock(bm_utils, 'rmtree_without_raise')
|
||||
|
||||
bm_utils.unlink_without_raise(tilera.get_image_file_path(
|
||||
self.instance))
|
||||
bm_utils.rmtree_without_raise(tilera.get_image_dir_path(self.instance))
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.driver.destroy_images(self.context, self.node, self.instance)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_activate_bootloader_passes_details(self):
|
||||
self._create_node()
|
||||
image_info = {
|
||||
'kernel': [None, 'cccc'],
|
||||
}
|
||||
self.instance['uuid'] = 'fake-uuid'
|
||||
self.instance['uuid'] = 'fake-uuid'
|
||||
tilera.get_tilera_nfs_path(self.instance)
|
||||
tilera.get_image_file_path(self.instance)
|
||||
|
||||
self.mox.StubOutWithMock(tilera, 'get_tftp_image_info')
|
||||
self.mox.StubOutWithMock(tilera, 'get_partition_sizes')
|
||||
|
||||
tilera.get_tftp_image_info(self.instance).AndReturn(image_info)
|
||||
tilera.get_partition_sizes(self.instance).AndReturn((0, 0))
|
||||
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.driver.activate_bootloader(self.context, self.node, self.instance)
|
||||
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_activate_and_deactivate_bootloader(self):
|
||||
self._create_node()
|
||||
self.instance['uuid'] = 'fake-uuid'
|
||||
tilera.get_tilera_nfs_path(self.instance)
|
||||
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_deactivate_bootloader_for_nonexistent_instance(self):
|
||||
self._create_node()
|
||||
self.node['id'] = 'fake-node-id'
|
||||
|
||||
self.mox.StubOutWithMock(bm_utils, 'unlink_without_raise')
|
||||
self.mox.StubOutWithMock(bm_utils, 'rmtree_without_raise')
|
||||
self.mox.StubOutWithMock(tilera, 'get_tftp_image_info')
|
||||
self.mox.StubOutWithMock(self.driver, '_collect_mac_addresses')
|
||||
|
||||
tilera.get_tftp_image_info(self.instance).\
|
||||
AndRaise(exception.NovaException)
|
||||
self.driver._collect_mac_addresses(self.context, self.node).\
|
||||
AndRaise(db_exc.DBError)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.driver.deactivate_bootloader(
|
||||
self.context, self.node, self.instance)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_activate_node(self):
|
||||
self._create_node()
|
||||
self.instance['uuid'] = 'fake-uuid'
|
||||
|
||||
db.bm_node_update(self.context, 1,
|
||||
{'task_state': baremetal_states.DEPLOYING,
|
||||
'instance_uuid': 'fake-uuid'})
|
||||
|
||||
# test DEPLOYDONE
|
||||
db.bm_node_update(self.context, 1,
|
||||
{'task_state': baremetal_states.DEPLOYDONE})
|
||||
self.driver.activate_node(self.context, self.node, self.instance)
|
||||
|
||||
# test no deploy -- state is just ACTIVE
|
||||
db.bm_node_update(self.context, 1,
|
||||
{'task_state': baremetal_states.ACTIVE})
|
||||
self.driver.activate_node(self.context, self.node, self.instance)
|
||||
|
||||
# test node gone
|
||||
db.bm_node_destroy(self.context, 1)
|
||||
self.assertRaises(exception.InstanceDeployFailure,
|
||||
self.driver.activate_node,
|
||||
self.context, self.node, self.instance)
|
||||
@ -1,141 +0,0 @@
|
||||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
# coding=utf-8
|
||||
|
||||
# Copyright (c) 2011-2013 University of Southern California / ISI
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
# not use this file except in compliance with the License. You may obtain
|
||||
# a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
"""Test class for baremetal PDU power manager."""
|
||||
|
||||
from oslo.config import cfg
|
||||
|
||||
from nova import test
|
||||
from nova.tests.baremetal.db import utils as bm_db_utils
|
||||
from nova import utils
|
||||
from nova.virt.baremetal import baremetal_states
|
||||
from nova.virt.baremetal import tilera_pdu
|
||||
from nova.virt.baremetal import utils as bm_utils
|
||||
|
||||
CONF = cfg.CONF
|
||||
|
||||
|
||||
class BareMetalPduTestCase(test.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(BareMetalPduTestCase, self).setUp()
|
||||
self.node = bm_db_utils.new_bm_node(
|
||||
id=123,
|
||||
pm_address='fake-address',
|
||||
pm_user='fake-user',
|
||||
pm_password='fake-password')
|
||||
self.tilera_pdu = tilera_pdu.Pdu(self.node)
|
||||
self.tile_pdu_on = 1
|
||||
self.tile_pdu_off = 2
|
||||
self.tile_pdu_status = 9
|
||||
|
||||
def test_construct(self):
|
||||
self.assertEqual(self.tilera_pdu.node_id, 123)
|
||||
self.assertEqual(self.tilera_pdu.address, 'fake-address')
|
||||
self.assertEqual(self.tilera_pdu.user, 'fake-user')
|
||||
self.assertEqual(self.tilera_pdu.password, 'fake-password')
|
||||
|
||||
def test_exec_pdutool(self):
|
||||
self.config(tile_pdu_mgr='fake-pdu-mgr', group='baremetal')
|
||||
self.config(tile_pdu_ip='fake-address', group='baremetal')
|
||||
self.mox.StubOutWithMock(utils, 'execute')
|
||||
self.mox.StubOutWithMock(bm_utils, 'unlink_without_raise')
|
||||
args = [
|
||||
'fake-pdu-mgr',
|
||||
'fake-address',
|
||||
self.tile_pdu_on,
|
||||
]
|
||||
utils.execute(*args).AndReturn('')
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_on)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_is_power(self):
|
||||
self.mox.StubOutWithMock(self.tilera_pdu, '_exec_pdutool')
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_status).AndReturn(
|
||||
self.tile_pdu_on)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.tilera_pdu._is_power(self.tile_pdu_on)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_power_already_on(self):
|
||||
self.mox.StubOutWithMock(self.tilera_pdu, '_exec_pdutool')
|
||||
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_on).AndReturn(None)
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_status).AndReturn(
|
||||
self.tile_pdu_on)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.tilera_pdu.state = baremetal_states.DELETED
|
||||
self.tilera_pdu._power_on()
|
||||
self.mox.VerifyAll()
|
||||
self.assertEqual(self.tilera_pdu.state, baremetal_states.ACTIVE)
|
||||
|
||||
def test_power_on_ok(self):
|
||||
self.mox.StubOutWithMock(self.tilera_pdu, '_exec_pdutool')
|
||||
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_on).AndReturn(None)
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_status).AndReturn(
|
||||
self.tile_pdu_on)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.tilera_pdu.state = baremetal_states.DELETED
|
||||
self.tilera_pdu._power_on()
|
||||
self.mox.VerifyAll()
|
||||
self.assertEqual(self.tilera_pdu.state, baremetal_states.ACTIVE)
|
||||
|
||||
def test_power_on_fail(self):
|
||||
self.mox.StubOutWithMock(self.tilera_pdu, '_exec_pdutool')
|
||||
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_on).AndReturn(None)
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_status).AndReturn(
|
||||
self.tile_pdu_off)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.tilera_pdu.state = baremetal_states.DELETED
|
||||
self.tilera_pdu._power_on()
|
||||
self.mox.VerifyAll()
|
||||
self.assertEqual(self.tilera_pdu.state, baremetal_states.ERROR)
|
||||
|
||||
def test_power_on_max_retries(self):
|
||||
self.mox.StubOutWithMock(self.tilera_pdu, '_exec_pdutool')
|
||||
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_on).AndReturn(None)
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_status).AndReturn(
|
||||
self.tile_pdu_off)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.tilera_pdu.state = baremetal_states.DELETED
|
||||
self.tilera_pdu._power_on()
|
||||
self.mox.VerifyAll()
|
||||
self.assertEqual(self.tilera_pdu.state, baremetal_states.ERROR)
|
||||
|
||||
def test_power_off_ok(self):
|
||||
self.mox.StubOutWithMock(self.tilera_pdu, '_exec_pdutool')
|
||||
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_off).AndReturn(None)
|
||||
self.tilera_pdu._exec_pdutool(self.tile_pdu_status).AndReturn(
|
||||
self.tile_pdu_off)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
self.tilera_pdu.state = baremetal_states.ACTIVE
|
||||
self.tilera_pdu._power_off()
|
||||
self.mox.VerifyAll()
|
||||
self.assertEqual(self.tilera_pdu.state, baremetal_states.DELETED)
|
||||
@ -1,401 +0,0 @@
|
||||
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
||||
# coding=utf-8
|
||||
|
||||
# Copyright 2012 Hewlett-Packard Development Company, L.P.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
# not use this file except in compliance with the License. You may obtain
|
||||
# a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
"""Tests for baremetal virtual power driver."""
|
||||
|
||||
import mox
|
||||
from oslo.config import cfg
|
||||
|
||||
from nova import exception
|
||||
from nova.tests.baremetal.db import base as bm_db_base
|
||||
from nova.tests.baremetal.db import utils as bm_db_utils
|
||||
from nova.tests.image import fake as fake_image
|
||||
from nova.tests import utils
|
||||
from nova import utils as nutils
|
||||
from nova.virt.baremetal import db
|
||||
from nova.virt.baremetal import virtual_power_driver
|
||||
import nova.virt.powervm.common as connection
|
||||
|
||||
CONF = cfg.CONF
|
||||
|
||||
COMMON_CONFIG = dict(
|
||||
firewall_driver='nova.virt.baremetal.fake.FakeFirewallDriver',
|
||||
host='test_host',
|
||||
)
|
||||
|
||||
BAREMETAL_CONFIG = dict(
|
||||
driver='nova.virt.baremetal.pxe.PXE',
|
||||
instance_type_extra_specs=['cpu_arch:test', 'test_spec:test_value'],
|
||||
power_manager=
|
||||
'nova.virt.baremetal.virtual_power_driver.VirtualPowerManager',
|
||||
vif_driver='nova.virt.baremetal.fake.FakeVifDriver',
|
||||
volume_driver='nova.virt.baremetal.fake.FakeVolumeDriver',
|
||||
virtual_power_ssh_host=None,
|
||||
virtual_power_type='vbox',
|
||||
virtual_power_host_user=None,
|
||||
virtual_power_host_pass=None,
|
||||
virtual_power_host_key=None,
|
||||
group='baremetal',
|
||||
)
|
||||
|
||||
|
||||
class BareMetalVPDTestCase(bm_db_base.BMDBTestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(BareMetalVPDTestCase, self).setUp()
|
||||
self.config(**COMMON_CONFIG)
|
||||
self.config(**BAREMETAL_CONFIG)
|
||||
|
||||
fake_image.stub_out_image_service(self.stubs)
|
||||
self.context = utils.get_test_admin_context()
|
||||
self.test_block_device_info = None,
|
||||
self.instance = utils.get_test_instance()
|
||||
self.test_network_info = utils.get_test_network_info(),
|
||||
self.node_info = bm_db_utils.new_bm_node(
|
||||
id=123,
|
||||
service_host='test_host',
|
||||
cpus=2,
|
||||
memory_mb=2048,
|
||||
prov_mac_address='aa:bb:cc:dd:ee:ff',
|
||||
)
|
||||
self.nic_info = [
|
||||
{'address': '11:11:11:11:11:11', 'datapath_id': '0x1',
|
||||
'port_no': 1},
|
||||
{'address': '22:22:22:22:22:22', 'datapath_id': '0x2',
|
||||
'port_no': 2},
|
||||
]
|
||||
self.addCleanup(fake_image.FakeImageService_reset)
|
||||
|
||||
def _create_node(self):
|
||||
self.node = db.bm_node_create(self.context, self.node_info)
|
||||
for nic in self.nic_info:
|
||||
db.bm_interface_create(
|
||||
self.context,
|
||||
self.node['id'],
|
||||
nic['address'],
|
||||
nic['datapath_id'],
|
||||
nic['port_no'],
|
||||
)
|
||||
self.instance['node'] = self.node['id']
|
||||
|
||||
def _create_pm(self):
|
||||
self.pm = virtual_power_driver.VirtualPowerManager(
|
||||
node=self.node,
|
||||
instance=self.instance)
|
||||
return self.pm
|
||||
|
||||
|
||||
class VPDMissingOptionsTestCase(BareMetalVPDTestCase):
|
||||
|
||||
def test_get_conn_missing_options(self):
|
||||
self.config(virtual_power_ssh_host=None, group="baremetal")
|
||||
self.config(virtual_power_host_user=None, group="baremetal")
|
||||
self.config(virtual_power_host_pass=None, group="baremetal")
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
self._conn = None
|
||||
self.assertRaises(exception.NovaException,
|
||||
self.pm._get_conn)
|
||||
self._conn = None
|
||||
self.config(virtual_power_ssh_host='127.0.0.1', group="baremetal")
|
||||
self.assertRaises(exception.NovaException,
|
||||
self.pm._get_conn)
|
||||
self._conn = None
|
||||
self.config(virtual_power_host_user='user', group="baremetal")
|
||||
self.assertRaises(exception.NovaException,
|
||||
self.pm._get_conn)
|
||||
|
||||
|
||||
class VPDClassMethodsTestCase(BareMetalVPDTestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(VPDClassMethodsTestCase, self).setUp()
|
||||
self.config(virtual_power_ssh_host='127.0.0.1', group="baremetal")
|
||||
self.config(virtual_power_host_user='user', group="baremetal")
|
||||
self.config(virtual_power_host_pass='password', group="baremetal")
|
||||
|
||||
def test_get_conn_success_pass(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
self._conn = self.pm._get_conn()
|
||||
self.mox.StubOutWithMock(connection, 'ssh_connect')
|
||||
connection.ssh_connect(mox.IsA(self._conn)).AndReturn(True)
|
||||
self.mox.ReplayAll()
|
||||
self.pm._set_connection()
|
||||
self.assertEqual(self.pm.connection_data.host, '127.0.0.1')
|
||||
self.assertEqual(self.pm.connection_data.username, 'user')
|
||||
self.assertEqual(self.pm.connection_data.password, 'password')
|
||||
self.assertEqual(self.pm.connection_data.keyfile, None)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_get_conn_success_key(self):
|
||||
self.config(virtual_power_host_pass='', group="baremetal")
|
||||
self.config(virtual_power_host_key='/id_rsa_file.txt',
|
||||
group="baremetal")
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
self._conn = self.pm._get_conn()
|
||||
self.mox.StubOutWithMock(connection, 'ssh_connect')
|
||||
connection.ssh_connect(mox.IsA(self._conn)).AndReturn(True)
|
||||
self.mox.ReplayAll()
|
||||
self.pm._set_connection()
|
||||
self.assertEqual(self.pm.connection_data.host, '127.0.0.1')
|
||||
self.assertEqual(self.pm.connection_data.username, 'user')
|
||||
self.assertEqual(self.pm.connection_data.password, '')
|
||||
self.assertEqual(self.pm.connection_data.keyfile, '/id_rsa_file.txt')
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_get_full_node_list(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
cmd = self.pm._vp_cmd.list_cmd
|
||||
self.pm._run_command(cmd).AndReturn("testNode")
|
||||
|
||||
self.mox.ReplayAll()
|
||||
name = self.pm._get_full_node_list()
|
||||
self.assertEqual(name, 'testNode')
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_check_for_node(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_get_full_node_list')
|
||||
self.pm._get_full_node_list().\
|
||||
AndReturn(["testNode"])
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
cmd = self.pm._vp_cmd.get_node_macs.replace('{_NodeName_}', 'testNode')
|
||||
self.pm._run_command(cmd).\
|
||||
AndReturn(["111111111111", "ffeeddccbbaa"])
|
||||
|
||||
self.mox.ReplayAll()
|
||||
name = self.pm._check_for_node()
|
||||
self.assertEqual(name, '"testNode"')
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_check_for_node_not_found(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_get_full_node_list')
|
||||
self.pm._get_full_node_list().AndReturn(["testNode"])
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
cmd = self.pm._vp_cmd.get_node_macs.replace('{_NodeName_}', 'testNode')
|
||||
# aa:bb:cc:dd:ee:ff is prov_mac_adress. Check it is not used to
|
||||
# find the node.
|
||||
self.pm._run_command(cmd).AndReturn(["aabbccddeeff", "ffeeddccbbaa"])
|
||||
|
||||
self.mox.ReplayAll()
|
||||
name = self.pm._check_for_node()
|
||||
self.assertEqual(name, '')
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_activate_node(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_check_for_node')
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
self.mox.StubOutWithMock(self.pm, 'is_power_on')
|
||||
self.pm._check_for_node().AndReturn('"testNode"')
|
||||
self.pm._run_command(self.pm._vp_cmd.start_cmd).AndReturn("Started")
|
||||
self.pm.is_power_on().AndReturn(True)
|
||||
self.mox.ReplayAll()
|
||||
state = self.pm.activate_node()
|
||||
self.assertEqual(state, 'active')
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_activate_node_fail(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_check_for_node')
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
self.mox.StubOutWithMock(self.pm, 'is_power_on')
|
||||
self.pm._check_for_node().AndReturn('"testNode"')
|
||||
self.pm._run_command(self.pm._vp_cmd.start_cmd).AndReturn("Started")
|
||||
self.pm.is_power_on().AndReturn(False)
|
||||
self.mox.ReplayAll()
|
||||
state = self.pm.activate_node()
|
||||
self.assertEqual(state, 'error')
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_deactivate_node(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_check_for_node')
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
self.mox.StubOutWithMock(self.pm, 'is_power_on')
|
||||
self.pm._check_for_node().AndReturn('"testNode"')
|
||||
self.pm.is_power_on().AndReturn(True)
|
||||
self.pm._run_command(self.pm._vp_cmd.stop_cmd).AndReturn("Stopped")
|
||||
self.pm.is_power_on().AndReturn(False)
|
||||
self.mox.ReplayAll()
|
||||
state = self.pm.deactivate_node()
|
||||
self.assertEqual(state, 'deleted')
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_deactivate_node_fail(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_check_for_node')
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
self.mox.StubOutWithMock(self.pm, 'is_power_on')
|
||||
self.pm._check_for_node().AndReturn('"testNode"')
|
||||
self.pm.is_power_on().AndReturn(True)
|
||||
self.pm._run_command(self.pm._vp_cmd.stop_cmd).AndReturn("Stopped")
|
||||
self.pm.is_power_on().AndReturn(True)
|
||||
self.mox.ReplayAll()
|
||||
state = self.pm.deactivate_node()
|
||||
self.assertEqual(state, 'error')
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_reboot_node(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_check_for_node')
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
self.mox.StubOutWithMock(self.pm, 'is_power_on')
|
||||
self.pm._check_for_node().AndReturn(['"testNode"'])
|
||||
self.pm._run_command(self.pm._vp_cmd.reboot_cmd).AndReturn("Restarted")
|
||||
self.pm.is_power_on().AndReturn(True)
|
||||
self.mox.ReplayAll()
|
||||
state = self.pm.reboot_node()
|
||||
self.assertEqual(state, 'active')
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_reboot_node_fail(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_check_for_node')
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
self.mox.StubOutWithMock(self.pm, 'is_power_on')
|
||||
self.pm._check_for_node().AndReturn(['"testNode"'])
|
||||
self.pm._run_command(self.pm._vp_cmd.reboot_cmd).AndReturn("Restarted")
|
||||
self.pm.is_power_on().AndReturn(False)
|
||||
self.mox.ReplayAll()
|
||||
state = self.pm.reboot_node()
|
||||
self.assertEqual(state, 'error')
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_is_power_on(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_check_for_node')
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
self.pm._check_for_node().AndReturn(['"testNode"'])
|
||||
self.pm._run_command(self.pm._vp_cmd.list_running_cmd).\
|
||||
AndReturn(['"testNode"'])
|
||||
self.pm._matched_name = 'testNode'
|
||||
self.mox.ReplayAll()
|
||||
state = self.pm.is_power_on()
|
||||
self.assertEqual(state, True)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_is_power_on_fail(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_check_for_node')
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
self.pm._check_for_node().AndReturn(['"NotFoundNode"'])
|
||||
self.pm._run_command(self.pm._vp_cmd.list_running_cmd).\
|
||||
AndReturn(['"NotFoundNode"'])
|
||||
self.pm._matched_name = 'testNode'
|
||||
self.mox.ReplayAll()
|
||||
state = self.pm.is_power_on()
|
||||
self.assertEqual(state, False)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_is_power_on_match_subname(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_check_for_node')
|
||||
self.mox.StubOutWithMock(self.pm, '_run_command')
|
||||
self.pm._check_for_node().AndReturn(['"testNode"'])
|
||||
self.pm._run_command(self.pm._vp_cmd.list_running_cmd).\
|
||||
AndReturn(['"testNode01"'])
|
||||
self.pm._matched_name = '"testNode"'
|
||||
self.mox.ReplayAll()
|
||||
state = self.pm.is_power_on()
|
||||
self.assertEqual(state, False)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_run_command(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_set_connection')
|
||||
self.mox.StubOutWithMock(nutils, 'ssh_execute')
|
||||
self.pm._set_connection().AndReturn(True)
|
||||
nutils.ssh_execute(None, '/usr/bin/VBoxManage test return',
|
||||
check_exit_code=True).AndReturn(("test\nreturn", ""))
|
||||
self.pm._matched_name = 'testNode'
|
||||
self.mox.ReplayAll()
|
||||
result = self.pm._run_command("test return")
|
||||
self.assertEqual(result, ['test', 'return'])
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_run_command_raises_exception(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_set_connection')
|
||||
self.mox.StubOutWithMock(nutils, 'ssh_execute')
|
||||
|
||||
self.pm._set_connection().AndReturn(True)
|
||||
nutils.ssh_execute(None, '/usr/bin/VBoxManage test return',
|
||||
check_exit_code=True).\
|
||||
AndRaise(exception.ProcessExecutionError)
|
||||
self.mox.ReplayAll()
|
||||
|
||||
result = self.pm._run_command("test return")
|
||||
self.assertEqual(result, [])
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def test_activate_node_with_exception(self):
|
||||
self._create_node()
|
||||
self._create_pm()
|
||||
|
||||
self.mox.StubOutWithMock(self.pm, '_check_for_node')
|
||||
self.mox.StubOutWithMock(nutils, 'ssh_execute')
|
||||
|
||||
self.pm._check_for_node().AndReturn(['"testNode"'])
|
||||
self.pm._check_for_node().AndReturn(['"testNode"'])
|
||||
nutils.ssh_execute('test', '/usr/bin/VBoxManage startvm ',
|
||||
check_exit_code=True).\
|
||||
AndRaise(exception.ProcessExecutionError)
|
||||
nutils.ssh_execute('test', '/usr/bin/VBoxManage list runningvms',
|
||||
check_exit_code=True).\
|
||||
AndRaise(exception.ProcessExecutionError)
|
||||
|
||||
self.mox.ReplayAll()
|
||||
self.pm._connection = 'test'
|
||||
state = self.pm.activate_node()
|
||||
self.assertEqual(state, 'error')
|
||||
self.mox.VerifyAll()
|
||||
@ -1,161 +0,0 @@
|
||||
# Copyright (c) 2012 NTT DOCOMO, INC.
|
||||
# All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||||
# not use this file except in compliance with the License. You may obtain
|
||||
# a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
"""Tests for baremetal volume driver."""
|
||||
|
||||
from oslo.config import cfg
|
||||
|
||||
from nova import test
|
||||
from nova.virt.baremetal import volume_driver
|
||||
|
||||
CONF = cfg.CONF
|
||||
|
||||
SHOW_OUTPUT = """Target 1: iqn.2010-10.org.openstack:volume-00000001
|
||||
System information:
|
||||
Driver: iscsi
|
||||
State: ready
|
||||
I_T nexus information:
|
||||
I_T nexus: 8
|
||||
Initiator: iqn.1993-08.org.debian:01:7780c6a16b4
|
||||
Connection: 0
|
||||
IP Address: 172.17.12.10
|
||||
LUN information:
|
||||
LUN: 0
|
||||
Type: controller
|
||||
SCSI ID: IET 00010000
|
||||
SCSI SN: beaf10
|
||||
Size: 0 MB, Block size: 1
|
||||
Online: Yes
|
||||
Removable media: No
|
||||
Readonly: No
|
||||
Backing store type: null
|
||||
Backing store path: None
|
||||
Backing store flags:
|
||||
LUN: 1
|
||||
Type: disk
|
||||
SCSI ID: IET 00010001
|
||||
SCSI SN: beaf11
|
||||
Size: 1074 MB, Block size: 512
|
||||
Online: Yes
|
||||
Removable media: No
|
||||
Readonly: No
|
||||
Backing store type: rdwr
|
||||
Backing store path: /dev/nova-volumes/volume-00000001
|
||||
Backing store flags:
|
||||
Account information:
|
||||
ACL information:
|
||||
ALL
|
||||
Target 2: iqn.2010-10.org.openstack:volume-00000002
|
||||
System information:
|
||||
Driver: iscsi
|
||||
State: ready
|
||||
I_T nexus information:
|
||||
LUN information:
|
||||
LUN: 0
|
||||
Type: controller
|
||||
SCSI ID: IET 00020000
|
||||
SCSI SN: beaf20
|
||||
Size: 0 MB, Block size: 1
|
||||
Online: Yes
|
||||
Removable media: No
|
||||
Readonly: No
|
||||
Backing store type: null
|
||||
Backing store path: None
|
||||
Backing store flags:
|
||||
LUN: 1
|
||||
Type: disk
|
||||
SCSI ID: IET 00020001
|
||||
SCSI SN: beaf21
|
||||
Size: 2147 MB, Block size: 512
|
||||
Online: Yes
|
||||
Removable media: No
|
||||
Readonly: No
|
||||
Backing store type: rdwr
|
||||
Backing store path: /dev/nova-volumes/volume-00000002
|
||||
Backing store flags:
|
||||
Account information:
|
||||
ACL information:
|
||||
ALL
|
||||
Target 1000001: iqn.2010-10.org.openstack.baremetal:1000001-dev.vdc
|
||||
System information:
|
||||
Driver: iscsi
|
||||
State: ready
|
||||
I_T nexus information:
|
||||
LUN information:
|
||||
LUN: 0
|
||||
Type: controller
|
||||
SCSI ID: IET f42410000
|
||||
SCSI SN: beaf10000010
|
||||
Size: 0 MB, Block size: 1
|
||||
Online: Yes
|
||||
Removable media: No
|
||||
Readonly: No
|
||||
Backing store type: null
|
||||
Backing store path: None
|
||||
Backing store flags:
|
||||
LUN: 1
|
||||
Type: disk
|
||||
SCSI ID: IET f42410001
|
||||
SCSI SN: beaf10000011
|
||||
Size: 1074 MB, Block size: 512
|
||||
Online: Yes
|
||||
Removable media: No
|
||||
Readonly: No
|
||||
Backing store type: rdwr
|
||||
Backing store path: /dev/disk/by-path/ip-172.17.12.10:3260-iscsi-\
|
||||
iqn.2010-10.org.openstack:volume-00000001-lun-1
|
||||
Backing store flags:
|
||||
Account information:
|
||||
ACL information:
|
||||
ALL
|
||||
"""
|
||||
|
||||
|
||||
def fake_show_tgtadm():
|
||||
return SHOW_OUTPUT
|
||||
|
||||
|
||||
class BareMetalVolumeTestCase(test.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
super(BareMetalVolumeTestCase, self).setUp()
|
||||
self.stubs.Set(volume_driver, '_show_tgtadm', fake_show_tgtadm)
|
||||
|
||||
def test_list_backingstore_path(self):
|
||||
l = volume_driver._list_backingstore_path()
|
||||
self.assertEqual(len(l), 3)
|
||||
self.assertIn('/dev/nova-volumes/volume-00000001', l)
|
||||
self.assertIn('/dev/nova-volumes/volume-00000002', l)
|
||||
self.assertIn('/dev/disk/by-path/ip-172.17.12.10:3260-iscsi-'
|
||||
'iqn.2010-10.org.openstack:volume-00000001-lun-1', l)
|
||||
|
||||
def test_get_next_tid(self):
|
||||
tid = volume_driver._get_next_tid()
|
||||
self.assertEqual(1000002, tid)
|
||||
|
||||
def test_find_tid_found(self):
|
||||
tid = volume_driver._find_tid(
|
||||
'iqn.2010-10.org.openstack.baremetal:1000001-dev.vdc')
|
||||
self.assertEqual(1000001, tid)
|
||||
|
||||
def test_find_tid_not_found(self):
|
||||
tid = volume_driver._find_tid(
|
||||
'iqn.2010-10.org.openstack.baremetal:1000002-dev.vdc')
|
||||
self.assertTrue(tid is None)
|
||||
|
||||
def test_get_iqn(self):
|
||||
self.config(iscsi_iqn_prefix='iqn.2012-12.a.b', group='baremetal')
|
||||
iqn = volume_driver._get_iqn('instname', '/dev/vdx')
|
||||
self.assertEquals('iqn.2012-12.a.b:instname-dev-vdx', iqn)
|
||||
@ -18,17 +18,18 @@
|
||||
|
||||
import os
|
||||
import tempfile
|
||||
import testtools
|
||||
import time
|
||||
|
||||
import mox
|
||||
|
||||
from ironic.cmd import ironic_deploy_helper as bmdh
|
||||
from ironic import db
|
||||
from ironic.openstack.common import log as logging
|
||||
from ironic.tests import base as tests_base
|
||||
from ironic.tests.db import base
|
||||
from ironic import db
|
||||
|
||||
bmdh.LOG = logging.getLogger('nova.virt.baremetal.deploy_helper')
|
||||
bmdh.LOG = logging.getLogger('ironic.deploy_helper')
|
||||
|
||||
_PXECONF_DEPLOY = """
|
||||
default deploy
|
||||
@ -77,6 +78,7 @@ class WorkerTestCase(base.DbTestCase):
|
||||
break
|
||||
time.sleep(0.1)
|
||||
|
||||
@testtools.skip("not compatible with Ironic db")
|
||||
def test_run_calls_deploy(self):
|
||||
"""Check all queued requests are passed to deploy()."""
|
||||
history = []
|
||||
@ -99,6 +101,7 @@ class WorkerTestCase(base.DbTestCase):
|
||||
self.assertEqual(params_list, history)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
@testtools.skip("not compatible with Ironic db")
|
||||
def test_run_with_failing_deploy(self):
|
||||
"""Check a worker keeps on running even if deploy() raises
|
||||
an exception.
|
||||
2
tox.ini
2
tox.ini
@ -31,4 +31,4 @@ commands = {posargs}
|
||||
[flake8]
|
||||
ignore = E12
|
||||
builtins = _
|
||||
exclude = .venv,.git,.tox,dist,doc,*openstack/common*,*lib/python*,*egg,build,*ironic/nova*,*ironic/tests/nova*,tools
|
||||
exclude = .venv,.git,.tox,dist,doc,*openstack/common*,*lib/python*,*egg,build,*ironic/nova*,tools
|
||||
|
||||
Loading…
Reference in New Issue
Block a user