test_long_request.py

"""Testing for long body in request."""

__author__ = 'Tempesta Technologies, Inc.'
__copyright__ = 'Copyright (C) 2022 Tempesta Technologies, Inc.'
__license__ = 'GPL2'

from framework import tester, wrk_client, external_client, deproxy_server
from helpers import control, tf_cfg, deproxy
from long_body import utils

NGINX_CONFIG = """
pid ${pid};
worker_processes  auto;

events {
    worker_connections   1024;
    use epoll;
}

http {
    keepalive_timeout ${server_keepalive_timeout};
    keepalive_requests ${server_keepalive_requests};
    sendfile         on;
    tcp_nopush       on;
    tcp_nodelay      on;

    open_file_cache max=1000;
    open_file_cache_valid 30s;
    open_file_cache_min_uses 2;
    open_file_cache_errors off;

    # [ debug | info | notice | warn | error | crit | alert | emerg ]
    # Fully disable log errors.
    error_log /dev/null emerg;

    # Disable access log altogether.
    access_log off;

    server {
        listen        ${server_ip}:8000;

        location / {
            return 200;
        }
        location /nginx_status {
            stub_status on;
        }
    }
}
"""


CONCURRENT_CONNECTIONS = int(tf_cfg.cfg.get('General', 'concurrent_connections'))


class RequestTestBase(tester.TempestaTest, base=True):
    """Base class for tests with long body in request."""
    tempesta = {
        'config': """
listen 80;
listen 443 proto=https;

server ${server_ip}:8000;

tls_certificate ${general_workdir}/tempesta.crt;
tls_certificate_key ${general_workdir}/tempesta.key;
tls_match_any_server_name;
cache 0;
"""
    }

    clients = [
        {
            'id': 'wrk-http',
            'type': 'wrk',
            'addr': '${tempesta_ip}:80',
        },
        {
            'id': 'wrk-https',
            'type': 'wrk',
            'ssl': True,
            'addr': '${tempesta_ip}:443',
        },
    ]

    backends = [
        {
            'id': 'nginx',
            'type': 'nginx',
            'port': '8000',
            'status_uri': 'http://${server_ip}:8000/nginx_status',
            'config': NGINX_CONFIG,
        },
    ]

    wrk_method: str
    wrk_path = '/'
    wrk_body: str
    client_id: str

    wrk_content = (
        'wrk.method = "%(method)s"\n'
        + 'wrk.path = "%(path)s"\n'
        + 'wrk.header = {\n'
        + '}\n'
        + 'wrk.body = "%(body)s"\n'
    )

    def setUp(self):
        """Set 'wrk' content for tests"""
        self.wrk_content = self.wrk_content % {
            'method': self.wrk_method,
            'path': self.wrk_path,
            'body': self.wrk_body,
        }
        super().setUp()

    def start_all(self):
        """Start servers, tempesta and check servers is running"""
        self.start_all_servers()
        self.start_tempesta()
        self.assertTrue(self.wait_all_connections())

    def test(self):
        """Send requests for wrk client with body and check tempesta/wrk statistic."""
        self.start_all()
        tempesta: control.Tempesta = self.get_tempesta()
        client: wrk_client.Wrk = self.get_client(self.client_id)
        client.set_script(script='request_1k', content=self.wrk_content)
        client.start()
        self.wait_while_busy(client)
        client.stop()

        tempesta.get_stats()
        results = client.results()
        statuses = client.statuses

        utils.debug_tempesta(results, tempesta)
        self.assertEqual(
            results[1],
            utils.get_sum_5xx_and_connection_errors(statuses),
            msg='HTTP client detected %i/%i errors. Results: %s' % (
                results[0], results[1], str(statuses),
            ),
        )
        self.assertTrue(
            results[0] <= tempesta.stats.cl_msg_received <= (results[0] + client.connections),
            msg='Tempesta received bad number %d of messages, expected [%d:%d]'
                % (tempesta.stats.cl_msg_received, results[0], (results[0] + client.connections)),
        )
        self.assertGreater(client.statuses[200], 0, 'Client has not received 200 responses.')


class HttpPostRequestTest1k(RequestTestBase):
    """Send many POST HTTP requests with 1k body and check tempesta/wrk statistic."""
    wrk_method = 'POST'
    wrk_body = 'x' * 1024
    client_id = 'wrk-http'


