2020-10-07 22:18:43 +00:00
|
|
|
import re
|
2018-07-13 17:15:50 +00:00
|
|
|
import socket
|
2020-05-15 03:20:56 +00:00
|
|
|
import time
|
|
|
|
|
2020-10-07 22:18:43 +00:00
|
|
|
import pytest
|
2019-03-28 15:43:13 +00:00
|
|
|
from unit.applications.lang.python import TestApplicationPython
|
2021-05-24 04:26:15 +00:00
|
|
|
from unit.utils import sysctl
|
2018-07-13 17:15:50 +00:00
|
|
|
|
|
|
|
|
2019-03-28 15:43:13 +00:00
|
|
|
class TestSettings(TestApplicationPython):
|
2020-04-24 04:08:56 +00:00
|
|
|
prerequisites = {'modules': {'python': 'any'}}
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2022-12-13 14:51:11 +00:00
|
|
|
def test_settings_large_header_buffer_size(self):
|
|
|
|
self.load('empty')
|
|
|
|
|
|
|
|
def set_buffer_size(size):
|
|
|
|
assert 'success' in self.conf(
|
|
|
|
{'http': {'large_header_buffer_size': size}},
|
|
|
|
'settings',
|
|
|
|
)
|
|
|
|
|
|
|
|
def header_value(size, expect=200):
|
|
|
|
headers = {'Host': 'a' * (size - 1), 'Connection': 'close'}
|
|
|
|
assert self.get(headers=headers)['status'] == expect
|
|
|
|
|
|
|
|
set_buffer_size(4096)
|
|
|
|
header_value(4096)
|
|
|
|
header_value(4097, 431)
|
|
|
|
|
|
|
|
set_buffer_size(16384)
|
|
|
|
header_value(16384)
|
|
|
|
header_value(16385, 431)
|
|
|
|
|
|
|
|
def test_settings_large_header_buffers(self):
|
|
|
|
self.load('empty')
|
|
|
|
|
|
|
|
def set_buffers(buffers):
|
|
|
|
assert 'success' in self.conf(
|
|
|
|
{'http': {'large_header_buffers': buffers}},
|
|
|
|
'settings',
|
|
|
|
)
|
|
|
|
|
|
|
|
def big_headers(headers_num, expect=200):
|
|
|
|
headers = {'Host': 'localhost', 'Connection': 'close'}
|
|
|
|
|
|
|
|
for i in range(headers_num):
|
2023-02-21 17:21:29 +00:00
|
|
|
headers[f'Custom-header-{i}'] = 'a' * 8000
|
2022-12-13 14:51:11 +00:00
|
|
|
|
|
|
|
assert self.get(headers=headers)['status'] == expect
|
|
|
|
|
|
|
|
set_buffers(1)
|
|
|
|
big_headers(1)
|
|
|
|
big_headers(2, 431)
|
|
|
|
|
|
|
|
set_buffers(2)
|
|
|
|
big_headers(2)
|
|
|
|
big_headers(3, 431)
|
|
|
|
|
|
|
|
set_buffers(8)
|
|
|
|
big_headers(8)
|
|
|
|
big_headers(9, 431)
|
|
|
|
|
|
|
|
@pytest.mark.skip('not yet')
|
|
|
|
def test_settings_large_header_buffer_invalid(self):
|
|
|
|
def check_error(conf):
|
|
|
|
assert 'error' in self.conf({'http': conf}, 'settings')
|
|
|
|
|
|
|
|
check_error({'large_header_buffer_size': -1})
|
|
|
|
check_error({'large_header_buffer_size': 0})
|
|
|
|
check_error({'large_header_buffers': -1})
|
|
|
|
check_error({'large_header_buffers': 0})
|
|
|
|
|
2018-07-13 17:15:50 +00:00
|
|
|
def test_settings_header_read_timeout(self):
|
|
|
|
self.load('empty')
|
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
def req():
|
|
|
|
(resp, sock) = self.http(
|
|
|
|
b"""GET / HTTP/1.1
|
2019-03-26 20:38:30 +00:00
|
|
|
""",
|
2021-05-24 21:28:23 +00:00
|
|
|
start=True,
|
|
|
|
read_timeout=1,
|
|
|
|
raw=True,
|
|
|
|
)
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
time.sleep(3)
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
return self.http(
|
|
|
|
b"""Host: localhost
|
2018-07-13 17:15:50 +00:00
|
|
|
Connection: close
|
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
""",
|
|
|
|
sock=sock,
|
|
|
|
raw=True,
|
|
|
|
)
|
|
|
|
|
|
|
|
assert 'success' in self.conf(
|
|
|
|
{'http': {'header_read_timeout': 2}}, 'settings'
|
2019-03-26 20:38:30 +00:00
|
|
|
)
|
2021-05-24 21:28:23 +00:00
|
|
|
assert req()['status'] == 408, 'status header read timeout'
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
assert 'success' in self.conf(
|
|
|
|
{'http': {'header_read_timeout': 7}}, 'settings'
|
|
|
|
)
|
|
|
|
assert req()['status'] == 200, 'status header read timeout 2'
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2018-08-21 17:49:23 +00:00
|
|
|
def test_settings_header_read_timeout_update(self):
|
|
|
|
self.load('empty')
|
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
assert 'success' in self.conf(
|
|
|
|
{'http': {'header_read_timeout': 4}}, 'settings'
|
|
|
|
)
|
2018-08-21 17:49:23 +00:00
|
|
|
|
2022-10-11 12:49:10 +00:00
|
|
|
sock = self.http(
|
2019-03-26 20:38:30 +00:00
|
|
|
b"""GET / HTTP/1.1
|
|
|
|
""",
|
|
|
|
raw=True,
|
|
|
|
no_recv=True,
|
|
|
|
)
|
2018-08-21 17:49:23 +00:00
|
|
|
|
|
|
|
time.sleep(2)
|
|
|
|
|
2022-10-11 12:49:10 +00:00
|
|
|
sock = self.http(
|
2019-03-26 20:38:30 +00:00
|
|
|
b"""Host: localhost
|
|
|
|
""",
|
|
|
|
sock=sock,
|
|
|
|
raw=True,
|
|
|
|
no_recv=True,
|
|
|
|
)
|
2018-09-03 23:30:27 +00:00
|
|
|
|
|
|
|
time.sleep(2)
|
|
|
|
|
2019-03-26 20:38:30 +00:00
|
|
|
(resp, sock) = self.http(
|
|
|
|
b"""X-Blah: blah
|
|
|
|
""",
|
|
|
|
start=True,
|
|
|
|
sock=sock,
|
|
|
|
read_timeout=1,
|
|
|
|
raw=True,
|
|
|
|
)
|
2018-08-21 17:49:23 +00:00
|
|
|
|
2018-09-17 16:07:29 +00:00
|
|
|
if len(resp) != 0:
|
|
|
|
sock.close()
|
|
|
|
|
|
|
|
else:
|
|
|
|
time.sleep(2)
|
2018-08-21 17:49:23 +00:00
|
|
|
|
2019-03-26 20:38:30 +00:00
|
|
|
resp = self.http(
|
|
|
|
b"""Connection: close
|
2018-08-21 17:49:23 +00:00
|
|
|
|
2019-03-26 20:38:30 +00:00
|
|
|
""",
|
|
|
|
sock=sock,
|
|
|
|
raw=True,
|
|
|
|
)
|
2018-08-21 17:49:23 +00:00
|
|
|
|
2020-09-16 20:31:15 +00:00
|
|
|
assert resp['status'] == 408, 'status header read timeout update'
|
2018-08-21 17:49:23 +00:00
|
|
|
|
2018-07-13 17:15:50 +00:00
|
|
|
def test_settings_body_read_timeout(self):
|
|
|
|
self.load('empty')
|
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
def req():
|
|
|
|
(resp, sock) = self.http(
|
|
|
|
b"""POST / HTTP/1.1
|
2018-07-13 17:15:50 +00:00
|
|
|
Host: localhost
|
|
|
|
Content-Length: 10
|
|
|
|
Connection: close
|
|
|
|
|
2019-03-26 20:38:30 +00:00
|
|
|
""",
|
2021-05-24 21:28:23 +00:00
|
|
|
start=True,
|
|
|
|
raw_resp=True,
|
|
|
|
read_timeout=1,
|
|
|
|
raw=True,
|
|
|
|
)
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
time.sleep(3)
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
return self.http(b"""0123456789""", sock=sock, raw=True)
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
assert 'success' in self.conf(
|
|
|
|
{'http': {'body_read_timeout': 2}}, 'settings'
|
|
|
|
)
|
|
|
|
assert req()['status'] == 408, 'status body read timeout'
|
|
|
|
|
|
|
|
assert 'success' in self.conf(
|
|
|
|
{'http': {'body_read_timeout': 7}}, 'settings'
|
|
|
|
)
|
|
|
|
assert req()['status'] == 200, 'status body read timeout 2'
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2018-08-21 17:49:23 +00:00
|
|
|
def test_settings_body_read_timeout_update(self):
|
|
|
|
self.load('empty')
|
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
assert 'success' in self.conf(
|
|
|
|
{'http': {'body_read_timeout': 4}}, 'settings'
|
|
|
|
)
|
2018-08-21 17:49:23 +00:00
|
|
|
|
2019-03-26 20:38:30 +00:00
|
|
|
(resp, sock) = self.http(
|
|
|
|
b"""POST / HTTP/1.1
|
2018-08-21 17:49:23 +00:00
|
|
|
Host: localhost
|
|
|
|
Content-Length: 10
|
|
|
|
Connection: close
|
|
|
|
|
2019-03-26 20:38:30 +00:00
|
|
|
""",
|
|
|
|
start=True,
|
|
|
|
read_timeout=1,
|
|
|
|
raw=True,
|
|
|
|
)
|
2018-08-21 17:49:23 +00:00
|
|
|
|
|
|
|
time.sleep(2)
|
|
|
|
|
2019-03-26 20:38:30 +00:00
|
|
|
(resp, sock) = self.http(
|
|
|
|
b"""012""", start=True, sock=sock, read_timeout=1, raw=True
|
|
|
|
)
|
2018-08-21 17:49:23 +00:00
|
|
|
|
|
|
|
time.sleep(2)
|
|
|
|
|
2019-03-26 20:38:30 +00:00
|
|
|
(resp, sock) = self.http(
|
|
|
|
b"""345""", start=True, sock=sock, read_timeout=1, raw=True
|
|
|
|
)
|
2018-08-21 17:49:23 +00:00
|
|
|
|
|
|
|
time.sleep(2)
|
|
|
|
|
|
|
|
resp = self.http(b"""6789""", sock=sock, raw=True)
|
|
|
|
|
2020-09-16 20:31:15 +00:00
|
|
|
assert resp['status'] == 200, 'status body read timeout update'
|
2018-08-21 17:49:23 +00:00
|
|
|
|
2020-10-19 21:25:29 +00:00
|
|
|
def test_settings_send_timeout(self, temp_dir):
|
2021-05-24 04:26:15 +00:00
|
|
|
self.load('body_generate')
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
def req(addr, data_len):
|
|
|
|
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
|
|
|
sock.connect(addr)
|
|
|
|
|
2023-02-21 17:21:29 +00:00
|
|
|
req = f"""GET / HTTP/1.1
|
2021-05-24 21:28:23 +00:00
|
|
|
Host: localhost
|
2023-02-21 17:21:29 +00:00
|
|
|
X-Length: {data_len}
|
2021-05-24 21:28:23 +00:00
|
|
|
Connection: close
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
sock.sendall(req.encode())
|
|
|
|
|
|
|
|
data = sock.recv(16).decode()
|
|
|
|
|
|
|
|
time.sleep(3)
|
|
|
|
|
|
|
|
data += self.recvall(sock).decode()
|
|
|
|
|
|
|
|
sock.close()
|
|
|
|
|
|
|
|
return data
|
|
|
|
|
2021-05-24 04:26:15 +00:00
|
|
|
sysctl_out = sysctl()
|
|
|
|
values = re.findall(
|
|
|
|
r'net.core.[rw]mem_(?:max|default).*?(\d+)', sysctl_out
|
|
|
|
)
|
|
|
|
values = [int(v) for v in values]
|
|
|
|
|
|
|
|
data_len = 1048576 if len(values) == 0 else 10 * max(values)
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2023-02-21 17:21:29 +00:00
|
|
|
addr = f'{temp_dir}/sock'
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
assert 'success' in self.conf(
|
2023-02-21 17:21:29 +00:00
|
|
|
{f'unix:{addr}': {'application': 'body_generate'}}, 'listeners'
|
2021-05-24 04:26:15 +00:00
|
|
|
)
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2022-04-11 20:05:14 +00:00
|
|
|
assert 'success' in self.conf({'http': {'send_timeout': 1}}, 'settings')
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
data = req(addr, data_len)
|
|
|
|
assert re.search(r'200 OK', data), 'send timeout status'
|
|
|
|
assert len(data) < data_len, 'send timeout data '
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
self.conf({'http': {'send_timeout': 7}}, 'settings')
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
data = req(addr, data_len)
|
|
|
|
assert re.search(r'200 OK', data), 'send timeout status 2'
|
|
|
|
assert len(data) > data_len, 'send timeout data 2'
|
2018-07-13 17:15:50 +00:00
|
|
|
|
|
|
|
def test_settings_idle_timeout(self):
|
|
|
|
self.load('empty')
|
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
def req():
|
|
|
|
(resp, sock) = self.get(
|
|
|
|
headers={'Host': 'localhost', 'Connection': 'keep-alive'},
|
|
|
|
start=True,
|
|
|
|
read_timeout=1,
|
|
|
|
)
|
2019-04-09 17:59:35 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
time.sleep(3)
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
return self.get(sock=sock)
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
assert self.get()['status'] == 200, 'init'
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2022-04-11 20:05:14 +00:00
|
|
|
assert 'success' in self.conf({'http': {'idle_timeout': 2}}, 'settings')
|
2021-05-24 21:28:23 +00:00
|
|
|
assert req()['status'] == 408, 'status idle timeout'
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2022-04-11 20:05:14 +00:00
|
|
|
assert 'success' in self.conf({'http': {'idle_timeout': 7}}, 'settings')
|
2021-05-24 21:28:23 +00:00
|
|
|
assert req()['status'] == 200, 'status idle timeout 2'
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2020-09-21 20:24:42 +00:00
|
|
|
def test_settings_idle_timeout_2(self):
|
|
|
|
self.load('empty')
|
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
def req():
|
2022-10-11 12:49:10 +00:00
|
|
|
sock = self.http(b'', raw=True, no_recv=True)
|
2020-09-21 20:24:42 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
time.sleep(3)
|
2020-09-21 20:24:42 +00:00
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
return self.get(sock=sock)
|
|
|
|
|
|
|
|
assert self.get()['status'] == 200, 'init'
|
2020-09-21 20:24:42 +00:00
|
|
|
|
2022-04-11 20:05:14 +00:00
|
|
|
assert 'success' in self.conf({'http': {'idle_timeout': 1}}, 'settings')
|
2021-05-24 21:28:23 +00:00
|
|
|
assert req()['status'] == 408, 'status idle timeout'
|
2020-09-21 20:24:42 +00:00
|
|
|
|
2022-04-11 20:05:14 +00:00
|
|
|
assert 'success' in self.conf({'http': {'idle_timeout': 7}}, 'settings')
|
2021-05-24 21:28:23 +00:00
|
|
|
assert req()['status'] == 200, 'status idle timeout 2'
|
2020-09-21 20:24:42 +00:00
|
|
|
|
2018-07-13 17:15:50 +00:00
|
|
|
def test_settings_max_body_size(self):
|
|
|
|
self.load('empty')
|
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
assert 'success' in self.conf(
|
|
|
|
{'http': {'max_body_size': 5}}, 'settings'
|
|
|
|
)
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2020-09-16 20:31:15 +00:00
|
|
|
assert self.post(body='01234')['status'] == 200, 'status size'
|
|
|
|
assert self.post(body='012345')['status'] == 413, 'status size max'
|
2018-07-13 17:15:50 +00:00
|
|
|
|
2020-02-20 20:33:49 +00:00
|
|
|
def test_settings_max_body_size_large(self):
|
|
|
|
self.load('mirror')
|
|
|
|
|
2021-05-24 21:28:23 +00:00
|
|
|
assert 'success' in self.conf(
|
|
|
|
{'http': {'max_body_size': 32 * 1024 * 1024}}, 'settings'
|
|
|
|
)
|
2020-02-20 20:33:49 +00:00
|
|
|
|
|
|
|
body = '0123456789abcdef' * 4 * 64 * 1024
|
|
|
|
resp = self.post(body=body, read_buffer_size=1024 * 1024)
|
2020-09-16 20:31:15 +00:00
|
|
|
assert resp['status'] == 200, 'status size 4'
|
|
|
|
assert resp['body'] == body, 'status body 4'
|
2020-02-20 20:33:49 +00:00
|
|
|
|
|
|
|
body = '0123456789abcdef' * 8 * 64 * 1024
|
|
|
|
resp = self.post(body=body, read_buffer_size=1024 * 1024)
|
2020-09-16 20:31:15 +00:00
|
|
|
assert resp['status'] == 200, 'status size 8'
|
|
|
|
assert resp['body'] == body, 'status body 8'
|
2020-02-20 20:33:49 +00:00
|
|
|
|
|
|
|
body = '0123456789abcdef' * 16 * 64 * 1024
|
|
|
|
resp = self.post(body=body, read_buffer_size=1024 * 1024)
|
2020-09-16 20:31:15 +00:00
|
|
|
assert resp['status'] == 200, 'status size 16'
|
|
|
|
assert resp['body'] == body, 'status body 16'
|
2020-02-20 20:33:49 +00:00
|
|
|
|
|
|
|
body = '0123456789abcdef' * 32 * 64 * 1024
|
|
|
|
resp = self.post(body=body, read_buffer_size=1024 * 1024)
|
2020-09-16 20:31:15 +00:00
|
|
|
assert resp['status'] == 200, 'status size 32'
|
|
|
|
assert resp['body'] == body, 'status body 32'
|
2020-02-20 20:33:49 +00:00
|
|
|
|
2020-09-16 20:31:15 +00:00
|
|
|
@pytest.mark.skip('not yet')
|
2018-07-13 17:15:50 +00:00
|
|
|
def test_settings_negative_value(self):
|
2020-09-16 20:31:15 +00:00
|
|
|
assert 'error' in self.conf(
|
|
|
|
{'http': {'max_body_size': -1}}, 'settings'
|
|
|
|
), 'settings negative value'
|
2020-11-12 00:07:08 +00:00
|
|
|
|
|
|
|
def test_settings_body_buffer_size(self):
|
|
|
|
self.load('mirror')
|
|
|
|
|
|
|
|
assert 'success' in self.conf(
|
|
|
|
{
|
|
|
|
'http': {
|
|
|
|
'max_body_size': 64 * 1024 * 1024,
|
|
|
|
'body_buffer_size': 32 * 1024 * 1024,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
'settings',
|
|
|
|
)
|
|
|
|
|
|
|
|
body = '0123456789abcdef'
|
|
|
|
resp = self.post(body=body)
|
|
|
|
assert bool(resp), 'response from application'
|
|
|
|
assert resp['status'] == 200, 'status'
|
|
|
|
assert resp['body'] == body, 'body'
|
|
|
|
|
|
|
|
body = '0123456789abcdef' * 1024 * 1024
|
|
|
|
resp = self.post(body=body, read_buffer_size=1024 * 1024)
|
|
|
|
assert bool(resp), 'response from application 2'
|
|
|
|
assert resp['status'] == 200, 'status 2'
|
|
|
|
assert resp['body'] == body, 'body 2'
|
|
|
|
|
|
|
|
body = '0123456789abcdef' * 2 * 1024 * 1024
|
|
|
|
resp = self.post(body=body, read_buffer_size=1024 * 1024)
|
|
|
|
assert bool(resp), 'response from application 3'
|
|
|
|
assert resp['status'] == 200, 'status 3'
|
|
|
|
assert resp['body'] == body, 'body 3'
|
|
|
|
|
|
|
|
body = '0123456789abcdef' * 3 * 1024 * 1024
|
|
|
|
resp = self.post(body=body, read_buffer_size=1024 * 1024)
|
|
|
|
assert bool(resp), 'response from application 4'
|
|
|
|
assert resp['status'] == 200, 'status 4'
|
|
|
|
assert resp['body'] == body, 'body 4'
|
2023-03-21 19:20:23 +00:00
|
|
|
|
|
|
|
def test_settings_log_route(self):
|
|
|
|
def count_fallbacks():
|
|
|
|
return len(self.findall(r'"fallback" taken'))
|
|
|
|
|
|
|
|
def check_record(template):
|
|
|
|
assert self.search_in_log(template) is not None
|
|
|
|
|
|
|
|
def check_no_record(template):
|
|
|
|
assert self.search_in_log(template) is None
|
|
|
|
|
|
|
|
def template_req_line(url):
|
|
|
|
return rf'\[notice\].*http request line "GET {url} HTTP/1\.1"'
|
|
|
|
|
|
|
|
def template_selected(route):
|
|
|
|
return rf'\[notice\].*"{route}" selected'
|
|
|
|
|
|
|
|
def template_discarded(route):
|
|
|
|
return rf'\[info\].*"{route}" discarded'
|
|
|
|
|
|
|
|
def wait_for_request_log(status, uri, route):
|
|
|
|
assert self.get(url=uri)['status'] == status
|
|
|
|
assert self.wait_for_record(template_req_line(uri)) is not None
|
|
|
|
assert self.wait_for_record(template_selected(route)) is not None
|
|
|
|
|
|
|
|
# routes array
|
|
|
|
|
|
|
|
assert 'success' in self.conf(
|
|
|
|
{
|
|
|
|
"listeners": {"*:7080": {"pass": "routes"}},
|
|
|
|
"routes": [
|
|
|
|
{
|
|
|
|
"match": {
|
|
|
|
"uri": "/zero",
|
|
|
|
},
|
|
|
|
"action": {"return": 200},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"action": {"return": 201},
|
|
|
|
},
|
|
|
|
],
|
|
|
|
"applications": {},
|
|
|
|
"settings": {"http": {"log_route": True}},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
wait_for_request_log(200, '/zero', 'routes/0')
|
|
|
|
check_no_record(r'discarded')
|
|
|
|
|
|
|
|
wait_for_request_log(201, '/one', 'routes/1')
|
|
|
|
check_record(template_discarded('routes/0'))
|
|
|
|
|
|
|
|
# routes object
|
|
|
|
|
|
|
|
assert 'success' in self.conf(
|
|
|
|
{
|
|
|
|
"listeners": {"*:7080": {"pass": "routes/main"}},
|
|
|
|
"routes": {
|
|
|
|
"main": [
|
|
|
|
{
|
|
|
|
"match": {
|
|
|
|
"uri": "/named_route",
|
|
|
|
},
|
|
|
|
"action": {"return": 200},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"action": {"return": 201},
|
|
|
|
},
|
|
|
|
]
|
|
|
|
},
|
|
|
|
"applications": {},
|
|
|
|
"settings": {"http": {"log_route": True}},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
wait_for_request_log(200, '/named_route', 'routes/main/0')
|
|
|
|
check_no_record(template_discarded('routes/main'))
|
|
|
|
|
|
|
|
wait_for_request_log(201, '/unnamed_route', 'routes/main/1')
|
|
|
|
check_record(template_discarded('routes/main/0'))
|
|
|
|
|
|
|
|
# routes sequence
|
|
|
|
|
|
|
|
assert 'success' in self.conf(
|
|
|
|
{
|
|
|
|
"listeners": {"*:7080": {"pass": "routes/first"}},
|
|
|
|
"routes": {
|
|
|
|
"first": [
|
|
|
|
{
|
|
|
|
"action": {"pass": "routes/second"},
|
|
|
|
},
|
|
|
|
],
|
|
|
|
"second": [
|
|
|
|
{
|
|
|
|
"action": {"return": 200},
|
|
|
|
},
|
|
|
|
],
|
|
|
|
},
|
|
|
|
"applications": {},
|
|
|
|
"settings": {"http": {"log_route": True}},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
wait_for_request_log(200, '/sequence', 'routes/second/0')
|
|
|
|
check_record(template_selected('routes/first/0'))
|
|
|
|
|
|
|
|
# fallback
|
|
|
|
|
|
|
|
assert 'success' in self.conf(
|
|
|
|
{
|
|
|
|
"listeners": {"*:7080": {"pass": "routes/fall"}},
|
|
|
|
"routes": {
|
|
|
|
"fall": [
|
|
|
|
{
|
|
|
|
"action": {
|
|
|
|
"share": "/blah",
|
|
|
|
"fallback": {"pass": "routes/fall2"},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
],
|
|
|
|
"fall2": [
|
|
|
|
{
|
|
|
|
"action": {"return": 200},
|
|
|
|
},
|
|
|
|
],
|
|
|
|
},
|
|
|
|
"applications": {},
|
|
|
|
"settings": {"http": {"log_route": True}},
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
wait_for_request_log(200, '/', 'routes/fall2/0')
|
|
|
|
assert count_fallbacks() == 1
|
|
|
|
check_record(template_selected('routes/fall/0'))
|
|
|
|
|
|
|
|
assert self.head()['status'] == 200
|
|
|
|
assert count_fallbacks() == 2
|
|
|
|
|
|
|
|
# disable log
|
|
|
|
|
|
|
|
assert 'success' in self.conf({"log_route": False}, 'settings/http')
|
|
|
|
|
|
|
|
url = '/disable_logging'
|
|
|
|
assert self.get(url=url)['status'] == 200
|
|
|
|
|
|
|
|
time.sleep(1)
|
|
|
|
|
|
|
|
check_no_record(template_req_line(url))
|
|
|
|
|
|
|
|
# total
|
|
|
|
|
|
|
|
assert len(self.findall(r'\[notice\].*http request line')) == 7
|
|
|
|
assert len(self.findall(r'\[notice\].*selected')) == 10
|
|
|
|
assert len(self.findall(r'\[info\].*discarded')) == 2
|