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_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)

        rpcapi = self.driver.intercell_rpcapi
        rpcclient = mock.Mock()

        with mock.patch.object(rpcapi, '_get_client') as m_get_client:
            m_get_client.return_value = rpcclient

            rpcclient.prepare(fanout=True)
            rpcclient.prepare.return_value = rpcclient

            self.driver.send_message_to_cell(cell_state, message)
            m_get_client.assert_called_with(cell_state,
                    'cells.intercell42.fake-message-type')
            self.assertEqual(expected_url,
                             cell_state.db_info['transport_url'])
            rpcclient.prepare.assert_called_with(fanout=True)
            rpcclient.cast.assert_called_with(mock.ANY,
                                              'process_message',
                                              message=message.to_json())
    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'])
Example #4
0
    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)
Example #5
0
 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_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)
Example #7
0
    def test_broadcast_routing_with_response_max_hops(self):
        self.flags(max_hop_count=2, group='cells')
        method = 'our_fake_method'
        method_kwargs = dict(arg1=1, arg2=2)
        direction = 'down'

        def our_fake_method(message, **kwargs):
            return 'response-%s' % message.routing_path

        fakes.stub_bcast_methods(self, 'our_fake_method', our_fake_method)

        bcast_message = messaging._BroadcastMessage(self.msg_runner,
                                                    self.ctxt,
                                                    method,
                                                    method_kwargs,
                                                    direction,
                                                    run_locally=True,
                                                    need_response=True)
        responses = bcast_message.process()
        # Should only get responses from our immediate children (and
        # ourselves)
        self.assertEqual(len(responses), 5)
        for response in responses:
            self.assertFalse(response.failure)
            self.assertEqual('response-%s' % response.cell_name,
                             response.value_or_raise())
Example #8
0
    def test_broadcast_routing_with_response_max_hops(self):
        self.flags(max_hop_count=2, group='cells')
        method = 'our_fake_method'
        method_kwargs = dict(arg1=1, arg2=2)
        direction = 'down'

        def our_fake_method(message, **kwargs):
            return 'response-%s' % message.routing_path

        fakes.stub_bcast_methods(self, 'our_fake_method', our_fake_method)

        bcast_message = messaging._BroadcastMessage(self.msg_runner,
                                                    self.ctxt, method,
                                                    method_kwargs,
                                                    direction,
                                                    run_locally=True,
                                                    need_response=True)
        responses = bcast_message.process()
        # Should only get responses from our immediate children (and
        # ourselves)
        self.assertEqual(len(responses), 5)
        for response in responses:
            self.assertFalse(response.failure)
            self.assertEqual('response-%s' % response.cell_name,
                    response.value_or_raise())
Example #9
0
    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'])
Example #10
0
    def test_broadcast_routing_with_two_erroring(self):
        method = 'our_fake_method'
        method_kwargs = dict(arg1=1, arg2=2)
        direction = 'down'

        def our_fake_method_failing(message, **kwargs):
            raise test.TestingException('fake failure')

        def our_fake_method(message, **kwargs):
            return 'response-%s' % message.routing_path

        fakes.stub_bcast_methods(self, 'our_fake_method', our_fake_method)
        fakes.stub_bcast_method(self, 'child-cell2', 'our_fake_method',
                                our_fake_method_failing)
        fakes.stub_bcast_method(self, 'grandchild-cell3', 'our_fake_method',
                                our_fake_method_failing)

        bcast_message = messaging._BroadcastMessage(self.msg_runner,
                                                    self.ctxt,
                                                    method,
                                                    method_kwargs,
                                                    direction,
                                                    run_locally=True,
                                                    need_response=True)
        responses = bcast_message.process()
        self.assertEqual(len(responses), 8)
        failure_responses = [resp for resp in responses if resp.failure]
        success_responses = [resp for resp in responses if not resp.failure]
        self.assertEqual(len(failure_responses), 2)
        self.assertEqual(len(success_responses), 6)

        for response in success_responses:
            self.assertFalse(response.failure)
            self.assertEqual('response-%s' % response.cell_name,
                             response.value_or_raise())

        for response in failure_responses:
            self.assertIn(response.cell_name, [
                'api-cell!child-cell2', 'api-cell!child-cell3!grandchild-cell3'
            ])
            self.assertTrue(response.failure)
            self.assertRaises(test.TestingException, response.value_or_raise)
Example #11
0
    def test_broadcast_routing(self):
        method = 'our_fake_method'
        method_kwargs = dict(arg1=1, arg2=2)
        direction = 'down'

        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(self.msg_runner,
                                                    self.ctxt, method,
                                                    method_kwargs,
                                                    direction,
                                                    run_locally=True)
        bcast_message.process()
        # fakes creates 8 cells (including ourself).
        self.assertEqual(len(cells), 8)
Example #12
0
    def test_broadcast_routing(self):
        method = 'our_fake_method'
        method_kwargs = dict(arg1=1, arg2=2)
        direction = 'down'

        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(self.msg_runner,
                                                    self.ctxt, method,
                                                    method_kwargs,
                                                    direction,
                                                    run_locally=True)
        bcast_message.process()
        # fakes creates 8 cells (including ourself).
        self.assertEqual(len(cells), 8)
Example #13
0
    def test_broadcast_routing_with_all_erroring(self):
        method = 'our_fake_method'
        method_kwargs = dict(arg1=1, arg2=2)
        direction = 'down'

        def our_fake_method(message, **kwargs):
            raise test.TestingException('fake failure')

        fakes.stub_bcast_methods(self, 'our_fake_method', our_fake_method)

        bcast_message = messaging._BroadcastMessage(self.msg_runner,
                                                    self.ctxt, method,
                                                    method_kwargs,
                                                    direction,
                                                    run_locally=True,
                                                    need_response=True)
        responses = bcast_message.process()
        self.assertEqual(len(responses), 8)
        for response in responses:
            self.assertTrue(response.failure)
            self.assertRaises(test.TestingException, response.value_or_raise)
