def _test_service_get_all(self, fake_filters, **kwargs):
services = [
cells_utils.ServiceProxy(
objects.Service(**dict(test_service.fake_service, id=1,
topic='compute', host='host1')),
'cell1'),
cells_utils.ServiceProxy(
objects.Service(**dict(test_service.fake_service, id=2,
topic='compute', host='host2')),
'cell1')]
exp_services = []
for service in services:
exp_service = copy.copy(service)
exp_service.update({'availability_zone': 'patron'})
exp_services.append(exp_service)
self.mox.StubOutWithMock(self.host_api.cells_rpcapi,
'service_get_all')
self.host_api.cells_rpcapi.service_get_all(self.ctxt,
filters=fake_filters).AndReturn(services)
self.mox.ReplayAll()
result = self.host_api.service_get_all(self.ctxt,
filters=fake_filters,
**kwargs)
self.mox.VerifyAll()
self.assertEqual(jsonutils.to_primitive(exp_services),
jsonutils.to_primitive(result))
def test_service_get_all(self):
responses = []
expected_response = []
# 3 cells... so 3 responses. Each response is a list of services.
# Manager should turn these into a single list of responses.
for i in xrange(3):
cell_name = 'path!to!cell%i' % i
services = []
for service in FAKE_SERVICES:
fake_service = objects.Service(**service)
services.append(fake_service)
expected_service = cells_utils.ServiceProxy(fake_service,
cell_name)
expected_response.append(
(cell_name, expected_service, fake_service))
response = messaging.Response(self.ctxt, cell_name, services,
False)
responses.append(response)
self.mox.StubOutWithMock(self.msg_runner,
'service_get_all')
self.mox.StubOutWithMock(cells_utils, 'add_cell_to_service')
self.msg_runner.service_get_all(self.ctxt,
'fake-filters').AndReturn(responses)
# Calls are done by cells, so we need to sort the list by the cell name
expected_response.sort(key=lambda k: k[0])
for cell_name, service_proxy, service in expected_response:
cells_utils.add_cell_to_service(
service, cell_name).AndReturn(service_proxy)
self.mox.ReplayAll()
response = self.cells_manager.service_get_all(self.ctxt,
filters='fake-filters')
self.assertEqual([proxy for cell, proxy, service in expected_response],
response)
def test_service_get_all_no_zones(self):
services = [
cells_utils.ServiceProxy(
objects.Service(id=1, topic='compute', host='host1'),
'cell1'),
cells_utils.ServiceProxy(
objects.Service(id=2, topic='compute', host='host2'),
'cell1')]
fake_filters = {'host': 'host1'}
self.mox.StubOutWithMock(self.host_api.cells_rpcapi,
'service_get_all')
self.host_api.cells_rpcapi.service_get_all(self.ctxt,
filters=fake_filters).AndReturn(services)
self.mox.ReplayAll()
result = self.host_api.service_get_all(self.ctxt,
filters=fake_filters)
self.assertEqual(services, result)
def test_service_get_by_compute_host(self):
self.mox.StubOutWithMock(self.host_api.cells_rpcapi,
'service_get_by_compute_host')
obj = objects.Service(id=1, host='fake')
fake_service = cells_utils.ServiceProxy(obj, 'cell1')
self.host_api.cells_rpcapi.service_get_by_compute_host(self.ctxt,
'fake-host').AndReturn(fake_service)
self.mox.ReplayAll()
result = self.host_api.service_get_by_compute_host(self.ctxt,
'fake-host')
self.assertEqual(fake_service, result)
def test_service_update(self):
host_name = 'fake-host'
binary = 'patron-compute'
params_to_update = dict(disabled=True)
obj = objects.Service(id=42, host='fake')
fake_service = cells_utils.ServiceProxy(obj, 'cell1')
self.mox.StubOutWithMock(self.host_api.cells_rpcapi, 'service_update')
self.host_api.cells_rpcapi.service_update(
self.ctxt, host_name,
binary, params_to_update).AndReturn(fake_service)
self.mox.ReplayAll()
result = self.host_api.service_update(
self.ctxt, host_name, binary, params_to_update)
self.assertEqual(fake_service, result)
def test_service_get_by_compute_host(self):
fake_cell = 'fake-cell'
fake_service = objects.Service(**FAKE_SERVICES[0])
fake_response = messaging.Response(self.ctxt, fake_cell,
fake_service,
False)
expected_response = cells_utils.ServiceProxy(fake_service, fake_cell)
cell_and_host = cells_utils.cell_with_item('fake-cell', 'fake-host')
self.mox.StubOutWithMock(self.msg_runner,
'service_get_by_compute_host')
self.mox.StubOutWithMock(cells_utils, 'add_cell_to_service')
self.msg_runner.service_get_by_compute_host(self.ctxt,
fake_cell, 'fake-host').AndReturn(fake_response)
cells_utils.add_cell_to_service(fake_service, fake_cell).AndReturn(
expected_response)
self.mox.ReplayAll()
response = self.cells_manager.service_get_by_compute_host(self.ctxt,
host_name=cell_and_host)
self.assertEqual(expected_response, response)
def test_service_update(self):
fake_cell = 'fake-cell'
fake_service = objects.Service(**FAKE_SERVICES[0])
fake_response = messaging.Response(
self.ctxt, fake_cell, fake_service, False)
expected_response = cells_utils.ServiceProxy(fake_service, fake_cell)
cell_and_host = cells_utils.cell_with_item('fake-cell', 'fake-host')
params_to_update = {'disabled': True}
self.mox.StubOutWithMock(self.msg_runner, 'service_update')
self.mox.StubOutWithMock(cells_utils, 'add_cell_to_service')
self.msg_runner.service_update(self.ctxt,
fake_cell, 'fake-host', 'patron-api',
params_to_update).AndReturn(fake_response)
cells_utils.add_cell_to_service(fake_service, fake_cell).AndReturn(
expected_response)
self.mox.ReplayAll()
response = self.cells_manager.service_update(
self.ctxt, host_name=cell_and_host, binary='patron-api',
params_to_update=params_to_update)
self.assertEqual(expected_response, response)
def setUp(self):
super(ServicesCellsTestV21, self).setUp()
host_api = cells_api.HostAPI()
self.ext_mgr = extensions.ExtensionManager()
self.ext_mgr.extensions = {}
self._set_up_controller()
self.controller.host_api = host_api
self.stubs.Set(timeutils, "utcnow", fake_utcnow)
self.stubs.Set(timeutils, "utcnow_ts", fake_utcnow_ts)
services_list = []
for service in fake_services_list:
service = service.copy()
service_obj = objects.Service(**service)
service_proxy = cells_utils.ServiceProxy(service_obj, 'cell1')
services_list.append(service_proxy)
self.stubs.Set(host_api.cells_rpcapi, "service_get_all",
fake_service_get_all(services_list))
class CellHypervisorsTestV21(HypervisorsTestV21):
cell_path = 'cell1'
TEST_HYPERS_OBJ = [
cells_utils.ComputeNodeProxy(obj, cell_path) for obj in TEST_HYPERS_OBJ
]
TEST_SERVICES = [
cells_utils.ServiceProxy(obj, cell_path) for obj in TEST_SERVICES
]
TEST_SERVERS = [
dict(server,
host=cells_utils.cell_with_item(cell_path, server['host']))
for server in TEST_SERVERS
]
DETAIL_HYPERS_DICTS = copy.deepcopy(HypervisorsTestV21.DETAIL_HYPERS_DICTS)
DETAIL_HYPERS_DICTS = [
dict(hyp,
id=cells_utils.cell_with_item(cell_path, hyp['id']),
service=dict(
hyp['service'],
id=cells_utils.cell_with_item(cell_path,
hyp['service']['id']),
host=cells_utils.cell_with_item(cell_path,
hyp['service']['host'])))
for hyp in DETAIL_HYPERS_DICTS
]
INDEX_HYPER_DICTS = copy.deepcopy(HypervisorsTestV21.INDEX_HYPER_DICTS)
INDEX_HYPER_DICTS = [
dict(hyp, id=cells_utils.cell_with_item(cell_path, hyp['id']))
for hyp in INDEX_HYPER_DICTS
]
@classmethod
def fake_compute_node_get_all(cls, context):
return cls.TEST_HYPERS_OBJ
@classmethod
def fake_compute_node_search_by_hypervisor(cls, context, hypervisor_re):
return cls.TEST_HYPERS_OBJ
@classmethod
def fake_compute_node_get(cls, context, compute_id):
for hyper in cls.TEST_HYPERS_OBJ:
if hyper.id == compute_id:
return hyper
raise exception.ComputeHostNotFound(host=compute_id)
@classmethod
def fake_service_get_by_compute_host(cls, context, host):
for service in cls.TEST_SERVICES:
if service.host == host:
return service
@classmethod
def fake_instance_get_all_by_host(cls, context, host):
results = []
for inst in cls.TEST_SERVERS:
if inst['host'] == host:
results.append(inst)
return results
def setUp(self):
self.flags(enable=True, cell_type='api', group='cells')
super(CellHypervisorsTestV21, self).setUp()
self.stubs.Set(self.controller.host_api, 'compute_node_get_all',
self.fake_compute_node_get_all)
self.stubs.Set(self.controller.host_api, 'service_get_by_compute_host',
self.fake_service_get_by_compute_host)
self.stubs.Set(self.controller.host_api,
'compute_node_search_by_hypervisor',
self.fake_compute_node_search_by_hypervisor)
self.stubs.Set(self.controller.host_api, 'compute_node_get',
self.fake_compute_node_get)
self.stubs.Set(self.controller.host_api, 'compute_node_statistics',
fake_compute_node_statistics)
self.stubs.Set(self.controller.host_api, 'instance_get_all_by_host',
self.fake_instance_get_all_by_host)