class HttpPostRequestTest1M(RequestTestBase):
    """Send many POST HTTP requests with 1M body and check tempesta/wrk statistic."""
    wrk_method = 'POST'
    wrk_body = 'x' * 1024 ** 2
    client_id = 'wrk-http'


class HttpPutRequestTest1k(RequestTestBase):
    """Send many PUT HTTP requests with 1k body and check tempesta/wrk statistic."""
    wrk_method = 'PUT'
    wrk_body = 'x' * 1024
    client_id = 'wrk-http'


class HttpPutRequestTest1M(RequestTestBase):
    """Send many PUT HTTP requests with 1M body and check tempesta/wrk statistic."""
    wrk_method = 'PUT'
    wrk_body = 'x' * 1024 ** 2
    client_id = 'wrk-http'


class HttpsPostRequestTest1k(RequestTestBase):
    """Send many POST HTTPS requests with 1k body and check tempesta/wrk statistic."""
    wrk_method = 'POST'
    wrk_body = 'x' * 1024
    client_id = 'wrk-https'


class HttpsPostRequestTest1M(RequestTestBase):
    """Send many POST HTTPS requests with 1M body and check tempesta/wrk statistic."""
    wrk_method = 'POST'
    wrk_body = 'x' * 1024 ** 2
    client_id = 'wrk-https'


class HttpsPutRequestTest1k(RequestTestBase):
    """Send many PUT HTTPS requests with 1k body and check tempesta/wrk statistic."""
    wrk_method = 'PUT'
    wrk_body = 'x' * 1024
    client_id = 'wrk-https'


class HttpsPutRequestTest1M(RequestTestBase):
    """Send many PUT HTTPS requests with 1M body and check tempesta/wrk statistic."""
    wrk_method = 'PUT'
    wrk_body = 'x' * 1024 ** 2
    client_id = 'wrk-https'


class H2RequestTestBase(tester.TempestaTest, base=True):
    """Base class for h2 tests with long body in request."""

    tempesta = {'config': """
listen 443 proto=h2;

server ${server_ip}:8000;

tls_certificate ${general_workdir}/tempesta.crt;
tls_certificate_key ${general_workdir}/tempesta.key;
tls_match_any_server_name;

cache 0;
    """}

    body = 'x' * 1024
    clients = [
        {
            'id': 'concurrent',
            'type': 'external',
            'binary': 'curl',
            'ssl': True,
            'cmd_args': (
                ' --http2-prior-knowledge'
                + ' --insecure'
                + ' --parallel'
                + ' --parallel-immediate'
                + f' --parallel-max {CONCURRENT_CONNECTIONS}'
                + f' --max-time {tf_cfg.cfg.get("General", "duration")}'
            ),
        }
    ]

    backends = [
        {
            'id': 'deproxy',
            'type': 'deproxy',
            'port': '8000',
            'response': 'static',
            'response_content': (
                'HTTP/1.1 200 OK\r\n'
                + 'Server: deproxy\r\n'
                + f'Date: {deproxy.HttpMessage.date_time_string()}\r\n'
                + 'Content-Length: 0\r\n'
                + '\r\n'
            ),
        },
    ]

    method: str
    body_length: int

    def start_all(self):
        self.start_all_servers()
        self.start_tempesta()
        self.deproxy_manager.start()
        self.assertTrue(self.wait_all_connections())

    def test_request_long_body(self):
        """Send many h2 requests with long body and """
        self.start_all()
        client: external_client.ExternalTester = self.get_client('concurrent')
        server: deproxy_server.StaticDeproxyServer = self.get_server('deproxy')
        tempesta = self.get_tempesta()

        count_requests = 10000
        client.options[0] += (
            f' -X {self.method}'
            + f" -H 'Content-Length: {self.body_length}'"
            + f" -d '{'x' * self.body_length}'"
            + f" https://127.0.0.1:443/[1-{count_requests}]"
        )

        client.start()
        self.wait_while_busy()
        client.stop()


class H2PostRequestTest1k(H2RequestTestBase):
    """Send many POST h2 requests with 1k body."""
    method = 'POST'
    body_length = 1024


class H2PutRequestTest1k(H2RequestTestBase):
    """Send many PUT h2 requests with 1k body."""
    method = 'PUT'
    body_length = 1024