def echo_server():
    mp = TMultiplexedProcessor()
    mp.registerProcessor("echo", Echoer.Processor(EchoHandler()))
    transport = TSocket.TServerSocket(port=PORT)
    tf = TTransport.TFramedTransportFactory()
    pf = TCompactProtocol.TCompactProtocolFactory()

    return TServer.TThreadedServer(mp, transport, tf, pf, daemon=True)
def echo_server():
    mp = TMultiplexedProcessor()
    mp.registerProcessor("echo", Echoer.Processor(EchoHandler()))
    transport = TSocket.TServerSocket(port=PORT)
    tf = TTransport.TFramedTransportFactory()
    pf = TCompactProtocol.TCompactProtocolFactory()

    return TServer.TThreadedServer(mp, transport, tf, pf, daemon=True)
Exemple #3
0
    def start_server(self):
        """
        Registers the host and root scheduler processors and
        starts the thrift server.
        """
        mux_processor = TMultiplexedProcessor()

        if self._hostHandler:
            self._register_processer("Host", mux_processor)

        if self._leafSchedulerHandler:
            self._register_processer("Scheduler", mux_processor)

        if self._rootSchedulerHandler:
            self._register_processer("RootScheduler", mux_processor)

        if self._enable_ping:
            self._register_processer("AgentControl", mux_processor)

        transport = TSocket.TServerSocket(self._address, self._port)

        protocol_factory = TCompactProtocol.TCompactProtocolFactory()

        self._server = TNonblockingServer(mux_processor, transport,
                                          protocol_factory, protocol_factory)

        self._thread = threading.Thread(target=self._server.serve)
        self._thread.daemon = True
        self._thread.start()
        self._server_started = True

        self._logger.info(
            "[ThriftServer] Thrift server started. Address: {0} Port: {1}".
            format(self._address, self._port))
    def test_shutdown(self):
        m_processor = TMultiplexedProcessor()
        processor = MagicMock()
        num_workers = 2
        services = ["Fake_1", "Fake_2"]
        for name in services:
            m_processor.registerProcessor(name, processor, num_workers)

        for name in services:
            self.assertEqual(len(m_processor.services[name].workers), 2)
            for worker in m_processor.services[name].workers:
                self.assertTrue(worker.is_alive())

        m_processor.shutdown()
        self.assertTrue(m_processor.shutting_down)
        for name in services:
            for worker in m_processor.services[name].workers:
                self.assertFalse(worker.is_alive())
