def _setup_attrs(self, up=True):
mid_cell = 'child-cell2'
if up:
src_cell = 'grandchild-cell1'
tgt_cell = 'api-cell'
else:
src_cell = 'api-cell'
tgt_cell = 'grandchild-cell1'
self.src_msg_runner = fakes.get_message_runner(src_cell)
methods_cls = self.src_msg_runner.methods_by_type['broadcast']
self.src_methods_cls = methods_cls
self.src_db_inst = methods_cls.db
self.src_compute_api = methods_cls.compute_api
self.mid_msg_runner = fakes.get_message_runner(mid_cell)
methods_cls = self.mid_msg_runner.methods_by_type['broadcast']
self.mid_methods_cls = methods_cls
self.mid_db_inst = methods_cls.db
self.mid_compute_api = methods_cls.compute_api
self.tgt_msg_runner = fakes.get_message_runner(tgt_cell)
methods_cls = self.tgt_msg_runner.methods_by_type['broadcast']
self.tgt_methods_cls = methods_cls
self.tgt_db_inst = methods_cls.db
self.tgt_compute_api = methods_cls.compute_api
def _setup_attrs(self, up=True):
mid_cell = 'child-cell2'
if up:
src_cell = 'grandchild-cell1'
tgt_cell = 'api-cell'
else:
src_cell = 'api-cell'
tgt_cell = 'grandchild-cell1'
self.src_msg_runner = fakes.get_message_runner(src_cell)
methods_cls = self.src_msg_runner.methods_by_type['broadcast']
self.src_methods_cls = methods_cls
self.src_db_inst = methods_cls.db
self.src_compute_api = methods_cls.compute_api
self.mid_msg_runner = fakes.get_message_runner(mid_cell)
methods_cls = self.mid_msg_runner.methods_by_type['broadcast']
self.mid_methods_cls = methods_cls
self.mid_db_inst = methods_cls.db
self.mid_compute_api = methods_cls.compute_api
self.tgt_msg_runner = fakes.get_message_runner(tgt_cell)
methods_cls = self.tgt_msg_runner.methods_by_type['broadcast']
self.tgt_methods_cls = methods_cls
self.tgt_db_inst = methods_cls.db
self.tgt_compute_api = methods_cls.compute_api
def _setup_attrs(self, up=True):
mid_cell = 'child-cell2'
if up:
src_cell = 'grandchild-cell1'
tgt_cell = 'api-cell'
else:
src_cell = 'api-cell'
tgt_cell = 'grandchild-cell1'
self.src_msg_runner = fakes.get_message_runner(src_cell)
methods_cls = self.src_msg_runner.methods_by_type['broadcast']
self.src_methods_cls = methods_cls
self.src_db_inst = methods_cls.db
self.src_compute_api = methods_cls.compute_api
if not up:
# fudge things so we only have 1 child to broadcast to
state_manager = self.src_msg_runner.state_manager
for cell in state_manager.get_child_cells():
if cell.name != 'child-cell2':
del state_manager.child_cells[cell.name]
self.mid_msg_runner = fakes.get_message_runner(mid_cell)
methods_cls = self.mid_msg_runner.methods_by_type['broadcast']
self.mid_methods_cls = methods_cls
self.mid_db_inst = methods_cls.db
self.mid_compute_api = methods_cls.compute_api
self.tgt_msg_runner = fakes.get_message_runner(tgt_cell)
methods_cls = self.tgt_msg_runner.methods_by_type['broadcast']
self.tgt_methods_cls = methods_cls
self.tgt_db_inst = methods_cls.db
self.tgt_compute_api = methods_cls.compute_api
def test_process_message(self):
msg_runner = fakes.get_message_runner('api-cell')
dispatcher = rpc_driver.InterCellRPCDispatcher(msg_runner)
message = messaging._BroadcastMessage(msg_runner,
self.ctxt,
'fake', {},
'down',
fanout=True)
call_info = {}
def _fake_message_from_json(json_message):
call_info['json_message'] = json_message
self.assertEqual(message.to_json(), json_message)
return message
def _fake_process():
call_info['process_called'] = True
self.stubs.Set(msg_runner, 'message_from_json',
_fake_message_from_json)
self.stubs.Set(message, 'process', _fake_process)
dispatcher.process_message(self.ctxt, message.to_json())
self.assertEqual(message.to_json(), call_info['json_message'])
self.assertTrue(call_info['process_called'])
def test_create_broadcast_message_with_response(self):
self.flags(max_hop_count=99, group='cells')
our_name = 'child-cell1'
msg_runner = fakes.get_message_runner(our_name)
method = 'fake_method'
method_kwargs = dict(arg1=1, arg2=2)
direction = 'up'
bcast_message = messaging._BroadcastMessage(msg_runner,
self.ctxt,
method,
method_kwargs,
direction,
need_response=True)
self.assertEqual(self.ctxt, bcast_message.ctxt)
self.assertEqual(method, bcast_message.method_name)
self.assertEqual(method_kwargs, bcast_message.method_kwargs)
self.assertEqual(direction, bcast_message.direction)
self.assertFalse(bcast_message.fanout)
self.assertTrue(bcast_message.need_response)
self.assertEqual(our_name, bcast_message.routing_path)
self.assertEqual(1, bcast_message.hop_count)
self.assertEqual(99, bcast_message.max_hop_count)
self.assertTrue(bcast_message.is_broadcast)
# Correct next hops?
next_hops = bcast_message._get_next_hops()
parent_cells = msg_runner.state_manager.get_parent_cells()
self.assertEqual(parent_cells, next_hops)
def _init_cells_scheduler(self):
fakes.init(self)
self.msg_runner = fakes.get_message_runner('api-cell')
self.scheduler = self.msg_runner.scheduler
self.state_manager = self.msg_runner.state_manager
self.my_cell_state = self.state_manager.get_my_state()
self.ctxt = context.RequestContext('fake', 'fake')
instance_uuids = []
for x in xrange(3):
instance_uuids.append(uuidutils.generate_uuid())
self.instance_uuids = instance_uuids
self.instances = [{'uuid': uuid} for uuid in instance_uuids]
self.request_spec = {
'instance_uuids': instance_uuids,
'instance_properties': 'fake_properties',
'instance_type': 'fake_type',
'image': 'fake_image',
'security_group': 'fake_sec_groups',
'block_device_mapping': 'fake_bdm'}
self.build_inst_kwargs = {
'instances': self.instances,
'image': 'fake_image',
'filter_properties': {'instance_type': 'fake_type'},
'security_groups': 'fake_sec_groups',
'block_device_mapping': 'fake_bdm'}
def test_rpc_topic_uses_message_type(self):
self.flags(rpc_driver_queue_base='cells.intercell42', group='cells')
msg_runner = fakes.get_message_runner('api-cell')
cell_state = fakes.get_cell_state('api-cell', 'child-cell2')
message = messaging._BroadcastMessage(msg_runner,
self.ctxt, 'fake', {}, 'down', fanout=True)
message.message_type = 'fake-message-type'
expected_server_params = {'hostname': 'rpc_host2',
'password': '******',
'port': 3092,
'username': '******',
'virtual_host': 'rpc_vhost2'}
expected_url = ('rabbit://%(username)s:%(password)s@'
'%(hostname)s:%(port)d/%(virtual_host)s' %
expected_server_params)
def check_transport_url(cell_state):
return cell_state.db_info['transport_url'] == expected_url
rpcapi = self.driver.intercell_rpcapi
rpcclient = self.mox.CreateMockAnything()
self.mox.StubOutWithMock(rpcapi, '_get_client')
rpcapi._get_client(
mox.Func(check_transport_url),
'cells.intercell42.fake-message-type').AndReturn(rpcclient)
rpcclient.prepare(fanout=True).AndReturn(rpcclient)
rpcclient.cast(mox.IgnoreArg(), 'process_message',
message=message.to_json())
self.mox.ReplayAll()
self.driver.send_message_to_cell(cell_state, message)
def test_send_message_to_cell_cast(self):
msg_runner = fakes.get_message_runner('api-cell')
cell_state = fakes.get_cell_state('api-cell', 'child-cell2')
message = messaging._TargetedMessage(msg_runner,
self.ctxt, 'fake', {}, 'down', cell_state, fanout=False)
expected_server_params = {'hostname': 'rpc_host2',
'password': '******',
'port': 3092,
'username': '******',
'virtual_host': 'rpc_vhost2'}
expected_url = ('rabbit://%(username)s:%(password)s@'
'%(hostname)s:%(port)d/%(virtual_host)s' %
expected_server_params)
def check_transport_url(cell_state):
return cell_state.db_info['transport_url'] == expected_url
rpcapi = self.driver.intercell_rpcapi
rpcclient = self.mox.CreateMockAnything()
self.mox.StubOutWithMock(rpcapi, '_get_client')
rpcapi._get_client(
mox.Func(check_transport_url),
'cells.intercell.targeted').AndReturn(rpcclient)
rpcclient.cast(mox.IgnoreArg(), 'process_message',
message=message.to_json())
self.mox.ReplayAll()
self.driver.send_message_to_cell(cell_state, message)
def _init_cells_scheduler(self):
fakes.init(self)
self.msg_runner = fakes.get_message_runner('api-cell')
self.scheduler = self.msg_runner.scheduler
self.state_manager = self.msg_runner.state_manager
self.my_cell_state = self.state_manager.get_my_state()
self.ctxt = context.RequestContext('fake', 'fake')
instance_uuids = []
for x in xrange(3):
instance_uuids.append(uuidutils.generate_uuid())
self.instance_uuids = instance_uuids
self.instances = [{'uuid': uuid} for uuid in instance_uuids]
self.request_spec = {
'instance_uuids': instance_uuids,
'instance_properties': 'fake_properties',
'instance_type': 'fake_type',
'image': 'fake_image',
'security_group': 'fake_sec_groups',
'block_device_mapping': 'fake_bdm'
}
self.build_inst_kwargs = {
'instances': self.instances,
'image': 'fake_image',
'filter_properties': {
'instance_type': 'fake_type'
},
'security_groups': 'fake_sec_groups',
'block_device_mapping': 'fake_bdm'
}
def _init_cells_scheduler(self):
fakes.init(self)
self.msg_runner = fakes.get_message_runner("api-cell")
self.scheduler = self.msg_runner.scheduler
self.state_manager = self.msg_runner.state_manager
self.my_cell_state = self.state_manager.get_my_state()
self.ctxt = context.RequestContext("fake", "fake")
instance_uuids = []
for x in xrange(3):
instance_uuids.append(uuidutils.generate_uuid())
self.instance_uuids = instance_uuids
self.instances = [{"uuid": uuid} for uuid in instance_uuids]
self.request_spec = {
"instance_uuids": instance_uuids,
"instance_properties": "fake_properties",
"instance_type": "fake_type",
"image": "fake_image",
"security_group": "fake_sec_groups",
"block_device_mapping": "fake_bdm",
}
self.build_inst_kwargs = {
"instances": self.instances,
"image": "fake_image",
"filter_properties": {"instance_type": "fake_type"},
"security_groups": "fake_sec_groups",
"block_device_mapping": "fake_bdm",
}
def test_broadcast_routing_up(self):
method = 'our_fake_method'
method_kwargs = dict(arg1=1, arg2=2)
direction = 'up'
msg_runner = fakes.get_message_runner('grandchild-cell3')
cells = set()
def our_fake_method(message, **kwargs):
cells.add(message.routing_path)
fakes.stub_bcast_methods(self, 'our_fake_method', our_fake_method)
bcast_message = messaging._BroadcastMessage(msg_runner,
self.ctxt,
method,
method_kwargs,
direction,
run_locally=True)
bcast_message.process()
# Paths are reversed, since going 'up'
expected = set([
'grandchild-cell3', 'grandchild-cell3!child-cell3',
'grandchild-cell3!child-cell3!api-cell'
])
self.assertEqual(expected, cells)
def test_create_targeted_message_with_response(self):
self.flags(max_hop_count=99, group='cells')
our_name = 'child-cell1'
target_cell = 'child-cell1!api-cell'
msg_runner = fakes.get_message_runner(our_name)
method = 'fake_method'
method_kwargs = dict(arg1=1, arg2=2)
direction = 'up'
tgt_message = messaging._TargetedMessage(msg_runner,
self.ctxt,
method,
method_kwargs,
direction,
target_cell,
need_response=True)
self.assertEqual(self.ctxt, tgt_message.ctxt)
self.assertEqual(method, tgt_message.method_name)
self.assertEqual(method_kwargs, tgt_message.method_kwargs)
self.assertEqual(direction, tgt_message.direction)
self.assertEqual(target_cell, target_cell)
self.assertFalse(tgt_message.fanout)
self.assertTrue(tgt_message.need_response)
self.assertEqual(our_name, tgt_message.routing_path)
self.assertEqual(1, tgt_message.hop_count)
self.assertEqual(99, tgt_message.max_hop_count)
self.assertFalse(tgt_message.is_broadcast)
# Correct next hop?
next_hop = tgt_message._get_next_hop()
parent_cell = msg_runner.state_manager.get_parent_cell('api-cell')
self.assertEqual(parent_cell, next_hop)
def test_create_targeted_message_with_response(self):
self.flags(max_hop_count=99, group='cells')
our_name = 'child-cell1'
target_cell = 'child-cell1!api-cell'
msg_runner = fakes.get_message_runner(our_name)
method = 'fake_method'
method_kwargs = dict(arg1=1, arg2=2)
direction = 'up'
tgt_message = messaging._TargetedMessage(msg_runner,
self.ctxt, method,
method_kwargs, direction,
target_cell,
need_response=True)
self.assertEqual(self.ctxt, tgt_message.ctxt)
self.assertEqual(method, tgt_message.method_name)
self.assertEqual(method_kwargs, tgt_message.method_kwargs)
self.assertEqual(direction, tgt_message.direction)
self.assertEqual(target_cell, target_cell)
self.assertFalse(tgt_message.fanout)
self.assertTrue(tgt_message.need_response)
self.assertEqual(our_name, tgt_message.routing_path)
self.assertEqual(1, tgt_message.hop_count)
self.assertEqual(99, tgt_message.max_hop_count)
self.assertFalse(tgt_message.is_broadcast)
# Correct next hop?
next_hop = tgt_message._get_next_hop()
parent_cell = msg_runner.state_manager.get_parent_cell('api-cell')
self.assertEqual(parent_cell, next_hop)
def setUp(self):
super(_FilterTestClass, self).setUp()
fakes.init(self)
self.msg_runner = fakes.get_message_runner("api-cell")
self.scheduler = self.msg_runner.scheduler
self.my_cell_state = self.msg_runner.state_manager.get_my_state()
self.filter_handler = filters.CellFilterHandler()
self.filter_classes = self.filter_handler.get_matching_classes([self.filter_cls_name])
self.context = context.RequestContext("fake", "fake", is_admin=True)
def setUp(self):
super(_FilterTestClass, self).setUp()
fakes.init(self)
self.msg_runner = fakes.get_message_runner('api-cell')
self.scheduler = self.msg_runner.scheduler
self.my_cell_state = self.msg_runner.state_manager.get_my_state()
self.filter_handler = filters.CellFilterHandler()
self.filter_classes = self.filter_handler.get_matching_classes(
[self.filter_cls_name])
self.context = context.RequestContext('fake', 'fake', is_admin=True)
def setUp(self):
super(CellsMessageClassesTestCase, self).setUp()
fakes.init(self)
self.ctxt = context.RequestContext('fake', 'fake')
# Need to be able to deserialize test.TestingException.
allowed_modules = CONF.allowed_rpc_exception_modules
allowed_modules.append('nova.test')
self.flags(allowed_rpc_exception_modules=allowed_modules)
self.our_name = 'api-cell'
self.msg_runner = fakes.get_message_runner(self.our_name)
self.state_manager = self.msg_runner.state_manager
def setUp(self):
super(CellsMessageClassesTestCase, self).setUp()
fakes.init(self)
self.ctxt = context.RequestContext('fake', 'fake')
# Need to be able to deserialize test.TestingException.
allowed_modules = CONF.allowed_rpc_exception_modules
allowed_modules.append('nova.test')
self.flags(allowed_rpc_exception_modules=allowed_modules)
self.our_name = 'api-cell'
self.msg_runner = fakes.get_message_runner(self.our_name)
self.state_manager = self.msg_runner.state_manager
def _init_cells_scheduler(self):
fakes.init(self)
self.msg_runner = fakes.get_message_runner("api-cell")
self.scheduler = self.msg_runner.scheduler
self.state_manager = self.msg_runner.state_manager
self.my_cell_state = self.state_manager.get_my_state()
self.ctxt = context.RequestContext("fake", "fake")
instance_uuids = []
for x in xrange(3):
instance_uuids.append(uuidutils.generate_uuid())
self.instance_uuids = instance_uuids
self.request_spec = {"instance_uuids": instance_uuids, "other": "stuff"}
def _setup_attrs(self, source_cell, target_cell):
self.tgt_cell_name = target_cell
self.src_msg_runner = fakes.get_message_runner(source_cell)
self.src_state_manager = self.src_msg_runner.state_manager
tgt_shortname = target_cell.split('!')[-1]
self.tgt_cell_mgr = fakes.get_cells_manager(tgt_shortname)
self.tgt_msg_runner = self.tgt_cell_mgr.msg_runner
self.tgt_scheduler = self.tgt_msg_runner.scheduler
self.tgt_state_manager = self.tgt_msg_runner.state_manager
methods_cls = self.tgt_msg_runner.methods_by_type['targeted']
self.tgt_methods_cls = methods_cls
self.tgt_compute_api = methods_cls.compute_api
self.tgt_db_inst = methods_cls.db
def _setup_attrs(self, source_cell, target_cell):
self.tgt_cell_name = target_cell
self.src_msg_runner = fakes.get_message_runner(source_cell)
self.src_state_manager = self.src_msg_runner.state_manager
tgt_shortname = target_cell.split('!')[-1]
self.tgt_cell_mgr = fakes.get_cells_manager(tgt_shortname)
self.tgt_msg_runner = self.tgt_cell_mgr.msg_runner
self.tgt_scheduler = self.tgt_msg_runner.scheduler
self.tgt_state_manager = self.tgt_msg_runner.state_manager
methods_cls = self.tgt_msg_runner.methods_by_type['targeted']
self.tgt_methods_cls = methods_cls
self.tgt_compute_api = methods_cls.compute_api
self.tgt_db_inst = methods_cls.db
def setUp(self):
super(CellsSchedulerTestCase, self).setUp()
fakes.init(self)
self.msg_runner = fakes.get_message_runner('api-cell')
self.scheduler = self.msg_runner.scheduler
self.state_manager = self.msg_runner.state_manager
self.my_cell_state = self.state_manager.get_my_state()
self.ctxt = context.RequestContext('fake', 'fake')
instance_uuids = []
for x in xrange(3):
instance_uuids.append(uuidutils.generate_uuid())
self.instance_uuids = instance_uuids
self.request_spec = {'instance_uuids': instance_uuids,
'other': 'stuff'}
def test_send_message_to_cell_fanout_cast(self):
msg_runner = fakes.get_message_runner('api-cell')
cell_state = fakes.get_cell_state('api-cell', 'child-cell2')
message = messaging._TargetedMessage(msg_runner,
self.ctxt,
'fake',
'fake',
'down',
cell_state,
fanout=True)
call_info = {}
def _fake_make_msg(method, **kwargs):
call_info['rpc_method'] = method
call_info['rpc_kwargs'] = kwargs
return 'fake-message'
def _fake_fanout_cast_to_server(*args, **kwargs):
call_info['cast_args'] = args
call_info['cast_kwargs'] = kwargs
self.stubs.Set(rpc, 'fanout_cast_to_server',
_fake_fanout_cast_to_server)
self.stubs.Set(self.driver.intercell_rpcapi, 'make_msg',
_fake_make_msg)
self.stubs.Set(self.driver.intercell_rpcapi, 'fanout_cast_to_server',
_fake_fanout_cast_to_server)
self.driver.send_message_to_cell(cell_state, message)
expected_server_params = {
'hostname': 'rpc_host2',
'password': '******',
'port': 'rpc_port2',
'username': '******',
'virtual_host': 'rpc_vhost2'
}
expected_cast_args = (self.ctxt, expected_server_params,
'fake-message')
expected_cast_kwargs = {'topic': 'cells.intercell.targeted'}
expected_rpc_kwargs = {'message': message.to_json()}
self.assertEqual(expected_cast_args, call_info['cast_args'])
self.assertEqual(expected_cast_kwargs, call_info['cast_kwargs'])
self.assertEqual('process_message', call_info['rpc_method'])
self.assertEqual(expected_rpc_kwargs, call_info['rpc_kwargs'])
def test_start_consumers(self):
self.flags(rpc_driver_queue_base='cells.intercell42', group='cells')
rpc_consumers = []
rpc_conns = []
fake_msg_runner = fakes.get_message_runner('api-cell')
call_info = {}
class FakeInterCellRPCDispatcher(object):
def __init__(_self, msg_runner):
self.assertEqual(fake_msg_runner, msg_runner)
call_info['intercell_dispatcher'] = _self
class FakeRPCDispatcher(object):
def __init__(_self, proxy_objs):
self.assertEqual([call_info['intercell_dispatcher']],
proxy_objs)
call_info['rpc_dispatcher'] = _self
class FakeRPCConn(object):
def create_consumer(_self, topic, proxy_obj, **kwargs):
self.assertEqual(call_info['rpc_dispatcher'], proxy_obj)
rpc_consumers.append((topic, kwargs))
def consume_in_thread(_self):
pass
def _fake_create_connection(new):
self.assertTrue(new)
fake_conn = FakeRPCConn()
rpc_conns.append(fake_conn)
return fake_conn
self.stubs.Set(rpc, 'create_connection', _fake_create_connection)
self.stubs.Set(rpc_driver, 'InterCellRPCDispatcher',
FakeInterCellRPCDispatcher)
self.stubs.Set(rpc_dispatcher, 'RpcDispatcher', FakeRPCDispatcher)
self.driver.start_consumers(fake_msg_runner)
for message_type in ['broadcast', 'response', 'targeted']:
topic = 'cells.intercell42.' + message_type
self.assertIn((topic, {'fanout': True}), rpc_consumers)
self.assertIn((topic, {'fanout': False}), rpc_consumers)
self.assertEqual(rpc_conns, self.driver.rpc_connections)
def test_start_consumers(self):
self.flags(rpc_driver_queue_base='cells.intercell42', group='cells')
rpc_consumers = []
rpc_conns = []
fake_msg_runner = fakes.get_message_runner('api-cell')
call_info = {}
class FakeInterCellRPCDispatcher(object):
def __init__(_self, msg_runner):
self.assertEqual(fake_msg_runner, msg_runner)
call_info['intercell_dispatcher'] = _self
class FakeRPCDispatcher(object):
def __init__(_self, proxy_objs):
self.assertEqual([call_info['intercell_dispatcher']],
proxy_objs)
call_info['rpc_dispatcher'] = _self
class FakeRPCConn(object):
def create_consumer(_self, topic, proxy_obj, **kwargs):
self.assertEqual(call_info['rpc_dispatcher'], proxy_obj)
rpc_consumers.append((topic, kwargs))
def consume_in_thread(_self):
pass
def _fake_create_connection(new):
self.assertTrue(new)
fake_conn = FakeRPCConn()
rpc_conns.append(fake_conn)
return fake_conn
self.stubs.Set(rpc, 'create_connection', _fake_create_connection)
self.stubs.Set(rpc_driver, 'InterCellRPCDispatcher',
FakeInterCellRPCDispatcher)
self.stubs.Set(rpc_dispatcher, 'RpcDispatcher', FakeRPCDispatcher)
self.driver.start_consumers(fake_msg_runner)
for message_type in ['broadcast', 'response', 'targeted']:
topic = 'cells.intercell42.' + message_type
self.assertIn((topic, {'fanout': True}), rpc_consumers)
self.assertIn((topic, {'fanout': False}), rpc_consumers)
self.assertEqual(rpc_conns, self.driver.rpc_connections)
def test_rpc_topic_uses_message_type(self):
self.flags(rpc_driver_queue_base='cells.intercell42', group='cells')
msg_runner = fakes.get_message_runner('api-cell')
cell_state = fakes.get_cell_state('api-cell', 'child-cell2')
message = messaging._BroadcastMessage(msg_runner,
self.ctxt, 'fake', 'fake', 'down', fanout=True)
message.message_type = 'fake-message-type'
call_info = {}
def _fake_fanout_cast_to_server(*args, **kwargs):
call_info['topic'] = kwargs.get('topic')
self.stubs.Set(self.driver.intercell_rpcapi,
'fanout_cast_to_server', _fake_fanout_cast_to_server)
self.driver.send_message_to_cell(cell_state, message)
self.assertEqual('cells.intercell42.fake-message-type',
call_info['topic'])
def test_rpc_topic_uses_message_type(self):
self.flags(rpc_driver_queue_base='cells.intercell42', group='cells')
msg_runner = fakes.get_message_runner('api-cell')
cell_state = fakes.get_cell_state('api-cell', 'child-cell2')
message = messaging._BroadcastMessage(msg_runner,
self.ctxt,
'fake', {},
'down',
fanout=True)
message.message_type = 'fake-message-type'
call_info = {}
def _fake_fanout_cast_to_server(*args, **kwargs):
call_info['topic'] = kwargs.get('topic')
self.stubs.Set(self.driver.intercell_rpcapi, 'fanout_cast_to_server',
_fake_fanout_cast_to_server)
self.driver.send_message_to_cell(cell_state, message)
self.assertEqual('cells.intercell42.fake-message-type',
call_info['topic'])
def test_broadcast_routing_up(self):
method = 'our_fake_method'
method_kwargs = dict(arg1=1, arg2=2)
direction = 'up'
msg_runner = fakes.get_message_runner('grandchild-cell3')
cells = set()
def our_fake_method(message, **kwargs):
cells.add(message.routing_path)
fakes.stub_bcast_methods(self, 'our_fake_method', our_fake_method)
bcast_message = messaging._BroadcastMessage(msg_runner, self.ctxt,
method, method_kwargs,
direction,
run_locally=True)
bcast_message.process()
# Paths are reversed, since going 'up'
expected = set(['grandchild-cell3', 'grandchild-cell3!child-cell3',
'grandchild-cell3!child-cell3!api-cell'])
self.assertEqual(expected, cells)
def test_send_message_to_cell_fanout_cast(self):
msg_runner = fakes.get_message_runner('api-cell')
cell_state = fakes.get_cell_state('api-cell', 'child-cell2')
message = messaging._TargetedMessage(msg_runner,
self.ctxt, 'fake', 'fake', 'down', cell_state, fanout=True)
call_info = {}
def _fake_make_msg(method, **kwargs):
call_info['rpc_method'] = method
call_info['rpc_kwargs'] = kwargs
return 'fake-message'
def _fake_fanout_cast_to_server(*args, **kwargs):
call_info['cast_args'] = args
call_info['cast_kwargs'] = kwargs
self.stubs.Set(rpc, 'fanout_cast_to_server',
_fake_fanout_cast_to_server)
self.stubs.Set(self.driver.intercell_rpcapi, 'make_msg',
_fake_make_msg)
self.stubs.Set(self.driver.intercell_rpcapi,
'fanout_cast_to_server', _fake_fanout_cast_to_server)
self.driver.send_message_to_cell(cell_state, message)
expected_server_params = {'hostname': 'rpc_host2',
'password': '******',
'port': 'rpc_port2',
'username': '******',
'virtual_host': 'rpc_vhost2'}
expected_cast_args = (self.ctxt, expected_server_params,
'fake-message')
expected_cast_kwargs = {'topic': 'cells.intercell.targeted'}
expected_rpc_kwargs = {'message': message.to_json()}
self.assertEqual(expected_cast_args, call_info['cast_args'])
self.assertEqual(expected_cast_kwargs, call_info['cast_kwargs'])
self.assertEqual('process_message', call_info['rpc_method'])
self.assertEqual(expected_rpc_kwargs, call_info['rpc_kwargs'])
def test_process_message(self):
msg_runner = fakes.get_message_runner('api-cell')
dispatcher = rpc_driver.InterCellRPCDispatcher(msg_runner)
message = messaging._BroadcastMessage(msg_runner,
self.ctxt, 'fake', {}, 'down', fanout=True)
call_info = {}
def _fake_message_from_json(json_message):
call_info['json_message'] = json_message
self.assertEqual(message.to_json(), json_message)
return message
def _fake_process():
call_info['process_called'] = True
self.stubs.Set(msg_runner, 'message_from_json',
_fake_message_from_json)
self.stubs.Set(message, 'process', _fake_process)
dispatcher.process_message(self.ctxt, message.to_json())
self.assertEqual(message.to_json(), call_info['json_message'])
self.assertTrue(call_info['process_called'])
def test_create_broadcast_message_with_response(self):
self.flags(max_hop_count=99, group='cells')
our_name = 'child-cell1'
msg_runner = fakes.get_message_runner(our_name)
method = 'fake_method'
method_kwargs = dict(arg1=1, arg2=2)
direction = 'up'
bcast_message = messaging._BroadcastMessage(msg_runner, self.ctxt,
method, method_kwargs, direction, need_response=True)
self.assertEqual(self.ctxt, bcast_message.ctxt)
self.assertEqual(method, bcast_message.method_name)
self.assertEqual(method_kwargs, bcast_message.method_kwargs)
self.assertEqual(direction, bcast_message.direction)
self.assertFalse(bcast_message.fanout)
self.assertTrue(bcast_message.need_response)
self.assertEqual(our_name, bcast_message.routing_path)
self.assertEqual(1, bcast_message.hop_count)
self.assertEqual(99, bcast_message.max_hop_count)
self.assertTrue(bcast_message.is_broadcast)
# Correct next hops?
next_hops = bcast_message._get_next_hops()
parent_cells = msg_runner.state_manager.get_parent_cells()
self.assertEqual(parent_cells, next_hops)
def test_start_servers(self):
self.flags(rpc_driver_queue_base='cells.intercell42', group='cells')
fake_msg_runner = fakes.get_message_runner('api-cell')
class FakeInterCellRPCDispatcher(object):
def __init__(_self, msg_runner):
self.assertEqual(fake_msg_runner, msg_runner)
self.stubs.Set(rpc_driver, 'InterCellRPCDispatcher',
FakeInterCellRPCDispatcher)
self.mox.StubOutWithMock(rpc, 'get_server')
for message_type in messaging.MessageRunner.get_message_types():
topic = 'cells.intercell42.' + message_type
target = oslo_messaging.Target(topic=topic, server=CONF.host)
endpoints = [mox.IsA(FakeInterCellRPCDispatcher)]
rpcserver = self.mox.CreateMockAnything()
rpc.get_server(target, endpoints=endpoints).AndReturn(rpcserver)
rpcserver.start()
self.mox.ReplayAll()
self.driver.start_servers(fake_msg_runner)
