def test_too_many_cores(self):
"""Ensures we don't go over max cores"""
compute1 = service.Service('host1', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute1.start()
compute2 = service.Service('host2', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute2.start()
instance_ids1 = []
instance_ids2 = []
for index in xrange(FLAGS.max_cores):
instance_id = self._create_instance()
compute1.run_instance(self.context, instance_id)
instance_ids1.append(instance_id)
instance_id = self._create_instance()
compute2.run_instance(self.context, instance_id)
instance_ids2.append(instance_id)
instance_id = self._create_instance()
self.assertRaises(driver.NoValidHost,
self.scheduler.driver.schedule_run_instance,
self.context, instance_id)
for instance_id in instance_ids1:
compute1.terminate_instance(self.context, instance_id)
for instance_id in instance_ids2:
compute2.terminate_instance(self.context, instance_id)
compute1.kill()
compute2.kill()
def test_least_busy_host_gets_volume(self):
"""Ensures the host with less gigabytes gets the next one"""
volume1 = service.Service('host1',
'nova-volume',
'volume',
FLAGS.volume_manager)
volume1.start()
volume2 = service.Service('host2',
'nova-volume',
'volume',
FLAGS.volume_manager)
volume2.start()
volume_id1 = self._create_volume()
volume1.create_volume(self.context, volume_id1)
volume_id2 = self._create_volume()
host = self.scheduler.driver.schedule_create_volume(self.context,
volume_id2)
self.assertEqual(host, 'host2')
volume1.delete_volume(self.context, volume_id1)
db.volume_destroy(self.context, volume_id2)
dic = {'service_id': s_ref['id'],
'vcpus': 16, 'memory_mb': 32, 'local_gb': 100,
'vcpus_used': 16, 'memory_mb_used': 12, 'local_gb_used': 10,
'hypervisor_type': 'qemu', 'hypervisor_version': 12003,
'cpu_info': ''}
def test_reports_enabled_hosts_as_up(self):
"""Ensures driver can find the hosts that are up"""
# NOTE(vish): constructing service without create method
# because we are going to use it without queue
compute1 = service.Service('host1', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute1.start()
compute2 = service.Service('host2', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute2.start()
hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
self.assertEqual(2, len(hosts))
compute1.kill()
compute2.kill()
def test_init_and_start_hooks(self):
self.manager_mock = self.mox.CreateMock(FakeManager)
self.mox.StubOutWithMock(sys.modules[__name__],
'FakeManager',
use_mock_anything=True)
self.mox.StubOutWithMock(self.manager_mock, 'init_host')
self.mox.StubOutWithMock(self.manager_mock, 'pre_start_hook')
self.mox.StubOutWithMock(self.manager_mock, 'create_rpc_dispatcher')
self.mox.StubOutWithMock(self.manager_mock, 'post_start_hook')
FakeManager(host=self.host).AndReturn(self.manager_mock)
# init_host is called before any service record is created
self.manager_mock.init_host()
self._service_start_mocks()
# pre_start_hook is called after service record is created,
# but before RPC consumer is created
self.manager_mock.pre_start_hook(rpc_connection=mox.IgnoreArg())
self.manager_mock.create_rpc_dispatcher()
# post_start_hook is called after RPC consumer is created.
self.manager_mock.post_start_hook()
self.mox.ReplayAll()
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.test_service.FakeManager')
serv.start()
def test_report_state_newly_disconnected(self):
host = 'foo'
binary = 'bar'
topic = 'test'
service_create = {
'host': host,
'binary': binary,
'topic': topic,
'report_count': 0,
'availability_zone': 'nova'
}
service_ref = {
'host': host,
'binary': binary,
'topic': topic,
'report_count': 0,
'availability_zone': 'nova',
'id': 1
}
service.db.service_get_by_args(mox.IgnoreArg(), host,
binary).AndRaise(exception.NotFound())
service.db.service_create(mox.IgnoreArg(),
service_create).AndReturn(service_ref)
service.db.service_get(mox.IgnoreArg(),
mox.IgnoreArg()).AndRaise(Exception())
self.mox.ReplayAll()
serv = service.Service(host, binary, topic,
'nova.tests.test_service.FakeManager')
serv.start()
serv.report_state()
self.assert_(serv.model_disconnected)
def test_report_state_no_service(self):
host = 'foo'
binary = 'bar'
topic = 'test'
service_create = {
'host': host,
'binary': binary,
'topic': topic,
'report_count': 0,
'availability_zone': 'nova'
}
service_ref = {
'host': host,
'binary': binary,
'topic': topic,
'report_count': 0,
'availability_zone': 'nova',
'id': 1
}
service.db.service_get_by_args(mox.IgnoreArg(), host,
binary).AndRaise(exception.NotFound())
service.db.service_create(mox.IgnoreArg(),
service_create).AndReturn(service_ref)
service.db.service_get(mox.IgnoreArg(),
service_ref['id']).AndReturn(service_ref)
service.db.service_update(mox.IgnoreArg(), service_ref['id'],
mox.ContainsKeyValue('report_count', 1))
self.mox.ReplayAll()
serv = service.Service(host, binary, topic,
'nova.tests.test_service.FakeManager')
serv.start()
serv.report_state()
def _test_service_check_create_race(self, ex):
self.manager_mock = self.mox.CreateMock(FakeManager)
self.mox.StubOutWithMock(sys.modules[__name__],
'FakeManager',
use_mock_anything=True)
self.mox.StubOutWithMock(self.manager_mock, 'init_host')
self.mox.StubOutWithMock(self.manager_mock, 'pre_start_hook')
self.mox.StubOutWithMock(self.manager_mock, 'post_start_hook')
FakeManager(host=self.host).AndReturn(self.manager_mock)
# init_host is called before any service record is created
self.manager_mock.init_host()
db.service_get_by_args(mox.IgnoreArg(), self.host,
self.binary).AndRaise(exception.NotFound)
db.service_create(mox.IgnoreArg(), mox.IgnoreArg()).AndRaise(ex)
class TestException(Exception):
pass
db.service_get_by_args(mox.IgnoreArg(), self.host,
self.binary).AndRaise(TestException)
self.mox.ReplayAll()
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.test_service.FakeManager')
self.assertRaises(TestException, serv.start)
def test_message_gets_to_manager(self):
serv = service.Service('test',
'test',
'test',
'nova.tests.test_service.FakeManager')
serv.start()
self.assertEqual(serv.test_method(), 'manager')
def test_parent_graceful_shutdown(self):
self.manager_mock = self.mox.CreateMock(FakeManager)
self.mox.StubOutWithMock(sys.modules[__name__],
'FakeManager',
use_mock_anything=True)
self.mox.StubOutWithMock(self.manager_mock, 'init_host')
self.mox.StubOutWithMock(self.manager_mock, 'pre_start_hook')
self.mox.StubOutWithMock(self.manager_mock, 'post_start_hook')
self.mox.StubOutWithMock(_service.Service, 'stop')
FakeManager(host=self.host).AndReturn(self.manager_mock)
self.manager_mock.service_name = self.topic
self.manager_mock.additional_endpoints = []
# init_host is called before any service record is created
self.manager_mock.init_host()
self._service_start_mocks()
# pre_start_hook is called after service record is created,
# but before RPC consumer is created
self.manager_mock.pre_start_hook()
# post_start_hook is called after RPC consumer is created.
self.manager_mock.post_start_hook()
_service.Service.stop()
self.mox.ReplayAll()
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.test_service.FakeManager')
serv.start()
serv.stop()
def test_service_with_min_down_time(self):
CONF.set_override('service_down_time', 10)
CONF.set_override('report_interval', 10)
serv = service.Service('test', 'test', 'test',
'nova.tests.test_service.FakeManager')
serv.start()
self.assertEqual(CONF.service_down_time, 25)
def test_least_busy_host_gets_volume(self):
"""Ensures the host with less gigabytes gets the next one"""
volume1 = service.Service('host1', 'nova-volume', 'volume',
FLAGS.volume_manager)
volume1.start()
volume2 = service.Service('host2', 'nova-volume', 'volume',
FLAGS.volume_manager)
volume2.start()
volume_id1 = self._create_volume()
volume1.create_volume(self.context, volume_id1)
volume_id2 = self._create_volume()
host = self.scheduler.driver.schedule_create_volume(
self.context, volume_id2)
self.assertEqual(host, 'host2')
volume1.delete_volume(self.context, volume_id1)
db.volume_destroy(self.context, volume_id2)
def test_service_with_min_down_time(self):
# TODO(hanlind): This really tests code in the servicegroup api.
self.flags(service_down_time=10, report_interval=10)
service.Service('test',
'test',
'test',
'nova.tests.unit.test_service.FakeManager')
self.assertEqual(25, CONF.service_down_time)
def test_repr(self):
# Test if a Service object is correctly represented, for example in
# log files.
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.unit.test_service.FakeManager')
exp = "<Service: host=foo, binary=nova-fake, " \
"manager_class_name=nova.tests.unit.test_service.FakeManager>"
self.assertEqual(exp, repr(serv))
def setUp(self):
super(ServiceFixture, self).setUp()
self.serv = service.Service(self.host,
self.binary,
self.topic,
'nova.tests.test_service.FakeManager',
1, 1)
self.addCleanup(self.serv.kill)
def test_reset(self):
serv = service.Service(self.host,
self.binary,
self.topic,
'nova.tests.unit.test_service.FakeManager')
with mock.patch.object(serv.manager, 'reset') as mock_reset:
serv.reset()
mock_reset.assert_called_once_with()
def test_least_busy_host_gets_instance(self):
"""Ensures the host with less cores gets the next one"""
compute1 = service.Service('host1', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute1.start()
compute2 = service.Service('host2', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute2.start()
instance_id1 = self._create_instance()
compute1.run_instance(self.context, instance_id1)
instance_id2 = self._create_instance()
host = self.scheduler.driver.schedule_run_instance(
self.context, instance_id2)
self.assertEqual(host, 'host2')
compute1.terminate_instance(self.context, instance_id1)
db.instance_destroy(self.context, instance_id2)
compute1.kill()
compute2.kill()
def test_doesnt_report_disabled_hosts_as_up(self):
"""Ensures driver doesn't find hosts before they are enabled"""
# NOTE(vish): constructing service without create method
# because we are going to use it without queue
compute1 = service.Service('host1', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute1.start()
compute2 = service.Service('host2', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute2.start()
s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
s2 = db.service_get_by_args(self.context, 'host2', 'nova-compute')
db.service_update(self.context, s1['id'], {'disabled': True})
db.service_update(self.context, s2['id'], {'disabled': True})
hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
self.assertEqual(0, len(hosts))
compute1.kill()
compute2.kill()
def test_specific_host_gets_instance(self):
"""Ensures if you set availability_zone it launches on that zone"""
compute1 = service.Service('host1', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute1.start()
compute2 = service.Service('host2', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute2.start()
instance_id1 = self._create_instance()
compute1.run_instance(self.context, instance_id1)
instance_id2 = self._create_instance(availability_zone='nova:host1')
host = self.scheduler.driver.schedule_run_instance(
self.context, instance_id2)
self.assertEqual('host1', host)
compute1.terminate_instance(self.context, instance_id1)
db.instance_destroy(self.context, instance_id2)
compute1.kill()
compute2.kill()
def test_service_stop_waits_for_rpcserver(self, mock_rpc,
mock_svc_get_by_host_and_binary,
mock_API):
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.unit.test_service.FakeManager')
serv.start()
serv.stop()
serv.rpcserver.start.assert_called_once_with()
serv.rpcserver.stop.assert_called_once_with()
serv.rpcserver.wait.assert_called_once_with()
def test_service_stop_waits_for_rpcserver(self, mock_rpc,
mock_svc_get_by_args, mock_API):
mock_svc_get_by_args.return_value = {'id': 'some_value'}
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.test_service.FakeManager')
serv.start()
serv.stop()
serv.rpcserver.start.assert_called_once_with()
serv.rpcserver.stop.assert_called_once_with()
serv.rpcserver.wait.assert_called_once_with()
def test_report_state_newly_disconnected(self):
self._service_start_mocks()
service.db.service_get(mox.IgnoreArg(),
mox.IgnoreArg()).AndRaise(Exception())
self.mox.ReplayAll()
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.test_service.FakeManager')
serv.start()
serv.report_state()
self.assert_(serv.model_disconnected)
def test_will_schedule_on_disabled_host_if_specified(self):
compute1 = service.Service('host1', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute1.start()
s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
db.service_update(self.context, s1['id'], {'disabled': True})
instance_id2 = self._create_instance(availability_zone='nova:host1')
host = self.scheduler.driver.schedule_run_instance(
self.context, instance_id2)
self.assertEqual('host1', host)
db.instance_destroy(self.context, instance_id2)
compute1.kill()
def test_init_with_indirection_api_waits(self, mock_wait):
obj_base.NovaObject.indirection_api = mock.MagicMock()
with mock.patch.object(FakeManager, '__init__') as init:
def check(*a, **k):
self.assertTrue(mock_wait.called)
init.side_effect = check
service.Service(self.host, self.binary, self.topic,
'nova.tests.unit.test_service.FakeManager')
self.assertTrue(init.called)
mock_wait.assert_called_once_with(mock.ANY)
def test_get_all(self):
host1 = self._host + '_1'
host2 = self._host + '_2'
serv1 = service.Service(host1, self._binary, self._topic,
'nova.tests.test_service.FakeManager', 1, 1)
serv1.start()
serv2 = service.Service(host2, self._binary, self._topic,
'nova.tests.test_service.FakeManager', 1, 1)
serv2.start()
service_ref1 = db.service_get_by_args(self._ctx, host1, self._binary)
service_ref2 = db.service_get_by_args(self._ctx, host2, self._binary)
services = self.servicegroup_api.get_all(self._topic)
self.assertTrue(service_ref1['host'] in services)
self.assertTrue(service_ref2['host'] in services)
service_id = self.servicegroup_api.get_one(self._topic)
self.assertTrue(service_id in services)
def test_start_updates_version(self, mock_get_by_host_and_binary):
# test that the service version gets updated on services startup
service_obj = mock.Mock()
service_obj.binary = 'fake-binary'
service_obj.host = 'fake-host'
service_obj.version = -42
mock_get_by_host_and_binary.return_value = service_obj
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.unit.test_service.FakeManager')
serv.start()
# test service version got updated and saved:
self.assertEqual(1, service_obj.save.call_count)
self.assertEqual(objects.service.SERVICE_VERSION, service_obj.version)
def test_wont_sechedule_if_specified_host_is_down(self):
compute1 = service.Service('host1', 'nova-compute', 'compute',
FLAGS.compute_manager)
compute1.start()
s1 = db.service_get_by_args(self.context, 'host1', 'nova-compute')
now = utils.utcnow()
delta = datetime.timedelta(seconds=FLAGS.service_down_time * 2)
past = now - delta
db.service_update(self.context, s1['id'], {'updated_at': past})
instance_id2 = self._create_instance(availability_zone='nova:host1')
self.assertRaises(driver.WillNotSchedule,
self.scheduler.driver.schedule_run_instance,
self.context, instance_id2)
db.instance_destroy(self.context, instance_id2)
compute1.kill()
def test_parent_graceful_shutdown_with_cleanup_host(
self, mock_svc_get_by_host_and_binary, mock_API):
mock_manager = mock.Mock()
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.unit.test_service.FakeManager')
serv.manager = mock_manager
serv.manager.additional_endpoints = []
serv.start()
serv.manager.init_host.assert_called_with()
serv.stop()
serv.manager.cleanup_host.assert_called_with()
def test_report_state_newly_connected(self):
service_ref = self._service_start_mocks()
service.db.service_get(mox.IgnoreArg(),
service_ref['id']).AndReturn(service_ref)
service.db.service_update(mox.IgnoreArg(), service_ref['id'],
mox.ContainsKeyValue('report_count', 1))
self.mox.ReplayAll()
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.test_service.FakeManager')
serv.start()
serv.model_disconnected = True
serv.report_state()
self.assert_(not serv.model_disconnected)
def test_DB_driver(self):
serv = service.Service(self._host, self._binary, self._topic,
'nova.tests.test_service.FakeManager', 1, 1)
serv.start()
service_ref = db.service_get_by_args(self._ctx, self._host,
self._binary)
self.assertTrue(self.servicegroup_api.service_is_up(service_ref))
eventlet.sleep(self.down_time + 1)
service_ref = db.service_get_by_args(self._ctx, self._host,
self._binary)
self.assertTrue(self.servicegroup_api.service_is_up(service_ref))
serv.stop()
eventlet.sleep(self.down_time + 1)
service_ref = db.service_get_by_args(self._ctx, self._host,
self._binary)
self.assertFalse(self.servicegroup_api.service_is_up(service_ref))
def test_parent_graceful_shutdown(self, mock_stop,
mock_get_by_host_and_binary,
mock_create):
mock_get_by_host_and_binary.return_value = None
mock_manager = mock.Mock(target=None)
serv = service.Service(self.host, self.binary, self.topic,
'nova.tests.unit.test_service.FakeManager')
serv.manager = mock_manager
serv.manager.service_name = self.topic
serv.manager.additional_endpoints = []
serv.start()
serv.manager.init_host.assert_called_once_with()
mock_get_by_host_and_binary.assert_called_once_with(
mock.ANY, self.host, self.binary)
mock_create.assert_called_once_with()
serv.manager.pre_start_hook.assert_called_once_with()
serv.manager.post_start_hook.assert_called_once_with()
serv.stop()
mock_stop.assert_called_once_with()
