Ejemplo n.º 1
0
    def test_wsgi_keep_alive(self):
        # mocking server method of eventlet.wsgi to check it is called with
        # configured 'wsgi_keep_alive' value.
        wsgi_keepalive = False
        self.config_fixture.config(group='eventlet_server',
                                   wsgi_keep_alive=wsgi_keepalive)

        server = environment.Server(mock.MagicMock(), host=self.host,
                                    port=self.port)
        with mock.patch.object(eventlet.wsgi, 'server') as mock_server:
            fake_application = uuid.uuid4().hex
            fake_socket = uuid.uuid4().hex
            server._run(fake_application, fake_socket)
            mock_server.assert_called_once_with(fake_socket,
                                                fake_application,
                                                debug=mock.ANY,
                                                socket_timeout=mock.ANY,
                                                log=mock.ANY,
                                                keepalive=wsgi_keepalive)
Ejemplo n.º 2
0
    def test_keepalive_and_keepidle_set(self, mock_getaddrinfo, mock_listen):
        mock_getaddrinfo.return_value = [(1, 2, 3, 4, 5)]
        mock_sock_dup = mock_listen.return_value.dup.return_value

        server = environment.Server(mock.MagicMock(),
                                    host=self.host,
                                    port=self.port,
                                    keepalive=True,
                                    keepidle=1)
        server.start()
        self.addCleanup(server.stop)

        self.assertEqual(2, mock_sock_dup.setsockopt.call_count)

        # Test the last set of call args i.e. for the keepidle
        mock_sock_dup.setsockopt.assert_called_with(socket.IPPROTO_TCP,
                                                    socket.TCP_KEEPIDLE, 1)

        self.assertTrue(mock_listen.called)
    def test_keepalive_and_keepidle_set(self, mock_getaddrinfo, mock_listen):
        mock_getaddrinfo.return_value = [(1, 2, 3, 4, 5)]
        mock_sock_dup = mock_listen.return_value.dup.return_value

        server = environment.Server(mock.MagicMock(), host=self.host,
                                    port=self.port, keepalive=True,
                                    keepidle=1)
        server.start()

        # keepidle isn't available in the OS X version of eventlet
        if hasattr(socket, 'TCP_KEEPIDLE'):
            self.assertEqual(mock_sock_dup.setsockopt.call_count, 2)

            # Test the last set of call args i.e. for the keepidle
            mock_sock_dup.setsockopt.assert_called_with(socket.IPPROTO_TCP,
                                                        socket.TCP_KEEPIDLE,
                                                        1)
        else:
            self.assertEqual(mock_sock_dup.setsockopt.call_count, 1)

        self.assertTrue(mock_listen.called)
Ejemplo n.º 4
0
    def serveapp(self,
                 config,
                 name=None,
                 cert=None,
                 key=None,
                 ca=None,
                 cert_required=None,
                 host="127.0.0.1",
                 port=0):
        app = self.loadapp(config, name=name)
        server = environment.Server(app, host, port)
        if cert is not None and ca is not None and key is not None:
            server.set_ssl(certfile=cert,
                           keyfile=key,
                           ca_certs=ca,
                           cert_required=cert_required)
        server.start(key='socket')

        # Service catalog tests need to know the port we ran on.
        port = server.socket_info['socket'][1]
        self.opt(public_port=port, admin_port=port)
        return server
Ejemplo n.º 5
0
    def test_client_socket_timeout(self):
        # mocking server method of eventlet.wsgi to check it is called with
        # configured 'client_socket_timeout' value.

        # setting random socket_timeout between 1 to 10, so that after given
        # seconds client connection will be closed if it is idle.
        socket_timeout = random.randint(1, 10)
        self.config_fixture.config(group='eventlet_server',
                                   client_socket_timeout=socket_timeout)
        server = environment.Server(mock.MagicMock(),
                                    host=self.host,
                                    port=self.port)
        with mock.patch.object(eventlet.wsgi, 'server') as mock_server:
            fake_application = uuid.uuid4().hex
            fake_socket = uuid.uuid4().hex
            server._run(fake_application, fake_socket)
            mock_server.assert_called_once_with(fake_socket,
                                                fake_application,
                                                debug=mock.ANY,
                                                socket_timeout=socket_timeout,
                                                log=mock.ANY,
                                                keepalive=mock.ANY)