mirror of
https://github.com/rightup/pyMC_Repeater.git
synced 2026-03-28 17:43:06 +01:00
343 lines
13 KiB
Python
343 lines
13 KiB
Python
import json
|
|
import logging
|
|
import os
|
|
import re
|
|
from collections import deque
|
|
from datetime import datetime
|
|
from typing import Callable, Optional
|
|
|
|
import cherrypy
|
|
from pymc_core.protocol.utils import PAYLOAD_TYPES, ROUTE_TYPES
|
|
|
|
from repeater import __version__
|
|
from .api_endpoints import APIEndpoints
|
|
|
|
logger = logging.getLogger("HTTPServer")
|
|
|
|
|
|
# In-memory log buffer
|
|
class LogBuffer(logging.Handler):
|
|
|
|
def __init__(self, max_lines=100):
|
|
super().__init__()
|
|
self.logs = deque(maxlen=max_lines)
|
|
self.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
|
|
|
|
def emit(self, record):
|
|
|
|
try:
|
|
msg = self.format(record)
|
|
self.logs.append(
|
|
{
|
|
"message": msg,
|
|
"timestamp": datetime.fromtimestamp(record.created).isoformat(),
|
|
"level": record.levelname,
|
|
}
|
|
)
|
|
except Exception:
|
|
self.handleError(record)
|
|
|
|
|
|
# Global log buffer instance
|
|
_log_buffer = LogBuffer(max_lines=100)
|
|
|
|
class StatsApp:
|
|
|
|
def __init__(
|
|
self,
|
|
stats_getter: Optional[Callable] = None,
|
|
template_dir: Optional[str] = None,
|
|
node_name: str = "Repeater",
|
|
pub_key: str = "",
|
|
send_advert_func: Optional[Callable] = None,
|
|
config: Optional[dict] = None,
|
|
event_loop=None,
|
|
daemon_instance=None,
|
|
config_path=None,
|
|
):
|
|
|
|
self.stats_getter = stats_getter
|
|
self.template_dir = template_dir
|
|
self.node_name = node_name
|
|
self.pub_key = pub_key
|
|
self.dashboard_template = None
|
|
self.config = config or {}
|
|
|
|
# Create nested API object for routing
|
|
self.api = APIEndpoints(stats_getter, send_advert_func, self.config, event_loop, daemon_instance, config_path)
|
|
|
|
# Load template on init
|
|
if template_dir:
|
|
template_path = os.path.join(template_dir, "dashboard.html")
|
|
try:
|
|
with open(template_path, "r") as f:
|
|
self.dashboard_template = f.read()
|
|
logger.info(f"Loaded template from {template_path}")
|
|
except FileNotFoundError:
|
|
logger.error(f"Template not found: {template_path}")
|
|
|
|
@cherrypy.expose
|
|
def index(self):
|
|
"""Serve dashboard HTML."""
|
|
return self._serve_template("dashboard.html")
|
|
|
|
@cherrypy.expose
|
|
def neighbors(self):
|
|
"""Serve neighbors page."""
|
|
return self._serve_template("neighbors.html")
|
|
|
|
@cherrypy.expose
|
|
def statistics(self):
|
|
"""Serve statistics page."""
|
|
return self._serve_template("statistics.html")
|
|
|
|
@cherrypy.expose
|
|
def configuration(self):
|
|
"""Serve configuration page."""
|
|
return self._serve_template("configuration.html")
|
|
|
|
@cherrypy.expose
|
|
def logs(self):
|
|
"""Serve logs page."""
|
|
return self._serve_template("logs.html")
|
|
|
|
@cherrypy.expose
|
|
def help(self):
|
|
"""Serve help documentation."""
|
|
return self._serve_template("help.html")
|
|
|
|
@cherrypy.expose
|
|
def cad_calibration(self):
|
|
"""Serve CAD calibration page."""
|
|
return self._serve_template("cad-calibration.html")
|
|
|
|
def _serve_template(self, template_name: str):
|
|
"""Serve HTML template with stats."""
|
|
if not self.template_dir:
|
|
return "<h1>Error</h1><p>Template directory not configured</p>"
|
|
|
|
if not self.dashboard_template:
|
|
return "<h1>Error</h1><p>Template not loaded</p>"
|
|
|
|
try:
|
|
|
|
template_path = os.path.join(self.template_dir, template_name)
|
|
with open(template_path, "r") as f:
|
|
template_content = f.read()
|
|
|
|
nav_path = os.path.join(self.template_dir, "nav.html")
|
|
nav_content = ""
|
|
try:
|
|
with open(nav_path, "r") as f:
|
|
nav_content = f.read()
|
|
except FileNotFoundError:
|
|
logger.warning(f"Navigation template not found: {nav_path}")
|
|
|
|
stats = self.stats_getter() if self.stats_getter else {}
|
|
|
|
if "uptime_seconds" not in stats or not isinstance(
|
|
stats.get("uptime_seconds"), (int, float)
|
|
):
|
|
stats["uptime_seconds"] = 0
|
|
|
|
# Calculate uptime in hours
|
|
uptime_seconds = stats.get("uptime_seconds", 0)
|
|
uptime_hours = int(uptime_seconds // 3600) if uptime_seconds else 0
|
|
|
|
# Determine current page for nav highlighting
|
|
page_map = {
|
|
"dashboard.html": "dashboard",
|
|
"neighbors.html": "neighbors",
|
|
"statistics.html": "statistics",
|
|
"configuration.html": "configuration",
|
|
"cad-calibration.html": "cad-calibration",
|
|
"logs.html": "logs",
|
|
"help.html": "help",
|
|
}
|
|
current_page = page_map.get(template_name, "")
|
|
|
|
# Prepare basic substitutions
|
|
html = template_content
|
|
html = html.replace("{{ node_name }}", str(self.node_name))
|
|
html = html.replace("{{ last_updated }}", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
|
|
html = html.replace("{{ page }}", current_page)
|
|
|
|
# Replace navigation placeholder with actual nav content
|
|
if "<!-- NAVIGATION_PLACEHOLDER -->" in html:
|
|
nav_substitutions = nav_content
|
|
nav_substitutions = nav_substitutions.replace(
|
|
"{{ node_name }}", str(self.node_name)
|
|
)
|
|
nav_substitutions = nav_substitutions.replace("{{ pub_key }}", str(self.pub_key))
|
|
nav_substitutions = nav_substitutions.replace(
|
|
"{{ last_updated }}", datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
)
|
|
|
|
# Handle active state for nav items
|
|
nav_substitutions = nav_substitutions.replace(
|
|
"{{ ' active' if page == 'dashboard' else '' }}",
|
|
" active" if current_page == "dashboard" else "",
|
|
)
|
|
nav_substitutions = nav_substitutions.replace(
|
|
"{{ ' active' if page == 'neighbors' else '' }}",
|
|
" active" if current_page == "neighbors" else "",
|
|
)
|
|
nav_substitutions = nav_substitutions.replace(
|
|
"{{ ' active' if page == 'statistics' else '' }}",
|
|
" active" if current_page == "statistics" else "",
|
|
)
|
|
nav_substitutions = nav_substitutions.replace(
|
|
"{{ ' active' if page == 'configuration' else '' }}",
|
|
" active" if current_page == "configuration" else "",
|
|
)
|
|
nav_substitutions = nav_substitutions.replace(
|
|
"{{ ' active' if page == 'logs' else '' }}",
|
|
" active" if current_page == "logs" else "",
|
|
)
|
|
nav_substitutions = nav_substitutions.replace(
|
|
"{{ ' active' if page == 'help' else '' }}",
|
|
" active" if current_page == "help" else "",
|
|
)
|
|
|
|
html = html.replace("<!-- NAVIGATION_PLACEHOLDER -->", nav_substitutions)
|
|
|
|
# Build packets table HTML for dashboard
|
|
if template_name == "dashboard.html":
|
|
recent_packets = stats.get("recent_packets", [])
|
|
packets_table = ""
|
|
|
|
if recent_packets:
|
|
for pkt in recent_packets[-20:]: # Last 20 packets
|
|
time_obj = datetime.fromtimestamp(pkt.get("timestamp", 0))
|
|
time_str = time_obj.strftime("%H:%M:%S")
|
|
pkt_type = PAYLOAD_TYPES.get(
|
|
pkt.get("type", 0), f"0x{pkt.get('type', 0): 02x}"
|
|
)
|
|
route_type = pkt.get("route", 0)
|
|
route = ROUTE_TYPES.get(route_type, f"UNKNOWN_{route_type}")
|
|
status = "OK TX" if pkt.get("transmitted") else "WAIT"
|
|
|
|
# Get proper CSS class for route type
|
|
route_class = route.lower().replace("_", "-")
|
|
snr_val = pkt.get("snr", 0.0)
|
|
score_val = pkt.get("score", 0)
|
|
delay_val = pkt.get("tx_delay_ms", 0)
|
|
|
|
packets_table += (
|
|
"<tr>"
|
|
f"<td>{time_str}</td>"
|
|
f'<td><span class="packet-type">{pkt_type}</span></td>'
|
|
f'<td><span class="route-{route_class}">{route}</span></td>'
|
|
f"<td>{pkt.get('length', 0)}</td>"
|
|
f"<td>{pkt.get('rssi', 0)}</td>"
|
|
f"<td>{snr_val: .1f}</td>"
|
|
f'<td><span class="score">{score_val: .2f}</span></td>'
|
|
f"<td>{delay_val: .0f}</td>"
|
|
f"<td>{status}</td>"
|
|
"</tr>"
|
|
)
|
|
else:
|
|
packets_table = """
|
|
<tr>
|
|
<td colspan="9" class="empty-message">
|
|
No packets received yet - waiting for traffic...
|
|
</td>
|
|
</tr>
|
|
"""
|
|
|
|
# Add dashboard-specific substitutions
|
|
html = html.replace("{{ rx_count }}", str(stats.get("rx_count", 0)))
|
|
html = html.replace("{{ forwarded_count }}", str(stats.get("forwarded_count", 0)))
|
|
html = html.replace("{{ dropped_count }}", str(stats.get("dropped_count", 0)))
|
|
html = html.replace("{{ uptime_hours }}", str(uptime_hours))
|
|
|
|
# Replace tbody with actual packets
|
|
tbody_pattern = r'<tbody id="packet-table">.*?</tbody>'
|
|
tbody_replacement = f'<tbody id="packet-table">\n{packets_table}\n</tbody>'
|
|
html = re.sub(
|
|
tbody_pattern,
|
|
tbody_replacement,
|
|
html,
|
|
flags=re.DOTALL,
|
|
)
|
|
|
|
return html
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error rendering template {template_name}: {e}", exc_info=True)
|
|
return f"<h1>Error</h1><p>{str(e)}</p>"
|
|
|
|
|
|
class HTTPStatsServer:
|
|
|
|
def __init__(
|
|
self,
|
|
host: str = "0.0.0.0",
|
|
port: int = 8000,
|
|
stats_getter: Optional[Callable] = None,
|
|
template_dir: Optional[str] = None,
|
|
node_name: str = "Repeater",
|
|
pub_key: str = "",
|
|
send_advert_func: Optional[Callable] = None,
|
|
config: Optional[dict] = None,
|
|
event_loop=None,
|
|
daemon_instance=None,
|
|
config_path=None,
|
|
):
|
|
|
|
self.host = host
|
|
self.port = port
|
|
self.app = StatsApp(
|
|
stats_getter, template_dir, node_name, pub_key, send_advert_func, config, event_loop, daemon_instance, config_path
|
|
)
|
|
|
|
def start(self):
|
|
|
|
try:
|
|
# Serve static files from templates directory
|
|
static_dir = (
|
|
self.app.template_dir if self.app.template_dir else os.path.dirname(__file__)
|
|
)
|
|
|
|
config = {
|
|
"/": {
|
|
"tools.sessions.on": False,
|
|
},
|
|
"/static": {
|
|
"tools.staticdir.on": True,
|
|
"tools.staticdir.dir": static_dir,
|
|
},
|
|
}
|
|
|
|
cherrypy.config.update(
|
|
{
|
|
"server.socket_host": self.host,
|
|
"server.socket_port": self.port,
|
|
"engine.autoreload.on": False,
|
|
"log.screen": False,
|
|
"log.access_file": "", # Disable access log file
|
|
"log.error_file": "", # Disable error log file
|
|
}
|
|
)
|
|
|
|
cherrypy.tree.mount(self.app, "/", config)
|
|
|
|
# Completely disable access logging
|
|
cherrypy.log.access_log.propagate = False
|
|
cherrypy.log.error_log.setLevel(logging.ERROR)
|
|
|
|
cherrypy.engine.start()
|
|
server_url = "http://{}:{}".format(self.host, self.port)
|
|
logger.info(f"HTTP stats server started on {server_url}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to start HTTP server: {e}")
|
|
raise
|
|
|
|
def stop(self):
|
|
try:
|
|
cherrypy.engine.exit()
|
|
logger.info("HTTP stats server stopped")
|
|
except Exception as e:
|
|
logger.warning(f"Error stopping HTTP server: {e}")
|