Example #14
0
    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"])
Example #15
0
    def test_broadcast_routing_with_all_erroring(self):
        method = 'our_fake_method'
        method_kwargs = dict(arg1=1, arg2=2)
        direction = 'down'

        def our_fake_method(message, **kwargs):
            raise test.TestingException('fake failure')

        fakes.stub_bcast_methods(self, 'our_fake_method', our_fake_method)

        bcast_message = messaging._BroadcastMessage(self.msg_runner,
                                                    self.ctxt, method,
                                                    method_kwargs,
                                                    direction,
                                                    run_locally=True,
                                                    need_response=True)
        responses = bcast_message.process()
        self.assertEqual(len(responses), 8)
        for response in responses:
            self.assertTrue(response.failure)
            self.assertRaises(test.TestingException, response.value_or_raise)
Example #16
0
    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

        msg_runner.message_from_json = _fake_message_from_json
        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'])
Example #17
0
    def test_broadcast_routing_with_two_erroring(self):
        method = 'our_fake_method'
        method_kwargs = dict(arg1=1, arg2=2)
        direction = 'down'

        def our_fake_method_failing(message, **kwargs):
            raise test.TestingException('fake failure')

        def our_fake_method(message, **kwargs):
            return 'response-%s' % message.routing_path

        fakes.stub_bcast_methods(self, 'our_fake_method', our_fake_method)
        fakes.stub_bcast_method(self, 'child-cell2', 'our_fake_method',
                                our_fake_method_failing)
        fakes.stub_bcast_method(self, 'grandchild-cell3', 'our_fake_method',
                                our_fake_method_failing)

        bcast_message = messaging._BroadcastMessage(self.msg_runner,
                                                    self.ctxt, method,
                                                    method_kwargs,
                                                    direction,
                                                    run_locally=True,
                                                    need_response=True)
        responses = bcast_message.process()
        self.assertEqual(len(responses), 8)
        failure_responses = [resp for resp in responses if resp.failure]
        success_responses = [resp for resp in responses if not resp.failure]
        self.assertEqual(len(failure_responses), 2)
        self.assertEqual(len(success_responses), 6)

        for response in success_responses:
            self.assertFalse(response.failure)
            self.assertEqual('response-%s' % response.cell_name,
                    response.value_or_raise())

        for response in failure_responses:
            self.assertIn(response.cell_name, ['api-cell!child-cell2',
                    'api-cell!child-cell3!grandchild-cell3'])
            self.assertTrue(response.failure)
            self.assertRaises(test.TestingException, response.value_or_raise)
Example #18
0
    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)
Example #19
0
    def test_broadcast_routing_with_response(self):
        method = 'our_fake_method'
        method_kwargs = dict(arg1=1, arg2=2)
        direction = 'down'

        def our_fake_method(message, **kwargs):
            return 'response-%s' % message.routing_path

        fakes.stub_bcast_methods(self, 'our_fake_method', our_fake_method)

        bcast_message = messaging._BroadcastMessage(self.msg_runner,
                                                    self.ctxt, method,
                                                    method_kwargs,
                                                    direction,
                                                    run_locally=True,
                                                    need_response=True)
        responses = bcast_message.process()
        self.assertEqual(len(responses), 8)
        for response in responses:
            self.assertFalse(response.failure)
            self.assertEqual('response-%s' % response.cell_name,
                    response.value_or_raise())
Example #20
0
    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'])
Example #21
0
    def test_broadcast_routing_with_response(self):
        method = 'our_fake_method'
        method_kwargs = dict(arg1=1, arg2=2)
        direction = 'down'

        def our_fake_method(message, **kwargs):
            return 'response-%s' % message.routing_path

        fakes.stub_bcast_methods(self, 'our_fake_method', our_fake_method)

        bcast_message = messaging._BroadcastMessage(self.msg_runner,
                                                    self.ctxt, method,
                                                    method_kwargs,
                                                    direction,
                                                    run_locally=True,
                                                    need_response=True)
        responses = bcast_message.process()
        self.assertEqual(len(responses), 8)
        for response in responses:
            self.assertFalse(response.failure)
            self.assertEqual('response-%s' % response.cell_name,
                    response.value_or_raise())
Example #22
0
 def test_create_broadcast_message(self):
     self.flags(max_hop_count=99, group='cells')
     self.flags(name='api-cell', max_hop_count=99, group='cells')
     method = 'fake_method'
     method_kwargs = dict(arg1=1, arg2=2)
     direction = 'down'
     bcast_message = messaging._BroadcastMessage(self.msg_runner, self.ctxt,
                                                 method, method_kwargs,
                                                 direction)
     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.assertFalse(bcast_message.need_response)
     self.assertEqual(self.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()
     child_cells = self.state_manager.get_child_cells()
     self.assertEqual(child_cells, next_hops)
Example #23
0
 def test_create_broadcast_message(self):
     self.flags(max_hop_count=99, group='cells')
     self.flags(name='api-cell', max_hop_count=99, group='cells')
     method = 'fake_method'
     method_kwargs = dict(arg1=1, arg2=2)
     direction = 'down'
     bcast_message = messaging._BroadcastMessage(self.msg_runner,
                                               self.ctxt, method,
                                               method_kwargs, direction)
     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.assertFalse(bcast_message.need_response)
     self.assertEqual(self.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()
     child_cells = self.state_manager.get_child_cells()
     self.assertEqual(child_cells, next_hops)
Example #24
0
 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)