154 lines
4.4 KiB
Python
154 lines
4.4 KiB
Python
#!/usr/bin/env python3
|
|
"""WebSocket server that sends real Pi system stats every 2 seconds.
|
|
|
|
Drop-in replacement for mock_server.py. Same port (8765), same JSON schema,
|
|
same 2s push interval. Services remain mocked until systemd integration is added.
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import subprocess
|
|
import time
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
|
|
import psutil
|
|
import websockets
|
|
|
|
# Prime the CPU percent counter (first call always returns 0.0)
|
|
psutil.cpu_percent(interval=None)
|
|
|
|
# Network baseline for delta calculation
|
|
_prev_net = psutil.net_io_counters()
|
|
_prev_net_time = time.monotonic()
|
|
|
|
|
|
def _get_cpu_temp() -> float:
|
|
"""Read CPU temperature with fallback for different Pi OS versions."""
|
|
try:
|
|
temps = psutil.sensors_temperatures()
|
|
if "cpu_thermal" in temps and temps["cpu_thermal"]:
|
|
return round(temps["cpu_thermal"][0].current, 1)
|
|
except (AttributeError, KeyError):
|
|
pass
|
|
|
|
# Fallback: read sysfs directly (value is in millidegrees)
|
|
thermal_path = Path("/sys/class/thermal/thermal_zone0/temp")
|
|
try:
|
|
millidegrees = int(thermal_path.read_text().strip())
|
|
return round(millidegrees / 1000.0, 1)
|
|
except (FileNotFoundError, ValueError, PermissionError):
|
|
return 0.0
|
|
|
|
|
|
def _get_net_throughput() -> tuple[float, float]:
|
|
"""Calculate network rx/tx in kbps since last call."""
|
|
global _prev_net, _prev_net_time
|
|
|
|
now = time.monotonic()
|
|
current = psutil.net_io_counters()
|
|
elapsed = now - _prev_net_time
|
|
|
|
if elapsed <= 0:
|
|
return 0.0, 0.0
|
|
|
|
rx_kbps = round((current.bytes_recv - _prev_net.bytes_recv) * 8 / (elapsed * 1000), 1)
|
|
tx_kbps = round((current.bytes_sent - _prev_net.bytes_sent) * 8 / (elapsed * 1000), 1)
|
|
|
|
_prev_net = current
|
|
_prev_net_time = now
|
|
|
|
return rx_kbps, tx_kbps
|
|
|
|
|
|
def _get_docker_services() -> list[dict]:
|
|
"""Query Docker for real container statuses with ternary status model."""
|
|
try:
|
|
result = subprocess.run(
|
|
["docker", "ps", "-a", "--format", "{{.Names}}\t{{.Status}}"],
|
|
capture_output=True, text=True, timeout=5,
|
|
)
|
|
except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
|
|
return []
|
|
|
|
if result.returncode != 0:
|
|
return []
|
|
|
|
services = []
|
|
for line in result.stdout.strip().splitlines():
|
|
parts = line.split("\t", 1)
|
|
if len(parts) != 2:
|
|
continue
|
|
name, raw_status = parts
|
|
|
|
if raw_status.startswith("Up"):
|
|
if "unhealthy" in raw_status or "Restarting" in raw_status:
|
|
status = "warning"
|
|
else:
|
|
status = "running"
|
|
else:
|
|
status = "stopped"
|
|
|
|
services.append({"name": name, "status": status})
|
|
|
|
# Sort: warnings first, then stopped, then running (problems float to top)
|
|
order = {"warning": 0, "stopped": 1, "running": 2}
|
|
services.sort(key=lambda s: order.get(s["status"], 3))
|
|
|
|
return services
|
|
|
|
|
|
def _local_time_fields() -> dict:
|
|
"""Current local time as broken-down fields for RTC sync."""
|
|
now = datetime.now()
|
|
return {
|
|
"y": now.year,
|
|
"mo": now.month,
|
|
"d": now.day,
|
|
"h": now.hour,
|
|
"m": now.minute,
|
|
"s": now.second,
|
|
}
|
|
|
|
|
|
def generate_stats() -> dict:
|
|
mem = psutil.virtual_memory()
|
|
disk = psutil.disk_usage("/mnt/buffalo")
|
|
rx_kbps, tx_kbps = _get_net_throughput()
|
|
|
|
return {
|
|
"cpu_pct": psutil.cpu_percent(interval=None),
|
|
"mem_pct": round(mem.percent, 1),
|
|
"mem_used_mb": int(mem.used // (1024 * 1024)),
|
|
"disk_pct": round(disk.percent, 1),
|
|
"cpu_temp": _get_cpu_temp(),
|
|
"uptime_hrs": round((time.time() - psutil.boot_time()) / 3600, 1),
|
|
"net_rx_kbps": rx_kbps / 8,
|
|
"net_tx_kbps": tx_kbps / 8, # kByte/s for humans
|
|
"services": _get_docker_services(),
|
|
"timestamp": int(time.time()),
|
|
"local_time": _local_time_fields(),
|
|
}
|
|
|
|
|
|
async def handler(websocket):
|
|
addr = websocket.remote_address
|
|
print(f"Client connected: {addr}")
|
|
try:
|
|
while True:
|
|
stats = generate_stats()
|
|
await websocket.send(json.dumps(stats))
|
|
await asyncio.sleep(2)
|
|
except websockets.ConnectionClosed:
|
|
print(f"Client disconnected: {addr}")
|
|
|
|
|
|
async def main():
|
|
print("Pi stats server starting on ws://0.0.0.0:8765")
|
|
async with websockets.serve(handler, "0.0.0.0", 8765):
|
|
await asyncio.Future() # run forever
|
|
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(main())
|