async def test_06_reload_change_on_signal(self, capsys, patch_systemd,
signal_server_manager_started,
signal_num, tmp_config_file,
server_port, reset_logging):
second_id = '::1'
out = capsys.readouterr().out
port1 = port_from_out(out)
current_server_id = id(signal_server_manager_started.server)
assert signal_server_manager_started.server.host == '127.0.0.1'
self.modify_config_file(tmp_config_file)
await self.send_signal(signal_server_manager_started, signal_num)
await asyncio.wait_for(
signal_server_manager_started.wait_server_stopped(), timeout=1)
await asyncio.wait_for(
signal_server_manager_started.wait_server_started(), timeout=2)
assert signal_server_manager_started.server.host == second_id
assert id(signal_server_manager_started.server) != current_server_id
out = capsys.readouterr().out
port2 = port_from_out(out)
if patch_systemd:
daemon, journal = patch_systemd
daemon.notify.assert_has_calls([
status_call(port1), ready_call, reloading_call,
restarting_status,
status_call(port2, host=second_id), ready_call
])
assert daemon.notify.call_count == 6
async def test_04_close_signal(self, patch_systemd, signal_server_manager,
signal_num, capsys, reset_logging):
task = create_task(self.send_signal(signal_server_manager, signal_num))
await signal_server_manager.serve_until_stopped()
await task
await asyncio.wait_for(signal_server_manager.server.wait_stopped(),
timeout=10)
if patch_systemd:
out = capsys.readouterr().out
port = port_from_out(out)
daemon, journal = patch_systemd
daemon.notify.assert_has_calls(
[status_call(port), ready_call, stopping_call])
assert daemon.notify.call_count == 3
async def step(p, host):
s = await p.stdout.readline()
s = s.decode()
if not s:
print(await p.stderr.read())
assert s.startswith('Storing')
s = await p.stdout.readline()
s = s.decode()
if not s:
print(await p.stderr.read())
else:
port = port_from_out(s)
newline = '\r\n' if os.name == 'nt' else '\n'
assert s == f'Serving TCP Server on {host}:{port}{newline}'
assert is_listening_on((host, port), pid=p.pid)
# ensure that child process gets to run_forever
time.sleep(0.5)
os.kill(p.pid, signal_num)
async def test_00_start_close(self, signal_server_manager, patch_systemd,
server_sock, capsys, reset_logging):
task = create_task(signal_server_manager.serve_until_stopped())
try:
await asyncio.wait_for(signal_server_manager.wait_server_started(),
timeout=2)
signal_server_manager.close()
except asyncio.TimeoutError:
await asyncio.wait_for(task, timeout=2)
else:
await asyncio.wait_for(task, timeout=1)
await asyncio.wait_for(signal_server_manager.wait_server_stopped(),
timeout=1)
if patch_systemd:
daemon, journal = patch_systemd
out = capsys.readouterr().out
port = port_from_out(out)
daemon.notify.assert_has_calls(
[status_call(port), ready_call, stopping_call])
assert daemon.notify.call_count == 3
async def test_07_reload_no_file_signal(self, patch_systemd,
signal_server_manager, signal_num,
tmp_config_file, capsys,
reset_logging):
task = create_task(signal_server_manager.serve_until_stopped())
await signal_server_manager.wait_server_started()
tmp_config_file.unlink()
await self.send_signal(signal_server_manager, signal_num)
await signal_server_manager._stop_event.wait()
assert not signal_server_manager._restart_event.is_set()
await asyncio.wait_for(signal_server_manager.wait_server_stopped(),
timeout=2)
await asyncio.wait_for(task, timeout=1)
if patch_systemd:
out = capsys.readouterr().out
port = port_from_out(out)
daemon, journal = patch_systemd
daemon.notify.assert_has_calls(
[status_call(port), ready_call, stopping_call])
assert daemon.notify.call_count == 3