Add live VPS CPU, memory and disk widgets

This commit is contained in:
kzolotarev95 committed 2026-10-08 09:47:52 +04:00
1 parent b854d3a001
commit 4c525b8f77
5 files changed
+558

No files matched your search

+51
View File
@@ -0,0 +1,51 @@
# Виджеты ресурсов VPS (v111)
Три карточки ЦП, ОЗУ и ДИСК находятся над кнопками «Рестарт Xray VPS»,
профилем и выходом. На ПК ширина и высота совпадают с кнопками под ними.
На мобильном карточки видны над кнопкой открытия меню хаба.
Панель запрашивает `/api/vps/resources` сразу и каждые 3 секунды.
ЦП — общая загрузка процессоров по разнице счётчиков `/proc/stat`.
ОЗУ — занятая память, рассчитанная как `MemTotal - MemAvailable`.
ДИСК — занятое место файловой системы `/`. В подсказках указаны число
vCPU и объёмы занятой/общей памяти и диска.
Доступ требует входа в Hub. Показания общие для всех вкладок и кешируются
на 3 секунды. Сбор не открывает SQLite и не запускает внешние команды.
Опрос приостанавливается в скрытой вкладке; после возвращения возобновляется.
При ошибке связи вместо устаревших чисел показывается «—».
## Установка и откат с Windows 11
В PowerShell, из любого каталога:
```powershell
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-vps-widgets.ps1" -Vps "root@193.233.82.38" -Action Install
```
После `VPS_WIDGETS_V111_Install_OK` обновите страницу через Ctrl+F5.
Скрипт загружает локальный файл, проверяет его до замены, перезапускает
службу и проверяет health. При ошибке после замены восстанавливает файл
перед текущей попыткой. База данных и настройки не заменяются.
```powershell
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-vps-widgets.ps1" -Vps "root@193.233.82.38" -Action Rollback
```
Откат использует неизменяемую копию первого состояния до установки:
`/opt/owrt-remote/owrt-remote-hub.py.bak-before-vps-widgets-v111`.
Успешное завершение: `VPS_WIDGETS_V111_Rollback_OK`.
## Локальные проверки
```powershell
python tests/test_vps_resources.py -v
python tests/test_vps_resources.py --export-preview .test-output/vps-widgets
node --check .test-output/vps-widgets/dashboard.js
node tests/test_vps_resources_ui.cjs .test-output/vps-widgets/dashboard.js
```
Проверяются вычисления, совместный кеш при одновременных запросах,
ошибки чтения, авторизация HTTP и отсутствие доступа к SQLite.
JS-проверки охватывают обновление обеих версий панели, отсутствие
параллельных запросов, таймауты, восстановление связи и скрытие вкладки.
+135
View File
@@ -0,0 +1,135 @@
"""VPS metrics, shared sampling and authenticated HTTP regression checks."""
import importlib.util
import json
import os
from pathlib import Path
import re
import sys
import tempfile
import threading
from types import SimpleNamespace
import unittest
import urllib.error
import urllib.request
from unittest import mock
SOURCE = Path(os.environ.get("OWRT_VPS_WIDGETS_HUB_SOURCE", Path(__file__).resolve().parents[1] / "vps/owrt-remote-hub.py"))
STATE = tempfile.TemporaryDirectory(prefix="owrt-vps-widgets-")
spec = importlib.util.spec_from_file_location("vps_widgets_hub", SOURCE)
hub = importlib.util.module_from_spec(spec)
sys.modules[spec.name] = hub
with mock.patch.dict(os.environ, {"OWRT_REMOTE_STATE_DIR": STATE.name}):
spec.loader.exec_module(hub)
class ResourceSampleTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory(dir=STATE.name)
self.addCleanup(self.tmp.cleanup)
self.proc = Path(self.tmp.name)
self.proc.joinpath("stat").write_text("cpu 100 20 30 500 50 10 10 10 40 20\n")
self.proc.joinpath("meminfo").write_text("MemTotal: 1000 kB\nMemAvailable: 600 kB\nMemFree: 100 kB\nCached: 500 kB\n")
self.monitor = hub.VpsResourceMonitor(self.proc)
def test_cpu_uses_interval_delta_without_double_counting_guest_ticks(self):
# 100 total ticks, 70 idle+iowait ticks; guest counters are duplicated.
self.proc.joinpath("stat").write_text("cpu 110 20 40 550 70 15 15 10 45 20\n")
self.assertEqual(self.monitor.cpu_usage()["percent"], 30.0)
self.assertIsNone(self.monitor.cpu_usage()["percent"], "zero interval must not invent a CPU reading")
self.proc.joinpath("stat").write_text("cpu 1 0 0 1\n")
self.assertIsNone(self.monitor.cpu_usage()["percent"], "reset counters must not give negative load")
def test_memory_counts_available_cache_as_available_ram(self):
memory = self.monitor.memory_usage()
self.assertEqual(memory["percent"], 40.0)
self.assertEqual(memory["used_bytes"], 400 * 1024)
self.assertEqual(memory["available_bytes"], 600 * 1024)
def test_memory_fallback_and_bounds(self):
self.proc.joinpath("meminfo").write_text("MemTotal: 1000 kB\nMemFree: 100 kB\nBuffers: 50 kB\nCached: 200 kB\nSReclaimable: 100 kB\nShmem: 50 kB\n")
self.assertEqual(self.monitor.memory_usage()["percent"], 60.0)
self.proc.joinpath("meminfo").write_text("MemTotal: 1000 kB\nMemAvailable: 2000 kB\n")
self.assertEqual(self.monitor.memory_usage()["percent"], 0.0)
def test_disk_reports_root_filesystem_used_free_and_total(self):
with mock.patch.object(hub.shutil, "disk_usage", return_value=SimpleNamespace(total=1000, used=250, free=750)) as disk:
metric = self.monitor.disk_usage()
disk.assert_called_once_with("/")
self.assertEqual(metric, {"percent": 25.0, "used_bytes": 250, "total_bytes": 1000, "free_bytes": 750, "path": "/"})
def test_shared_cache_samples_once_for_concurrent_viewers_then_refreshes(self):
with mock.patch.object(hub.time, "monotonic", return_value=10) as clock, mock.patch.object(self.monitor, "cpu_usage", return_value={"percent": 30, "cores": 2}) as cpu:
results = []
threads = [threading.Thread(target=lambda: results.append(self.monitor.snapshot())) for _ in range(8)]
for thread in threads: thread.start()
for thread in threads: thread.join(timeout=5)
self.assertEqual(len(results), 8)
self.assertEqual(cpu.call_count, 1)
clock.return_value = 12.99
self.monitor.snapshot()
self.assertEqual(cpu.call_count, 1)
clock.return_value = 13
self.monitor.snapshot()
self.assertEqual(cpu.call_count, 2)
def test_unavailable_proc_files_do_not_break_disk_or_response(self):
self.proc.joinpath("stat").write_text("invalid stat\n")
self.proc.joinpath("meminfo").write_text("MemTotal: invalid\n")
with mock.patch.object(hub.shutil, "disk_usage", return_value=SimpleNamespace(total=1000, used=250, free=750)):
result = self.monitor.snapshot()
self.assertIsNone(result["cpu"]["percent"])
self.assertIsNone(result["memory"])
self.assertEqual(result["disk"]["percent"], 25)
with mock.patch.object(hub.shutil, "disk_usage", side_effect=OSError("unavailable")):
self.assertIsNone(self.monitor.disk_usage())
class QuietHandler(hub.Handler):
def log_message(self, *args):
pass
class ResourceHttpTests(unittest.TestCase):
def test_metrics_require_hub_login_and_never_open_router_database(self):
app = hub.App(Path(STATE.name) / "unused.db", "test-session", "test-agent", "")
server = hub.HubHTTPServer(("127.0.0.1", 0), QuietHandler)
server.app = app
server.is_tls = False
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
url = f"http://127.0.0.1:{server.server_port}/api/vps/resources"
try:
with mock.patch.object(app, "conn", side_effect=AssertionError("metrics must not access SQLite")):
for headers in ({}, {"Authorization": "Bearer test-agent"}):
with self.assertRaises(urllib.error.HTTPError) as error:
urllib.request.urlopen(urllib.request.Request(url, headers=headers), timeout=5)
with error.exception as response:
self.assertEqual(response.code, 401)
self.assertFalse(json.load(response)["ok"])
request = urllib.request.Request(url, headers={"Cookie": "owrt_remote_session=test-session"})
with urllib.request.urlopen(request, timeout=5) as response:
self.assertEqual(response.headers["Cache-Control"], "no-store")
data = json.load(response)
self.assertTrue(data["ok"])
self.assertEqual(set(data), {"ok", "cpu", "memory", "disk", "sampled_at"})
self.assertGreater(data["disk"]["total_bytes"], 0)
finally:
server.shutdown()
server.server_close()
thread.join(timeout=5)
def export_preview(output):
output.mkdir(parents=True, exist_ok=True)
with mock.patch.object(hub, "web_push_backend_status", return_value={"ready": False}):
page = hub.dashboard_html([], "root", auth_bootstrap={"is_owner": True, "can_add_router": True})
output.joinpath("dashboard.html").write_text(page, encoding="utf-8")
output.joinpath("dashboard.js").write_text("\n".join(re.findall(r"<script>(.*?)</script>", page, re.S)), encoding="utf-8")
print(f"Exported preview: {output}")
if __name__ == "__main__":
if len(sys.argv) == 3 and sys.argv[1] == "--export-preview":
export_preview(Path(sys.argv[2]))
else:
unittest.main()
+98
View File
@@ -0,0 +1,98 @@
// node tests/test_vps_resources_ui.cjs <exported-dashboard.js>
const assert = require('node:assert/strict');
const fs = require('node:fs');
const vm = require('node:vm');
const source = fs.readFileSync(process.argv[2], 'utf8').replace(/\r\n/g, '\n');
const begin = source.indexOf('function initVpsResourceWidgets() {');
const end = source.indexOf('\nsetInterval(loadRouters, 5000);', begin);
assert(begin >= 0 && end > begin);
const flush = async () => { for (let i = 0; i < 8; i++) await Promise.resolve(); };
function fixture() {
const timers = new Map(), documentEvents = {}, windowEvents = {}, calls = [];
let nextId = 1;
const widgets = ['cpu', 'memory', 'disk', 'cpu', 'memory', 'disk'].map(key => ({
dataset: {vpsResource: key}, label: {textContent: {cpu: 'ЦП', memory: 'ОЗУ', disk: 'ДИСК'}[key]},
value: {textContent: '—'}, title: '',
querySelector(selector) { return selector === 'span' ? this.label : this.value; },
setAttribute(key, value) { this[key] = value; },
}));
const metrics = {ok: true, cpu: {percent: 25, cores: 2}, memory: {percent: 40, used_bytes: 1024, total_bytes: 2048}, disk: {percent: 60, used_bytes: 2048, total_bytes: 4096}};
const context = {
Intl, AbortController,
document: {hidden: false, querySelectorAll() { return widgets; }, addEventListener(key, fn) { documentEvents[key] = fn; }},
window: {addEventListener(key, fn) { windowEvents[key] = fn; }},
setInterval(fn, ms) { const id = nextId++; timers.set(id, {fn, ms, interval: true}); return id; },
setTimeout(fn, ms) { const id = nextId++; timers.set(id, {fn, ms}); return id; },
clearInterval(id) { timers.delete(id); }, clearTimeout(id) { timers.delete(id); },
fetch(url, options) { calls.push({url, options}); return context.respond(url, options); },
respond: async () => ({ok: true, status: 200, json: async () => metrics}),
};
vm.createContext(context);
vm.runInContext(source.slice(begin, end), context);
return {context, timers, calls, widgets, documentEvents, windowEvents,
tick() { const timer = [...timers.values()].find(t => t.interval); assert(timer); return timer.fn(); },
intervals() { return [...timers.values()].filter(t => t.interval); },
};
}
(async () => {
const f = fixture();
await flush();
assert.equal(f.calls.length, 1, 'first update starts immediately');
assert.equal(f.intervals().length, 1);
assert.equal(f.intervals()[0].ms, 3000);
assert.equal(f.calls[0].url, '/api/vps/resources');
assert.equal(f.calls[0].options.cache, 'no-store');
assert.equal(f.widgets[0].value.textContent, '25%');
assert.equal(f.widgets[3].value.textContent, '25%');
assert(f.widgets[1].title.includes('1 КиБ из 2 КиБ'));
assert(f.widgets[2].title.includes('раздел /'));
let finish;
f.context.respond = () => new Promise(resolve => { finish = resolve; });
f.tick(); f.tick();
assert.equal(f.calls.length, 2, 'slow requests must not overlap');
finish({ok: true, status: 200, json: async () => ({ok: true, cpu: {percent: 50, cores: 2}, memory: null, disk: null})});
await flush();
assert.equal(f.widgets[0].value.textContent, '50%');
assert.equal(f.widgets[1].value.textContent, '—');
f.context.respond = async () => { throw new Error('offline'); };
f.tick(); await flush();
assert.equal(f.widgets[0].value.textContent, '—', 'failed fetch must not pretend old numbers are live');
assert.equal(f.widgets[0].dataset.stale, 'true');
f.context.respond = async () => ({ok: true, status: 200, json: async () => ({ok: true, cpu: {percent: 0, cores: 1}})});
f.tick(); await flush();
assert.equal(f.widgets[0].value.textContent, '0%');
assert.equal(f.widgets[0].dataset.stale, 'false');
f.context.document.hidden = true;
f.documentEvents.visibilitychange();
assert.equal(f.intervals().length, 0);
f.context.document.hidden = false;
f.documentEvents.visibilitychange(); await flush();
assert.equal(f.intervals().length, 1);
f.windowEvents.pagehide();
assert.equal(f.intervals().length, 0);
f.windowEvents.pageshow(); await flush();
assert.equal(f.intervals().length, 1, 'BFCache restore must resume once');
f.context.respond = async () => ({ok: false, status: 401});
f.tick(); await flush();
assert.equal(f.intervals().length, 0, 'expired sessions stop polling');
const count = f.calls.length;
f.documentEvents.visibilitychange(); await flush();
assert.equal(f.calls.length, count);
const g = fixture(); await flush();
g.context.respond = (url, options) => new Promise((resolve, reject) => options.signal.addEventListener('abort', () => reject(new Error('timeout'))));
g.tick();
const timeout = [...g.timers.values()].find(timer => !timer.interval);
assert.equal(timeout.ms, 2500);
timeout.fn(); await flush();
assert(g.calls.at(-1).options.signal.aborted);
assert.equal(g.widgets[0].dataset.stale, 'true');
g.windowEvents.pagehide();
console.log('VPS_WIDGETS_UI_OK: immediate/3s updates, no overlaps, desktop/mobile, errors, timeout, pause/resume and session expiry');
})().catch(error => { console.error(error); process.exitCode = 1; });