Exemple #5
0
    def _initialize_thrift_service(self):
        """ Initialize the thrift server. """
        mux_processor = TMultiplexedProcessor()

        for plugin in thrift_services():
            self._logger.info("Load thrift services %s (num_threads: %d)",
                              plugin.name, plugin.num_threads)
            handler = plugin.handler
            processor = plugin.service.Processor(handler)
            mux_processor.registerProcessor(plugin.name, processor,
                                            plugin.num_threads,
                                            plugin.max_entries)

        transport = TSocket.TServerSocket(port=self._config.host_port)
        protocol_factory = TCompactProtocol.TCompactProtocolFactory()

        server = TNonblockingServer(
            mux_processor, transport, protocol_factory, protocol_factory)
        self._server = server
    def test_registerProcessor(self, worker, queue):
        """
        Test to check the registration of a thrift service processor.
        Validates that the right number of threads are created and that all
        threads created for the same processor share the same synchrnoized
        Queue.
        """
        test_worker = MagicMock()
        worker.return_value = test_worker

        test_queue = MagicMock()
        queue.return_value = test_queue

        m_processor = TMultiplexedProcessor()
        processor = MagicMock()

        num_workers = 2
        service_name = "Fake"
        m_processor.registerProcessor(service_name, processor, num_workers)
        queue.assert_called_once_with()
        self._check_worker_calls(service_name, num_workers, worker, test_queue)

        # Register a second processor and verify that we have a new queue
        # created, and is passed to the number of workers specified.
        num_workers = 3
        queue.reset_mock()
        worker.reset_mock()
        test_queue_1 = MagicMock()
        queue.return_value = test_queue_1
        m_processor = TMultiplexedProcessor()
        processor = MagicMock()

        m_processor.registerProcessor(service_name, processor, num_workers)
        queue.assert_called_once_with()
        self._check_worker_calls(service_name, num_workers, worker,
                                 test_queue_1)
        self.assertEqual(m_processor.services[service_name].processor,
                         processor)
        self.assertEqual(m_processor.services[service_name].name, service_name)
        self.assertEqual(m_processor.services[service_name].queue,
                         test_queue_1)
    def test_shutdown(self):
        m_processor = TMultiplexedProcessor()
        processor = MagicMock()
        num_workers = 2
        services = ["Fake_1", "Fake_2"]
        for name in services:
            m_processor.registerProcessor(name, processor, num_workers)

        for name in services:
            self.assertEqual(len(m_processor.services[name].workers), 2)
            for worker in m_processor.services[name].workers:
                self.assertTrue(worker.is_alive())

        m_processor.shutdown()
        self.assertTrue(m_processor.shutting_down)
        for name in services:
            for worker in m_processor.services[name].workers:
                self.assertFalse(worker.is_alive())
    def test_registerProcessor(self, worker, queue):
        """
        Test to check the registration of a thrift service processor.
        Validates that the right number of threads are created and that all
        threads created for the same processor share the same synchrnoized
        Queue.
        """
        test_worker = MagicMock()
        worker.return_value = test_worker

        test_queue = MagicMock()
        queue.return_value = test_queue

        m_processor = TMultiplexedProcessor()
        processor = MagicMock()

        num_workers = 2
        service_name = "Fake"
        m_processor.registerProcessor(service_name, processor, num_workers)
        queue.assert_called_once_with()
        self._check_worker_calls(service_name, num_workers, worker, test_queue)

        # Register a second processor and verify that we have a new queue
        # created, and is passed to the number of workers specified.
        num_workers = 3
        queue.reset_mock()
        worker.reset_mock()
        test_queue_1 = MagicMock()
        queue.return_value = test_queue_1
        m_processor = TMultiplexedProcessor()
        processor = MagicMock()

        m_processor.registerProcessor(service_name, processor, num_workers)
        queue.assert_called_once_with()
        self._check_worker_calls(
            service_name, num_workers, worker, test_queue_1)
        self.assertEqual(m_processor.services[service_name].processor,
                         processor)
        self.assertEqual(m_processor.services[service_name].name, service_name)
        self.assertEqual(m_processor.services[service_name].queue,
                         test_queue_1)
    def test_process_queued(self, cur_time):
        """
        Test the basic process_queued functionality.
        +ve cases
        1. Enqueues the request in the right queue for the service.
        2. Checks that the queue is not full before enqueuing the request.
        -ve cases
        1. Fails if the processor is being shutdown.
        2. Fails if the message type is not a call or one way message.
        3. Fails if there is no service type in the message specified.
        4. Fails if the service is not registered.
        5. Fails if the queue is full.
        """

        # Fake the current time
        cur_time.return_value = 5

        # Start by doing a lot of magic.
        iprot = MagicMock()
        oprot = MagicMock()
        otrans = MagicMock()
        otrans.getvalue.return_value = 0
        callback = MagicMock()

        mock_queue = MagicMock()
        mock_queue.qsize.return_value = 5
        processor = MagicMock()
        service_mock = ServiceProcessor("Fake", processor, mock_queue,
                                        MagicMock(), 10)

        m_processor = TMultiplexedProcessor()
        m_processor.services["Fake"] = service_mock

        iprot.readMessageBegin.return_value = \
            ("Fake:test", TMessageType.CALL, 3)
        standardMessage = ("test", TMessageType.CALL, 3)
        m_iprot = StoredMessageProtocol(iprot, standardMessage)
        m_processor.process_queued(iprot, oprot, otrans, callback)

        # Invoke a custom matcher so we compare equivalence and not identity
        # for the StandardMessage
        matcher = Matcher(compare_standard_msg, m_iprot)

        # assert that queue size and put were called
        mock_queue.assert_has_calls([call.qsize()])
        mock_queue.put.assert_called_with(
            [processor, matcher, oprot, otrans, callback, 5])

        # Negative tests

        # Test shutting down.
        callback.reset_mock()
        m_processor = TMultiplexedProcessor()
        m_processor.shutting_down = True
        m_processor.process_queued(iprot, oprot, otrans, callback)
        callback.assert_called_once_with(False, '')

        # Test invalid_message
        callback.reset_mock()
        iprot.readMessageBegin.return_value = \
            ("Faketest", TMessageType.CALL, 3)
        m_processor = TMultiplexedProcessor()
        m_processor.process_queued(iprot, oprot, otrans, callback)
        callback.assert_called_once_with(False, '')

        # Test unknown service
        callback.reset_mock()
        iprot.readMessageBegin.return_value = \
            ("Fake1:test", TMessageType.CALL, 3)
        m_processor = TMultiplexedProcessor()
        m_processor.process_queued(iprot, oprot, otrans, callback)
        callback.assert_called_once_with(False, '')

        # Test full queue
        callback.reset_mock()
        iprot.readMessageBegin.return_value = \
            ("Fake:test", TMessageType.CALL, 3)
        service_mock = ServiceProcessor("Fake", processor, mock_queue,
                                        MagicMock(), 10)
        m_processor = TMultiplexedProcessor()
        m_processor.services["Fake"] = service_mock
        mock_queue.qsize.return_value = 10
        m_processor.process_queued(iprot, oprot, otrans, callback)
        callback.assert_called_once_with(False, '')
    def test_process_queued(self, cur_time):
        """
        Test the basic process_queued functionality.
        +ve cases
        1. Enqueues the request in the right queue for the service.
        2. Checks that the queue is not full before enqueuing the request.
        -ve cases
        1. Fails if the processor is being shutdown.
        2. Fails if the message type is not a call or one way message.
        3. Fails if there is no service type in the message specified.
        4. Fails if the service is not registered.
        5. Fails if the queue is full.
        """

        # Fake the current time
        cur_time.return_value = 5

        # Start by doing a lot of magic.
        iprot = MagicMock()
        oprot = MagicMock()
        otrans = MagicMock()
        otrans.getvalue.return_value = 0
        callback = MagicMock()

        mock_queue = MagicMock()
        mock_queue.qsize.return_value = 5
        processor = MagicMock()
        service_mock = ServiceProcessor("Fake", processor, mock_queue,
                                        MagicMock(), 10)

        m_processor = TMultiplexedProcessor()
        m_processor.services["Fake"] = service_mock

        iprot.readMessageBegin.return_value = \
            ("Fake:test", TMessageType.CALL, 3)
        standardMessage = ("test", TMessageType.CALL, 3)
        m_iprot = StoredMessageProtocol(iprot, standardMessage)
        m_processor.process_queued(iprot, oprot, otrans, callback)

        # Invoke a custom matcher so we compare equivalence and not identity
        # for the StandardMessage
        matcher = Matcher(compare_standard_msg, m_iprot)

        # assert that queue size and put were called
        mock_queue.assert_has_calls([call.qsize()])
        mock_queue.put.assert_called_with([processor, matcher, oprot, otrans,
                                           callback, 5])

        # Negative tests

        # Test shutting down.
        callback.reset_mock()
        m_processor = TMultiplexedProcessor()
        m_processor.shutting_down = True
        m_processor.process_queued(iprot, oprot, otrans, callback)
        callback.assert_called_once_with(False, '')

        # Test invalid_message
        callback.reset_mock()
        iprot.readMessageBegin.return_value = \
            ("Faketest", TMessageType.CALL, 3)
        m_processor = TMultiplexedProcessor()
        m_processor.process_queued(iprot, oprot, otrans, callback)
        callback.assert_called_once_with(False, '')

        # Test unknown service
        callback.reset_mock()
        iprot.readMessageBegin.return_value = \
            ("Fake1:test", TMessageType.CALL, 3)
        m_processor = TMultiplexedProcessor()
        m_processor.process_queued(iprot, oprot, otrans, callback)
        callback.assert_called_once_with(False, '')

        # Test full queue
        callback.reset_mock()
        iprot.readMessageBegin.return_value = \
            ("Fake:test", TMessageType.CALL, 3)
        service_mock = ServiceProcessor("Fake", processor, mock_queue,
                                        MagicMock(), 10)
        m_processor = TMultiplexedProcessor()
        m_processor.services["Fake"] = service_mock
        mock_queue.qsize.return_value = 10
        m_processor.process_queued(iprot, oprot, otrans, callback)
        callback.assert_called_once_with(False, '')