125 lines
4.6 KiB
Python
125 lines
4.6 KiB
Python
#!/usr/bin/env python3
|
|
import json
|
|
import subprocess
|
|
import os
|
|
import time
|
|
import threading
|
|
from collections import deque
|
|
from http.server import BaseHTTPRequestHandler, HTTPServer
|
|
|
|
# --- CONFIGURATION ---
|
|
PORT = 8080
|
|
IFACE = "vmbr0"
|
|
ENABLE_PVE_STATS = True
|
|
# ---------------------
|
|
|
|
# Rolling memory buffers (stores exactly 60 seconds of data)
|
|
hist_cpu = deque([0]*60, maxlen=60)
|
|
hist_ram = deque([0]*60, maxlen=60)
|
|
hist_rx = deque([0.0]*60, maxlen=60)
|
|
hist_tx = deque([0.0]*60, maxlen=60)
|
|
|
|
# Dictionary to hold the most recent slow-changing data
|
|
latest_state = {}
|
|
|
|
def run_cmd(cmd):
|
|
try:
|
|
return subprocess.check_output(cmd, shell=True, stderr=subprocess.DEVNULL).decode('utf-8').strip()
|
|
except Exception:
|
|
return None
|
|
|
|
def get_cpu_times():
|
|
"""Reads raw CPU ticks directly from the kernel (ultra-fast, no blocking)"""
|
|
with open('/proc/stat', 'r') as f:
|
|
for line in f:
|
|
if line.startswith('cpu '):
|
|
parts = list(map(int, line.split()[1:]))
|
|
idle = parts[3] + parts[4] # idle + iowait
|
|
total = sum(parts)
|
|
return idle, total
|
|
return 0, 0
|
|
|
|
def background_poller():
|
|
"""Runs in the background, gathering data every 1 second."""
|
|
global latest_state
|
|
|
|
# Baseline for 1-second delta calculations
|
|
prev_idle, prev_total = get_cpu_times()
|
|
rx_prev = int(run_cmd(f"cat /sys/class/net/{IFACE}/statistics/rx_bytes") or 0)
|
|
tx_prev = int(run_cmd(f"cat /sys/class/net/{IFACE}/statistics/tx_bytes") or 0)
|
|
|
|
while True:
|
|
time.sleep(1) # The 1-second heartbeat
|
|
|
|
try:
|
|
# 1. CPU Delta Calculation
|
|
idle, total = get_cpu_times()
|
|
diff_idle = idle - prev_idle
|
|
diff_total = total - prev_total
|
|
cpu_pct = (1.0 - (diff_idle / diff_total)) * 100.0 if diff_total > 0 else 0.0
|
|
hist_cpu.append(round(cpu_pct, 1))
|
|
prev_idle, prev_total = idle, total
|
|
|
|
# 2. Network Delta Calculation (Changed to Mbps)
|
|
rx_now = int(run_cmd(f"cat /sys/class/net/{IFACE}/statistics/rx_bytes") or 0)
|
|
tx_now = int(run_cmd(f"cat /sys/class/net/{IFACE}/statistics/tx_bytes") or 0)
|
|
|
|
# Multiply by 8 for bits, divide by 1,000,000 for Megabits
|
|
hist_rx.append(round(((rx_now - rx_prev) * 8) / 1000000, 2))
|
|
hist_tx.append(round(((tx_now - tx_prev) * 8) / 1000000, 2))
|
|
rx_prev, tx_prev = rx_now, tx_now
|
|
|
|
# 3. RAM Snapshot
|
|
ram_raw = run_cmd("free -b | grep Mem | awk '{print $2, $3}'")
|
|
if ram_raw:
|
|
ram_total, ram_used = map(int, ram_raw.split())
|
|
ram_pct = (ram_used / ram_total) * 100.0
|
|
hist_ram.append(round(ram_pct, 1))
|
|
latest_state["ram"] = {
|
|
"percent": round(ram_pct, 1),
|
|
"used_gb": round(ram_used / (1024**3), 1),
|
|
"total_gb": round(ram_total / (1024**3), 1)
|
|
}
|
|
|
|
# 4. Storage & System Health
|
|
st = os.statvfs('/')
|
|
latest_state["root_disk_pct"] = round((1.0 - (st.f_bavail / st.f_blocks)) * 100.0, 1)
|
|
|
|
if ENABLE_PVE_STATS:
|
|
latest_state["vms_running"] = int(run_cmd("qm list | grep running | wc -l") or 0)
|
|
latest_state["lxcs_running"] = int(run_cmd("pct list | grep running | wc -l") or 0)
|
|
|
|
except Exception as e:
|
|
print(f"Poller error: {e}")
|
|
|
|
class MetricsHandler(BaseHTTPRequestHandler):
|
|
def do_GET(self):
|
|
if self.path == '/api/homelab':
|
|
self.send_response(200)
|
|
self.send_header('Content-type', 'application/json')
|
|
self.send_header('Access-Control-Allow-Origin', '*')
|
|
self.end_headers()
|
|
|
|
# Package the latest instantaneous data + the full 60s history arrays
|
|
data = latest_state.copy()
|
|
data["cpu"] = hist_cpu[-1] if hist_cpu else 0
|
|
data["rx_mb"] = hist_rx[-1] if hist_rx else 0
|
|
data["tx_mb"] = hist_tx[-1] if hist_tx else 0
|
|
|
|
data["cpu_hist"] = list(hist_cpu)
|
|
data["ram_hist"] = list(hist_ram)
|
|
data["rx_hist"] = list(hist_rx)
|
|
data["tx_hist"] = list(hist_tx)
|
|
|
|
self.wfile.write(json.dumps(data).encode())
|
|
else:
|
|
self.send_response(404)
|
|
self.end_headers()
|
|
|
|
if __name__ == '__main__':
|
|
# Start the data collector in the background
|
|
threading.Thread(target=background_poller, daemon=True).start()
|
|
|
|
server = HTTPServer(('0.0.0.0', PORT), MetricsHandler)
|
|
print(f"Starting API on port {PORT}...")
|
|
server.serve_forever() |