279 lines
8.8 KiB
Python
279 lines
8.8 KiB
Python
import json, subprocess, hashlib, os, uuid
|
|
from datetime import datetime, timezone
|
|
from flask import session
|
|
|
|
CONFIGS_DIR = '/routlin_location'
|
|
CORE_FILE = f'{CONFIGS_DIR}/core.json'
|
|
DASHBOARD_QUEUE = f'{CONFIGS_DIR}/.dashboard-queue'
|
|
DASHBOARD_DONE = f'{CONFIGS_DIR}/.dashboard-done'
|
|
DASHBOARD_LAST_RUN = f'{CONFIGS_DIR}/.dashboard-last-run'
|
|
DASHBOARD_LOCK = f'{CONFIGS_DIR}/.dashboard-lock'
|
|
DASHBOARD_PENDING = f'{CONFIGS_DIR}/.dashboard-pending'
|
|
STATUS_FILE = f'{CONFIGS_DIR}/.status'
|
|
DASHB_TIMER_NAME = 'routlin-dashboard-queue'
|
|
PRODUCT_DISPLAY_NAME = os.environ.get('PRODUCT_DISPLAY_NAME', 'Routlin Dashboard')
|
|
DASHB_INTERVAL_SECS = 60
|
|
QUEUE_MAX_LINES = 50
|
|
|
|
|
|
def load_core():
|
|
try:
|
|
with open(CORE_FILE) as f:
|
|
return json.load(f)
|
|
except Exception:
|
|
return {}
|
|
|
|
|
|
def save_core(data):
|
|
with open(CORE_FILE, 'w') as f:
|
|
json.dump(data, f, indent=2)
|
|
|
|
|
|
def core_hash():
|
|
try:
|
|
with open(CORE_FILE, 'rb') as f:
|
|
return hashlib.md5(f.read()).hexdigest()
|
|
except Exception:
|
|
return ''
|
|
|
|
|
|
def verify_core_hash(submitted):
|
|
if not submitted:
|
|
return True
|
|
return submitted == core_hash()
|
|
|
|
|
|
def _load_done_set():
|
|
try:
|
|
done = set()
|
|
for line in open(DASHBOARD_DONE).read().splitlines():
|
|
parts = line.split()
|
|
if parts:
|
|
done.add(parts[0])
|
|
return done
|
|
except Exception:
|
|
return set()
|
|
|
|
|
|
def _read_pending(done_set):
|
|
pending = []
|
|
try:
|
|
lines = open(DASHBOARD_QUEUE).read().splitlines()
|
|
except Exception:
|
|
return pending
|
|
for line in lines:
|
|
try:
|
|
parts = line.split(None, 3)
|
|
if len(parts) == 4:
|
|
entry_uuid, entry_ts, _dt, rest = parts
|
|
cmd_user = rest.rsplit(' (', 1)
|
|
entry_cmd = cmd_user[0].strip('[]')
|
|
entry_user = cmd_user[1].rstrip(')') if len(cmd_user) == 2 else ''
|
|
if entry_uuid not in done_set:
|
|
pending.append((entry_uuid, int(entry_ts), entry_cmd, entry_user))
|
|
except Exception:
|
|
pass
|
|
return pending
|
|
|
|
|
|
def get_pending_entries():
|
|
return _read_pending(_load_done_set())
|
|
|
|
|
|
def _format_timing(secs):
|
|
if secs is None:
|
|
return None
|
|
if secs <= 5:
|
|
return 'momentarily'
|
|
if secs < 60:
|
|
return f'in about {secs} seconds'
|
|
mins = round(secs / 60)
|
|
return f'in about {mins} minute{"s" if mins != 1 else ""}'
|
|
|
|
|
|
def _trim_if_needed():
|
|
try:
|
|
lines = [l for l in open(DASHBOARD_QUEUE).read().splitlines() if l]
|
|
if len(lines) <= QUEUE_MAX_LINES:
|
|
return
|
|
done_set = _load_done_set()
|
|
pending = [l for l in lines if l.split()[0] not in done_set]
|
|
with open(DASHBOARD_QUEUE, 'w') as f:
|
|
f.write('\n'.join(pending) + ('\n' if pending else ''))
|
|
open(DASHBOARD_DONE, 'w').close()
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _apply_on_save():
|
|
try:
|
|
return load_core().get('general', {}).get('apply_on_save', True)
|
|
except Exception:
|
|
return True
|
|
|
|
|
|
def _read_dashboard_pending():
|
|
"""Return list of (uuid, ts, cmd, user, description) from .dashboard-pending."""
|
|
items = []
|
|
try:
|
|
lines = open(DASHBOARD_PENDING).read().splitlines()
|
|
except Exception:
|
|
return items
|
|
for line in lines:
|
|
if not line.strip():
|
|
continue
|
|
try:
|
|
main, _, desc = line.partition(' :: ')
|
|
parts = main.split(None, 3)
|
|
if len(parts) == 4:
|
|
entry_uuid, entry_ts, _dt, rest = parts
|
|
cmd_user = rest.rsplit(' (', 1)
|
|
entry_cmd = cmd_user[0].strip('[]')
|
|
entry_user = cmd_user[1].rstrip(')') if len(cmd_user) == 2 else ''
|
|
items.append((entry_uuid, int(entry_ts), entry_cmd, entry_user, desc))
|
|
except Exception:
|
|
pass
|
|
return items
|
|
|
|
|
|
def get_dashboard_pending():
|
|
return _read_dashboard_pending()
|
|
|
|
|
|
def flush_pending_to_queue():
|
|
"""Move all entries from .dashboard-pending to .dashboard-queue and clear pending."""
|
|
items = _read_dashboard_pending()
|
|
if not items:
|
|
return
|
|
done_set = _load_done_set()
|
|
existing_ids = {uu for uu, *_ in _read_pending(done_set)}
|
|
with open(DASHBOARD_QUEUE, 'a') as f:
|
|
for entry_uuid, entry_ts, entry_cmd, entry_user, _desc in items:
|
|
if entry_uuid not in existing_ids:
|
|
dt_str = datetime.fromtimestamp(entry_ts).strftime('%Y-%m-%dT%H:%M:%S')
|
|
f.write(f'{entry_uuid} {entry_ts} {dt_str} [{entry_cmd}] ({entry_user})\n')
|
|
open(DASHBOARD_PENDING, 'w').close()
|
|
_trim_if_needed()
|
|
|
|
|
|
def _queue_pending_command(cmd, description=''):
|
|
"""Append cmd to .dashboard-pending if not already present for this cmd+user."""
|
|
existing = _read_dashboard_pending()
|
|
current_user = session.get('email_address', 'unknown')
|
|
for entry_uuid, entry_ts, entry_cmd, entry_user, _desc in existing:
|
|
if entry_cmd == cmd and entry_user == current_user:
|
|
return entry_uuid, entry_ts
|
|
entry_uuid = str(uuid.uuid4())
|
|
now = datetime.now()
|
|
entry_ts = int(now.timestamp())
|
|
dt_str = now.strftime('%Y-%m-%dT%H:%M:%S')
|
|
desc_suffix = f' :: {description}' if description else ''
|
|
with open(DASHBOARD_PENDING, 'a') as f:
|
|
f.write(f'{entry_uuid} {entry_ts} {dt_str} [{cmd}] ({current_user}){desc_suffix}\n')
|
|
return entry_uuid, entry_ts
|
|
|
|
|
|
def _queue_command(cmd, description=''):
|
|
if not _apply_on_save():
|
|
return _queue_pending_command(cmd, description)
|
|
done_set = _load_done_set()
|
|
pending = _read_pending(done_set)
|
|
current_user = session.get('email_address', 'unknown')
|
|
for entry_uuid, entry_ts, entry_cmd, entry_user in pending:
|
|
if entry_cmd == cmd and entry_user == current_user:
|
|
return entry_uuid, entry_ts
|
|
entry_uuid = str(uuid.uuid4())
|
|
now = datetime.now()
|
|
entry_ts = int(now.timestamp())
|
|
dt_str = now.strftime('%Y-%m-%dT%H:%M:%S')
|
|
user = session.get('email_address', 'unknown')
|
|
with open(DASHBOARD_QUEUE, 'a') as f:
|
|
f.write(f'{entry_uuid} {entry_ts} {dt_str} [{cmd}] ({user})\n')
|
|
_trim_if_needed()
|
|
return entry_uuid, entry_ts
|
|
|
|
|
|
def _entry_ts_from_queue(entry_uuid):
|
|
try:
|
|
for line in open(DASHBOARD_QUEUE).read().splitlines():
|
|
parts = line.split(None, 2)
|
|
if len(parts) >= 2 and parts[0] == entry_uuid:
|
|
return int(parts[1])
|
|
except Exception:
|
|
pass
|
|
return None
|
|
|
|
|
|
def _seconds_until_next_run():
|
|
try:
|
|
last_run = float(open(DASHBOARD_LAST_RUN).read().strip())
|
|
elapsed = datetime.now(timezone.utc).timestamp() - last_run
|
|
return int(max(0, DASHB_INTERVAL_SECS - elapsed))
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def _is_locked():
|
|
try:
|
|
return os.path.getsize(DASHBOARD_LOCK) > 0
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def _lock_mtime():
|
|
try:
|
|
return os.path.getmtime(DASHBOARD_LOCK)
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def queue_command(cmd, description=''):
|
|
"""Queue a command without generating a flash message."""
|
|
return _queue_command(cmd, description)
|
|
|
|
|
|
def queued_msg(cmd=None, description=''):
|
|
"""Queue cmd if given, then return a timing message.
|
|
Without cmd, just returns timing (for commands already queued by the caller)."""
|
|
entry_ts = None
|
|
if cmd is not None:
|
|
_entry_uuid, entry_ts = queue_command(cmd, description)
|
|
if not _apply_on_save():
|
|
return 'Configuration saved. Click Apply Now on the Configuration Changes card to apply.'
|
|
if _is_locked():
|
|
mtime = _lock_mtime()
|
|
if entry_ts is not None and mtime and entry_ts < mtime:
|
|
return 'Configuration saved. Changes are being applied now.'
|
|
return 'Configuration saved. Changes will be applied on the next run.'
|
|
timing = _format_timing(_seconds_until_next_run())
|
|
if timing:
|
|
return f'Configuration saved. Changes will be applied {timing}.'
|
|
if cmd is None:
|
|
return 'Changes queued. The processing service is not running.'
|
|
parts = cmd.split()
|
|
cli_cmd = f'sudo python3 {parts[0]}.py --{parts[1]}' if len(parts) == 2 else cmd
|
|
install_cmd = f'sudo python3 install.py'
|
|
from markupsafe import Markup
|
|
return Markup(f'Configuration saved. The command processing service is not installed. '
|
|
f'Run <strong>{install_cmd}</strong> to enable it, '
|
|
f'or <strong>{cli_cmd}</strong> to apply manually.')
|
|
|
|
|
|
def run_apply():
|
|
try:
|
|
subprocess.run(
|
|
['python3', f'{CONFIGS_DIR}/core.py', '--apply'],
|
|
capture_output=True, timeout=30
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def run_update_blocklists():
|
|
try:
|
|
subprocess.run(
|
|
['python3', f'{CONFIGS_DIR}/core.py', '--update-blocklists'],
|
|
capture_output=True, timeout=120
|
|
)
|
|
except Exception:
|
|
pass
|