root
399 lines
13 KiB
Python
399 lines
13 KiB
Python
"""
|
||
Flask REST-API und statische Dateien.
|
||
"""
|
||
import os
|
||
import signal
|
||
import threading
|
||
import time
|
||
from datetime import datetime, timezone
|
||
from flask import Flask, jsonify, send_from_directory, abort, request as flask_request
|
||
|
||
import database as db
|
||
|
||
app = Flask(__name__, static_folder='web', static_url_path='/static')
|
||
|
||
# Wird vom main.py gesetzt
|
||
_monitor = None
|
||
|
||
|
||
def set_monitor(monitor):
|
||
global _monitor
|
||
_monitor = monitor
|
||
|
||
|
||
# ── Statische Dateien ────────────────────────────────────────────────────────
|
||
|
||
@app.route('/')
|
||
def index():
|
||
return send_from_directory('web', 'index.html')
|
||
|
||
|
||
# ── API Endpunkte ────────────────────────────────────────────────────────────
|
||
|
||
@app.route('/api/status')
|
||
def api_status():
|
||
"""Aktueller Systemstatus."""
|
||
mon_status = _monitor.status() if _monitor else {}
|
||
traffic = db.query_current_traffic()
|
||
fritz = db.query_fritz_latest()
|
||
|
||
# Heutige Ausfälle
|
||
today_start = int(datetime.now(timezone.utc).replace(hour=0, minute=0, second=0).timestamp())
|
||
outages_today = db.query_outages(since_ts=today_start, limit=500)
|
||
total_outage_s = sum(o['duration_s'] or 0 for o in outages_today if o['end_ts'])
|
||
current_outage = next((o for o in outages_today if not o['end_ts']), None)
|
||
|
||
devices = db.query_devices()
|
||
active_count = sum(1 for d in devices if d['is_active'])
|
||
|
||
return jsonify({
|
||
'internet_up': mon_status.get('internet_up', True),
|
||
'bps_up': traffic.get('bps_sent', 0),
|
||
'bps_down': traffic.get('bps_recv', 0),
|
||
'active_devices': active_count,
|
||
'total_devices': len(devices),
|
||
'outages_today': len([o for o in outages_today if o['end_ts']]),
|
||
'total_outage_seconds_today': total_outage_s,
|
||
'current_outage_since': current_outage['start_ts'] if current_outage else None,
|
||
'fritz': {
|
||
'available': fritz is not None,
|
||
'is_connected': fritz['is_connected'] if fritz else None,
|
||
'external_ip': fritz['external_ip'] if fritz else None,
|
||
'uptime_s': fritz['uptime_s'] if fritz else None,
|
||
'max_up_bps': fritz['max_up_bps'] if fritz else None,
|
||
'max_down_bps': fritz['max_down_bps'] if fritz else None,
|
||
},
|
||
})
|
||
|
||
|
||
@app.route('/api/traffic')
|
||
def api_traffic():
|
||
"""Traffic-Zeitreihe. ?range=1h|6h|24h|7d|30d"""
|
||
from flask import request
|
||
range_map = {
|
||
'1h': (3600, 60),
|
||
'6h': (21600, 300),
|
||
'24h': (86400, 900),
|
||
'7d': (604800, 3600),
|
||
'30d': (2592000, 14400),
|
||
}
|
||
r = request.args.get('range', '1h')
|
||
seconds, bucket = range_map.get(r, (3600, 60))
|
||
since = int(time.time()) - seconds
|
||
|
||
rows = db.query_traffic(since_ts=since, bucket_size=bucket)
|
||
labels = [_fmt_ts(row['bucket'], r) for row in rows]
|
||
upload = [round(row['bps_sent'] / 1000, 2) for row in rows] # kbit/s
|
||
download = [round(row['bps_recv'] / 1000, 2) for row in rows]
|
||
|
||
return jsonify({'labels': labels, 'upload': upload, 'download': download})
|
||
|
||
|
||
@app.route('/api/outages')
|
||
def api_outages():
|
||
"""Ausfalls-Historie."""
|
||
from flask import request
|
||
limit = int(request.args.get('limit', 100))
|
||
since = request.args.get('since')
|
||
since_ts = int(since) if since else None
|
||
|
||
rows = db.query_outages(since_ts=since_ts, limit=limit)
|
||
result = []
|
||
for r in rows:
|
||
duration = r['duration_s']
|
||
result.append({
|
||
'id': r['id'],
|
||
'start_ts': r['start_ts'],
|
||
'end_ts': r['end_ts'],
|
||
'duration_s': duration,
|
||
'duration_human': _human_duration(duration) if duration else 'Läuft noch',
|
||
'start_human': _fmt_dt(r['start_ts']),
|
||
'end_human': _fmt_dt(r['end_ts']) if r['end_ts'] else 'Läuft noch',
|
||
})
|
||
return jsonify(result)
|
||
|
||
|
||
@app.route('/api/devices')
|
||
def api_devices():
|
||
"""Alle Geräte mit Status und Port-Anzahl."""
|
||
devices = db.query_devices()
|
||
result = []
|
||
for d in devices:
|
||
result.append({
|
||
'id': d['id'],
|
||
'mac': d['mac'],
|
||
'ip': d['ip'] or '',
|
||
'name': d['fritz_name'] or d['hostname'] or d['ip'] or d['mac'],
|
||
'hostname': d['hostname'] or '',
|
||
'fritz_name': d['fritz_name'] or '',
|
||
'vendor': d['vendor'] or '',
|
||
'iface_type': d['iface_type'] or '',
|
||
'is_active': bool(d['is_active']),
|
||
'first_seen': d['first_seen'],
|
||
'last_seen': d['last_seen'],
|
||
'last_seen_human': _fmt_dt(d['last_seen']),
|
||
'port_count': d['port_count'],
|
||
})
|
||
return jsonify(result)
|
||
|
||
|
||
@app.route('/api/devices/<int:device_id>/ports')
|
||
def api_device_ports(device_id):
|
||
"""Offene Ports eines Geräts."""
|
||
ports = db.query_device_ports(device_id)
|
||
return jsonify(ports)
|
||
|
||
|
||
@app.route('/api/packets')
|
||
def api_packets():
|
||
"""Live-Paketmitschnitt. ?since=UNIX_TS&limit=200&filter=text"""
|
||
from flask import request
|
||
since = float(request.args.get('since', time.time() - 30))
|
||
limit = int(request.args.get('limit', 200))
|
||
filter_text = request.args.get('filter', '').strip() or None
|
||
rows = db.query_packets(since_ts=since, limit=limit, filter_text=filter_text)
|
||
# Neueste zuletzt (für Append im Frontend)
|
||
rows.reverse()
|
||
return jsonify(rows)
|
||
|
||
|
||
@app.route('/api/ping_log')
|
||
def api_ping_log():
|
||
"""Letzter Ping-Log – zeigt auch kurze Ausfälle. ?minutes=60"""
|
||
from flask import request
|
||
minutes = int(request.args.get('minutes', 60))
|
||
since = int(time.time()) - minutes * 60
|
||
rows = db.query_ping_log(since_ts=since, limit=2000)
|
||
stats = db.query_ping_stats(since_ts=since)
|
||
return jsonify({'log': rows, 'stats': stats})
|
||
|
||
|
||
_ENV_PATH = '/app/.env'
|
||
|
||
# Whitelist aller erlaubten .env-Keys (verhindert willkürliche Datei-Injection)
|
||
_ALLOWED_KEYS = {
|
||
'FRITZ_HOST', 'FRITZ_USER', 'FRITZ_PASSWORD',
|
||
'MONITOR_INTERFACE', 'NETWORK_RANGE',
|
||
'TRAFFIC_INTERVAL', 'OUTAGE_CHECK_INTERVAL', 'DEVICE_SCAN_INTERVAL',
|
||
'PORT_SCAN_INTERVAL', 'FRITZ_POLL_INTERVAL',
|
||
'PING_TARGET_INTERVAL', 'DEVICE_PING_INTERVAL', 'PING_TARGETS',
|
||
'DB_PATH', 'WEB_HOST', 'WEB_PORT', 'LOG_LEVEL',
|
||
'SWITCH_ENABLED', 'SWITCH_HOST', 'SWITCH_PASSWORD',
|
||
'SWITCH_GATEWAY_PORT', 'SWITCH_INTERVAL',
|
||
'CAPTURE_ENABLED', 'CAPTURE_MAX_ROWS',
|
||
'CAPTURE_FILTER_ICMP', 'CAPTURE_FILTER_ARP',
|
||
'CAPTURE_FILTER_ZABBIX', 'CAPTURE_FILTER_RUSTDESK', 'CAPTURE_FILTER_EXTRA',
|
||
'OUTAGE_THRESHOLD',
|
||
# Benachrichtigungen
|
||
'NOTIFY_ON_DOWN', 'NOTIFY_ON_UP', 'NOTIFY_COOLDOWN',
|
||
'PUSHOVER_ENABLED', 'PUSHOVER_APP_TOKEN', 'PUSHOVER_USER_KEY',
|
||
'NCTALK_ENABLED', 'NCTALK_URL', 'NCTALK_USER', 'NCTALK_PASSWORD', 'NCTALK_ROOM',
|
||
}
|
||
|
||
|
||
def _read_env_file() -> list[str]:
|
||
try:
|
||
with open(_ENV_PATH, 'r') as f:
|
||
return f.readlines()
|
||
except FileNotFoundError:
|
||
return []
|
||
|
||
|
||
def _parse_env(lines: list[str]) -> dict:
|
||
result = {}
|
||
for line in lines:
|
||
stripped = line.strip()
|
||
if stripped and not stripped.startswith('#') and '=' in stripped:
|
||
key, _, val = stripped.partition('=')
|
||
result[key.strip()] = val.strip()
|
||
return result
|
||
|
||
|
||
def _write_env(updates: dict) -> None:
|
||
"""Schreibt aktualisierte Werte in .env, behält Kommentare und Struktur."""
|
||
lines = _read_env_file()
|
||
updated_keys = set()
|
||
|
||
new_lines = []
|
||
for line in lines:
|
||
stripped = line.strip()
|
||
if stripped and not stripped.startswith('#') and '=' in stripped:
|
||
key = stripped.split('=', 1)[0].strip()
|
||
if key in updates and key in _ALLOWED_KEYS:
|
||
new_lines.append(f'{key}={updates[key]}\n')
|
||
updated_keys.add(key)
|
||
continue
|
||
new_lines.append(line)
|
||
|
||
# Neue Keys anhängen die noch nicht in der Datei waren
|
||
for key, val in updates.items():
|
||
if key in _ALLOWED_KEYS and key not in updated_keys:
|
||
new_lines.append(f'{key}={val}\n')
|
||
|
||
with open(_ENV_PATH, 'w') as f:
|
||
f.writelines(new_lines)
|
||
|
||
|
||
@app.route('/api/config', methods=['GET'])
|
||
def api_config_get():
|
||
"""Aktuelle .env-Konfiguration auslesen."""
|
||
lines = _read_env_file()
|
||
config = _parse_env(lines)
|
||
return jsonify({k: v for k, v in config.items() if k in _ALLOWED_KEYS})
|
||
|
||
|
||
@app.route('/api/config', methods=['POST'])
|
||
def api_config_post():
|
||
"""Konfiguration speichern."""
|
||
data = flask_request.get_json(force=True)
|
||
if not data or not isinstance(data, dict):
|
||
return jsonify({'error': 'Ungültige Daten'}), 400
|
||
|
||
# Nur erlaubte Keys
|
||
updates = {k: str(v) for k, v in data.items() if k in _ALLOWED_KEYS}
|
||
if not updates:
|
||
return jsonify({'error': 'Keine gültigen Keys'}), 400
|
||
|
||
_write_env(updates)
|
||
return jsonify({'ok': True, 'saved': list(updates.keys())})
|
||
|
||
|
||
@app.route('/api/restart', methods=['POST'])
|
||
def api_restart():
|
||
"""Container neu starten (Docker restart: unless-stopped)."""
|
||
def _do_restart():
|
||
time.sleep(0.8)
|
||
os.kill(os.getpid(), signal.SIGTERM)
|
||
|
||
threading.Thread(target=_do_restart, daemon=True).start()
|
||
return jsonify({'ok': True, 'message': 'Neustart eingeleitet…'})
|
||
|
||
|
||
@app.route('/api/notify_test', methods=['POST'])
|
||
def api_notify_test():
|
||
"""Sendet Test-Benachrichtigung über alle aktivierten Kanäle."""
|
||
import notify
|
||
results = notify.test_notification()
|
||
return jsonify(results)
|
||
|
||
|
||
@app.route('/api/ping_targets_live')
|
||
def api_ping_targets_live():
|
||
""".env PING_TARGETS: Live-Log der letzten N Sekunden."""
|
||
from flask import request
|
||
seconds = int(request.args.get('seconds', 120))
|
||
since = int(time.time()) - seconds
|
||
rows = db.query_ping_log(since_ts=since, limit=2000)
|
||
# Neueste zuletzt für Live-Append
|
||
rows.reverse()
|
||
targets = [t.strip() for t in os.getenv('PING_TARGETS', '').split(',') if t.strip()]
|
||
stats = db.query_ping_stats(since_ts=int(time.time()) - 300) # letzte 5min
|
||
return jsonify({
|
||
'targets': targets,
|
||
'log': rows,
|
||
'stats': {s['target']: s for s in stats},
|
||
})
|
||
|
||
|
||
@app.route('/api/device_pings')
|
||
def api_device_pings():
|
||
"""Alle Netzwerk-Geräte (nicht in PING_TARGETS): letztes Ping-Ergebnis + Statistik."""
|
||
from flask import request
|
||
minutes = int(request.args.get('minutes', 30))
|
||
since = int(time.time()) - minutes * 60
|
||
latest = db.query_device_pings_latest()
|
||
stats = db.query_device_ping_stats(since_ts=since)
|
||
stats_map = {s['ip']: s for s in stats}
|
||
result = []
|
||
for row in latest:
|
||
s = stats_map.get(row['ip'], {})
|
||
result.append({
|
||
'ip': row['ip'],
|
||
'mac': row['mac'],
|
||
'success': bool(row['success']),
|
||
'latency_ms': row['latency_ms'],
|
||
'ts': row['ts'],
|
||
'ts_human': _fmt_dt(row['ts']),
|
||
'total': s.get('total', 0),
|
||
'ok': s.get('ok', 0),
|
||
'avg_ms': s.get('avg_ms'),
|
||
'min_ms': s.get('min_ms'),
|
||
'max_ms': s.get('max_ms'),
|
||
})
|
||
return jsonify(result)
|
||
|
||
|
||
@app.route('/api/switch')
|
||
def api_switch():
|
||
"""Switch Port-Status und Ereignisse."""
|
||
from flask import request
|
||
ports = db.query_switch_latest()
|
||
hours = int(request.args.get('hours', 24))
|
||
since = int(time.time()) - hours * 3600
|
||
events = db.query_switch_events(since_ts=since, limit=200)
|
||
|
||
return jsonify({
|
||
'enabled': bool(os.getenv('SWITCH_ENABLED', 'false').lower() == 'true'),
|
||
'host': os.getenv('SWITCH_HOST', ''),
|
||
'gateway_port': int(os.getenv('SWITCH_GATEWAY_PORT', '') or 1),
|
||
'ports': [dict(p) for p in ports],
|
||
'events': [
|
||
{**dict(e), 'ts_human': _fmt_dt(e['ts'])}
|
||
for e in events
|
||
],
|
||
})
|
||
|
||
|
||
@app.route('/api/fritz')
|
||
def api_fritz():
|
||
"""FritzBox-Verlauf, aktueller Status und Geräteinformationen."""
|
||
from flask import request
|
||
hours = int(request.args.get('hours', 24))
|
||
since = int(time.time()) - hours * 3600
|
||
history = db.query_fritz_history(since_ts=since, bucket_size=300)
|
||
latest = db.query_fritz_latest()
|
||
|
||
# Live-Infos direkt vom Gerät abrufen
|
||
full_info = None
|
||
if _monitor and hasattr(_monitor, 'fritz') and _monitor.fritz:
|
||
full_info = _monitor.fritz.get_full_info()
|
||
|
||
return jsonify({
|
||
'latest': dict(latest) if latest else None,
|
||
'history': history,
|
||
'info': full_info,
|
||
'host': os.getenv('FRITZ_HOST', ''),
|
||
})
|
||
|
||
|
||
# ── Hilfsfunktionen ──────────────────────────────────────────────────────────
|
||
|
||
def _fmt_ts(ts, range_key):
|
||
"""Formatiert Timestamp je nach Zeitbereich."""
|
||
dt = datetime.fromtimestamp(ts)
|
||
if range_key in ('1h', '6h'):
|
||
return dt.strftime('%H:%M')
|
||
elif range_key == '24h':
|
||
return dt.strftime('%H:%M')
|
||
else:
|
||
return dt.strftime('%d.%m %H:%M')
|
||
|
||
|
||
def _fmt_dt(ts):
|
||
if not ts:
|
||
return ''
|
||
return datetime.fromtimestamp(ts).strftime('%d.%m.%Y %H:%M:%S')
|
||
|
||
|
||
def _human_duration(seconds):
|
||
if not seconds:
|
||
return '< 1s'
|
||
parts = []
|
||
h = seconds // 3600
|
||
m = (seconds % 3600) // 60
|
||
s = seconds % 60
|
||
if h: parts.append(f"{h}h")
|
||
if m: parts.append(f"{m}min")
|
||
if s or not parts: parts.append(f"{s}s")
|
||
return ' '.join(parts)
|