httpmorph/benchmarks/libs/aiohttp_bench.py at a4f04e2b66c835a8096d11c2bbeee7171194a991 · arman-bd/httpmorph · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
"""aiohttp benchmark implementations"""

try:
    import aiohttp

    AVAILABLE = True
except ImportError:
    AVAILABLE = False

from .base import LibraryBenchmark


class AiohttpBenchmark(LibraryBenchmark):
    """Benchmark tests for aiohttp library"""

    def is_available(self):
        return AVAILABLE

    def get_test_matrix(self):
        return [
            ("Async Local HTTP", "async_local_http"),
            ("Async Remote HTTP", "async_remote_http"),
            ("Async Remote HTTPS", "async_remote_https"),
            ("Async Proxy HTTP", "async_proxy_http"),
            ("Async Proxy HTTPS", "async_proxy_https"),
        ]

    def async_local_http(self):
        async def request():
            async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=False)) as session:
                async with session.get(
                    self.local_url, timeout=aiohttp.ClientTimeout(total=10)
                ) as resp:
                    assert 200 <= resp.status < 600, f"Got status {resp.status}"
                    body = await resp.text()
                    self.validate_response_body(self.local_url, body)

        return self.run_async_benchmark(request)

    def async_remote_http(self):
        async def request():
            async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=False)) as session:
                async with session.get(
                    self.remote_http_url, timeout=aiohttp.ClientTimeout(total=10)
                ) as resp:
                    assert 200 <= resp.status < 600, f"Got status {resp.status}"
                    body = await resp.text()
                    self.validate_response_body(self.remote_http_url, body)

        return self.run_async_benchmark(request)

    def async_remote_https(self):
        async def request():
            async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=False)) as session:
                async with session.get(
                    self.remote_https_url, timeout=aiohttp.ClientTimeout(total=10)
                ) as resp:
                    assert 200 <= resp.status < 600, f"Got status {resp.status}"
                    body = await resp.text()
                    self.validate_response_body(self.remote_https_url, body)

        return self.run_async_benchmark(request)

    def async_proxy_http(self):
        if not self.proxy_url_http:
            return {"error": "No proxy configured"}

        async def request():
            try:
                async with aiohttp.ClientSession(
                    connector=aiohttp.TCPConnector(ssl=False)
                ) as session:
                    async with session.get(
                        self.proxy_target_http,
                        proxy=self.proxy_url_http,
                        timeout=aiohttp.ClientTimeout(total=10),
                    ) as resp:
                        assert 200 <= resp.status < 600, f"Got status {resp.status}"
                        body = await resp.text()
                        self.validate_response_body(self.proxy_target_http, body)
            except Exception:
                pass

        try:
            return self.run_async_benchmark(request)
        except Exception:
            return {"total_time_s": 10.0, "req_per_sec": 0.1, "avg_ms": 10000.0}

    def async_proxy_https(self):
        if not self.proxy_url_https:
            return {"error": "No proxy configured"}

        async def request():
            try:
                async with aiohttp.ClientSession(
                    connector=aiohttp.TCPConnector(ssl=False)
                ) as session:
                    async with session.get(
                        self.proxy_target_https,
                        proxy=self.proxy_url_https,
                        timeout=aiohttp.ClientTimeout(total=10),
                    ) as resp:
                        assert 200 <= resp.status < 600, f"Got status {resp.status}"
                        body = await resp.text()
                        self.validate_response_body(self.proxy_target_https, body)
            except Exception:
                pass

        try:
            return self.run_async_benchmark(request)
        except Exception:
            return {"total_time_s": 10.0, "req_per_sec": 0.1, "avg_ms": 10000.0}