Bound VPS log retention and quiet routine Hub traffic
This commit is contained in:
1 parent
5ccead65f6
commit
799ad8aad6
8 files changed
+1063
-43
No files matched your search
@@ -0,0 +1,189 @@
|
||||
"""Retention policy, safe archive selection, disk levels and HTTP diagnostics."""
|
||||
import importlib.util
|
||||
import io
|
||||
import os
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
import subprocess
|
||||
from unittest import mock
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
spec = importlib.util.spec_from_file_location("log_maintenance", ROOT / "vps/log-maintenance.py")
|
||||
m = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(m)
|
||||
|
||||
|
||||
class MaintenanceTests(unittest.TestCase):
|
||||
def test_only_exact_old_project_rule_can_be_removed(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
path = Path(temp) / 'owrt-remote'
|
||||
rule = '/var/log/nginx/*.log {\n daily\n rotate 7\n size 50M\n missingok\n notifempty\n compress\n delaycompress\n copytruncate\n}\n'
|
||||
path.write_text(rule)
|
||||
self.assertTrue(m.legacy_policy(path))
|
||||
path.write_text(rule.replace('rotate 7', 'rotate 30'))
|
||||
self.assertFalse(m.legacy_policy(path))
|
||||
path.write_text(rule.replace('copytruncate', 'postrotate\n echo custom hook\n endscript'))
|
||||
self.assertFalse(m.legacy_policy(path))
|
||||
|
||||
def test_retention_preserves_native_reopen_hooks(self):
|
||||
text = '''weekly
|
||||
/var/log/syslog
|
||||
/var/log/auth.log
|
||||
{
|
||||
rotate 7
|
||||
weekly
|
||||
delaycompress
|
||||
postrotate
|
||||
if true; then
|
||||
echo "{ brace inside shell }"
|
||||
fi
|
||||
endscript
|
||||
}
|
||||
'''
|
||||
result, patterns = m.retention_config(text)
|
||||
self.assertEqual(patterns, ["/var/log/syslog", "/var/log/auth.log"])
|
||||
self.assertIn('echo "{ brace inside shell }"', result)
|
||||
self.assertGreater(result.index("daily"), result.index("endscript"))
|
||||
self.assertIn("maxsize 20M", result)
|
||||
self.assertIn("nodelaycompress", result)
|
||||
|
||||
def test_non_log_paths_and_ambiguous_rules_fail_before_rotation(self):
|
||||
for source in ("/var/lib/owrt-remote/hub.db {\n}\n", "/var/log/../lib/data {\n}\n",
|
||||
"/var/log/a { rotate 1 }\n", "/var/log/a {\nolddir /home/user\n}\n"):
|
||||
with self.subTest(source=source), self.assertRaises(RuntimeError):
|
||||
m.retention_config(source)
|
||||
|
||||
def test_archive_names_do_not_match_active_or_user_files(self):
|
||||
for suffix in (".1", ".20.gz", ".old", "-20261119.gz", ".20261119-032000.xz"):
|
||||
self.assertTrue(m.archive_name("syslog", "syslog" + suffix), suffix)
|
||||
for name in ("syslog", "syslog.db", "syslog.backup.tar.gz", "user.gz", "syslog.log", "syslog.old.key"):
|
||||
self.assertFalse(m.archive_name("syslog", name), name)
|
||||
|
||||
def test_prune_only_old_closed_archives_and_keep_active_inode(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
root = Path(temp).resolve()
|
||||
active = root / "access.log"
|
||||
active.write_bytes(b"active")
|
||||
old, fresh, opened, unrelated = [root / x for x in ("access.log.2.gz", "access.log.1", "access.log.old", "notes.gz")]
|
||||
for p in (old, fresh, opened, unrelated):
|
||||
p.write_bytes(b"archive")
|
||||
for p in (old, opened, unrelated):
|
||||
os.utime(p, (100, 100))
|
||||
st = opened.stat()
|
||||
inode = active.stat().st_ino
|
||||
removed, size = m.prune_archives([active], now=100000, opened={(st.st_dev, st.st_ino)})
|
||||
self.assertEqual((removed, size), (1, 7))
|
||||
self.assertFalse(old.exists())
|
||||
self.assertTrue(all(p.exists() for p in (active, fresh, opened, unrelated)))
|
||||
self.assertEqual(active.stat().st_ino, inode)
|
||||
self.assertEqual(m.prune_archives([active], emergency=True, opened={(st.st_dev, st.st_ino)})[0], 1)
|
||||
self.assertTrue(opened.exists())
|
||||
|
||||
@unittest.skipIf(os.name == "nt", "Requires Unix link semantics")
|
||||
def test_symlinks_and_hardlinks_are_not_deleted(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
root = Path(temp).resolve(); active = root / "a.log"; active.write_text("active")
|
||||
user = root / "user"; user.write_text("private")
|
||||
(root / "a.log.1").symlink_to(user)
|
||||
os.link(user, root / "a.log.2")
|
||||
self.assertEqual(m.prune_archives([active], emergency=True, opened=set()), (0, 0))
|
||||
self.assertEqual(user.read_text(), "private")
|
||||
|
||||
def test_disk_checks_root_and_separate_log_mount(self):
|
||||
usage = type("Usage", (), {"total": 110, "used": 91, "free": 9})()
|
||||
with mock.patch.object(m.shutil, "disk_usage", return_value=usage) as get:
|
||||
levels = m.disk_levels()
|
||||
self.assertEqual([x[0] for x in levels], ["/", "/var/log"])
|
||||
self.assertTrue(all(x[2] == "CRITICAL" for x in levels))
|
||||
self.assertTrue(all(x[1] == 91 for x in levels))
|
||||
self.assertEqual(get.call_count, 2)
|
||||
for used, expected in ((75, 'OK'), (75.1, 'WARN'), (85, 'WARN'), (90, 'WARN'), (90.1, 'CRITICAL')):
|
||||
usage = type('Usage', (), {'used': used, 'free': 100 - used})()
|
||||
with self.subTest(used=used), mock.patch.object(m.shutil, 'disk_usage', return_value=usage):
|
||||
self.assertEqual(m.disk_levels()[0][2], expected)
|
||||
|
||||
@unittest.skipIf(os.name == 'nt', 'Requires fcntl lock')
|
||||
def test_disk_pressure_selects_aggressive_archives_and_smaller_journal_budget(self):
|
||||
for percent, emergency in ((84.9, False), (85, False), (85.1, True)):
|
||||
with self.subTest(percent=percent), tempfile.TemporaryDirectory() as temp:
|
||||
with mock.patch.object(m, 'STATE', Path(temp) / 'state'), \
|
||||
mock.patch.object(m, 'RUN', Path(temp) / 'run'), \
|
||||
mock.patch.object(m, 'flatten_config', return_value=''), \
|
||||
mock.patch.object(m, 'disk_levels', return_value=[('/', percent, 'WARN'), ('/var/log', 20, 'OK')]), \
|
||||
mock.patch.object(m, 'prune_archives', return_value=(0, 0)) as prune, \
|
||||
mock.patch.object(m, 'record'), mock.patch('sys.stdout', new=io.StringIO()), \
|
||||
mock.patch.object(m, 'command', return_value=subprocess.CompletedProcess([], 0, '')) as command:
|
||||
m.run()
|
||||
self.assertTrue(all(call.kwargs['emergency'] == emergency for call in prune.call_args_list))
|
||||
self.assertTrue(any('--vacuum-size=' + ('10M' if emergency else '50M') in call.args[0] for call in command.call_args_list))
|
||||
|
||||
def test_later_journald_override_cannot_silently_disable_limit(self):
|
||||
text = '[Journal]\nSystemMaxUse=50M\nSystemKeepFree=500M\nMaxRetentionSec=7day\nCompress=yes\n'
|
||||
with mock.patch.object(m, 'command', return_value=subprocess.CompletedProcess([], 0, text)):
|
||||
m.validate_journal_config()
|
||||
with mock.patch.object(m, 'command', return_value=subprocess.CompletedProcess([], 0, text + '\n[Journal]\nSystemMaxUse=1G\n')):
|
||||
with self.assertRaisesRegex(RuntimeError, 'overrides SystemMaxUse'):
|
||||
m.validate_journal_config()
|
||||
|
||||
@unittest.skipIf(os.name == 'nt', 'Requires POSIX nginx paths')
|
||||
def test_nginx_modifies_existing_logger_without_adding_duplicate(self):
|
||||
text = 'http {\n access_log /var/log/nginx/access.log;\n access_log /var/log/nginx/custom.log;\n}\n'
|
||||
path = Path('/etc/nginx/nginx.conf')
|
||||
with mock.patch.object(m, 'command', return_value=subprocess.CompletedProcess([], 0, '# configuration file /etc/nginx/nginx.conf:\n')), \
|
||||
mock.patch.object(Path, 'resolve', return_value=path), \
|
||||
mock.patch.object(Path, 'is_file', return_value=True), \
|
||||
mock.patch.object(Path, 'read_text', return_value=text):
|
||||
configs = m.nginx_policies()
|
||||
changed = configs[str(path)]
|
||||
self.assertEqual(changed.count('access_log '), 2)
|
||||
self.assertIn('access.log combined if=$owrt_remote_access_log;', changed)
|
||||
self.assertIn('access_log /var/log/nginx/custom.log;', changed)
|
||||
|
||||
@unittest.skipIf(os.name == 'nt', 'Requires POSIX nginx paths')
|
||||
def test_existing_custom_nginx_condition_is_not_silently_overwritten(self):
|
||||
with mock.patch.object(m, 'command', return_value=subprocess.CompletedProcess([], 0, '# configuration file /etc/nginx/nginx.conf:\n')), \
|
||||
mock.patch.object(Path, 'resolve', return_value=Path('/etc/nginx/nginx.conf')), \
|
||||
mock.patch.object(Path, 'is_file', return_value=True), \
|
||||
mock.patch.object(Path, 'read_text', return_value='access_log /var/log/nginx/access.log combined if=$custom;'):
|
||||
with self.assertRaisesRegex(RuntimeError, 'manual review'):
|
||||
m.nginx_policies()
|
||||
|
||||
@unittest.skipIf(os.name == 'nt', 'Requires POSIX file permissions')
|
||||
def test_result_log_rollover_is_bounded(self):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
path = Path(temp) / 'maintenance.log'
|
||||
path.write_bytes(b'x' * 100000)
|
||||
with mock.patch.object(m, 'RESULT', path), mock.patch('sys.stdout', new=io.StringIO()):
|
||||
m.record('OK', 'done')
|
||||
self.assertLess(path.stat().st_size, 200)
|
||||
self.assertEqual(path.with_suffix('.log.1').stat().st_size, 65536)
|
||||
|
||||
@unittest.skipIf(os.name == 'nt', 'Requires fcntl lock')
|
||||
def test_daily_guard_parallel_lock_and_failed_run_are_explicit(self):
|
||||
import datetime
|
||||
import fcntl
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
state, runtime = Path(temp) / 'state', Path(temp) / 'run'
|
||||
state.mkdir(); runtime.mkdir()
|
||||
with mock.patch.object(m, 'STATE', state), mock.patch.object(m, 'RUN', runtime), \
|
||||
mock.patch.object(m, 'record'), mock.patch('sys.stdout', new=io.StringIO()) as output, \
|
||||
mock.patch.object(m, 'flatten_config', side_effect=RuntimeError('invalid policy')) as parse:
|
||||
with (runtime / 'lock').open('a') as lock:
|
||||
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
m.run()
|
||||
self.assertFalse(parse.called)
|
||||
with self.assertRaisesRegex(RuntimeError, 'invalid policy'):
|
||||
m.run()
|
||||
self.assertIn('"ok": false', (state / 'result.json').read_text())
|
||||
self.assertEqual((state / 'last-attempt').read_text().strip(), datetime.date.today().isoformat())
|
||||
parse.reset_mock()
|
||||
m.run()
|
||||
self.assertFalse(parse.called)
|
||||
self.assertIn('already', output.getvalue())
|
||||
with self.assertRaisesRegex(RuntimeError, 'invalid policy'):
|
||||
m.run(force=True)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -94,6 +94,40 @@ class NotificationLoadTests(unittest.TestCase):
|
||||
self.assertIn("500", output.getvalue())
|
||||
self.assertNotIn("200", output.getvalue())
|
||||
|
||||
def test_heartbeat_and_log_upload_keep_errors_debug_and_application_messages(self):
|
||||
class Handler:
|
||||
path = "/api/heartbeat?unused=1"
|
||||
def address_string(self): return "127.0.0.1"
|
||||
def log_date_time_string(self): return "now"
|
||||
handler = Handler()
|
||||
for path in ("/api/heartbeat", "/api/router-logs", "/api/ssh-session/test/read"):
|
||||
handler.path = path + "?test=1"
|
||||
with self.subTest(path=path), mock.patch.dict(os.environ, {"OWRT_REMOTE_HTTP_DEBUG": "0"}):
|
||||
output = io.StringIO()
|
||||
with mock.patch.object(self.hub.sys, "stderr", output):
|
||||
for status in (200, 201, 204, 301, 304):
|
||||
self.hub.Handler.log_message(handler, '"%s" %s %s', "POST /test HTTP/1.1", str(status), "0")
|
||||
for status in (400, 401, 403, 429, 500, 503, 599):
|
||||
self.hub.Handler.log_message(handler, '"%s" %s %s', "POST /test HTTP/1.1", str(status), "0")
|
||||
self.hub.Handler.log_message(handler, "database failed: %s", "disk full")
|
||||
self.hub.Handler.log_message(handler, "custom numeric error: %s %s", "bad", 200)
|
||||
lines = output.getvalue().splitlines()
|
||||
self.assertEqual(len(lines), 9)
|
||||
self.assertIn("database failed", output.getvalue())
|
||||
with mock.patch.dict(os.environ, {"OWRT_REMOTE_HTTP_DEBUG": "1"}), mock.patch.object(self.hub.sys, "stderr", output):
|
||||
self.hub.Handler.log_message(handler, '"%s" %s %s', "POST /test HTTP/1.1", "200", "0")
|
||||
self.assertEqual(len(output.getvalue().splitlines()), 10)
|
||||
|
||||
def test_malformed_http_request_without_path_is_still_logged(self):
|
||||
class Handler:
|
||||
def address_string(self): return '127.0.0.1'
|
||||
def log_date_time_string(self): return 'now'
|
||||
output = io.StringIO()
|
||||
with mock.patch.object(self.hub.sys, 'stderr', output):
|
||||
self.hub.Handler.log_message(Handler(), 'code %d, message %s', 400, 'Bad request syntax')
|
||||
self.assertIn('400', output.getvalue())
|
||||
self.assertIn('Bad request syntax', output.getvalue())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user