116 lines
4.7 KiB
Python
116 lines
4.7 KiB
Python
import json
|
|
import re
|
|
import os
|
|
import config_utils
|
|
import factory
|
|
import mod_validation as validate
|
|
|
|
|
|
DDNS_LOG_MAX = 50
|
|
|
|
|
|
def _parse_interval_to_seconds(s):
|
|
m = re.match(r'^(\d+)([mhd])$', str(s).strip())
|
|
if not m:
|
|
return None
|
|
val, unit = int(m.group(1)), m.group(2)
|
|
return val * {'m': 60, 'h': 3600, 'd': 86400}[unit]
|
|
|
|
|
|
def _ddns_log_tail():
|
|
log_path = f'{config_utils.CONFIGS_DIR}/ddns.log'
|
|
try:
|
|
log_max_kb = factory.load_ddns().get('general', {}).get('log_max_kb', 1024)
|
|
size_kb = os.path.getsize(log_path) / 1024
|
|
with open(log_path) as f:
|
|
lines = f.readlines()
|
|
if not lines:
|
|
return '(no log entries yet)', ''
|
|
total = len(lines)
|
|
tail = lines[-DDNS_LOG_MAX:]
|
|
shown = len(tail)
|
|
hidden = total - shown
|
|
pct = min(100, round(size_kb / log_max_kb * 100)) if log_max_kb else 0
|
|
left = f'Showing {shown} of {total} lines ({hidden} not shown)' if hidden > 0 else f'Showing {shown} of {total} lines'
|
|
right = f'Log file size: {size_kb:.1f} KB ({pct}% of max)'
|
|
summary = (
|
|
'<div class="text-muted" style="display:flex;justify-content:space-between;margin-top:0.5em;">'
|
|
f'<span>{left}</span><span>{right}</span></div>'
|
|
)
|
|
return ''.join(tail).strip(), summary
|
|
except FileNotFoundError:
|
|
return '(no log entries yet)', ''
|
|
except Exception:
|
|
return '(error reading log)', ''
|
|
|
|
|
|
def _read_cached_ip():
|
|
try:
|
|
best_ip, best_mtime = '', 0.0
|
|
for fname in os.listdir(config_utils.CONFIGS_DIR):
|
|
if fname.startswith('.ddns-last-ip-'):
|
|
path = f'{config_utils.CONFIGS_DIR}/{fname}'
|
|
mtime = os.path.getmtime(path)
|
|
if mtime > best_mtime:
|
|
ip = open(path).read().strip()
|
|
if ip:
|
|
best_ip, best_mtime = ip, mtime
|
|
return best_ip, (best_mtime if best_ip else None)
|
|
except Exception:
|
|
return '', None
|
|
|
|
|
|
def public_ip_info(ddns_cfg):
|
|
from datetime import datetime, timezone
|
|
enabled_p = [p for p in ddns_cfg.get('providers', []) if p.get('enabled', True)]
|
|
all_hosts = []
|
|
for p in enabled_p:
|
|
all_hosts.extend(p.get('hostnames', p.get('subdomains', [])))
|
|
domains_sub = ', '.join(all_hosts)
|
|
ip, mtime = _read_cached_ip()
|
|
last_obtained = f'Obtained: {config_utils.relative_time(mtime, datetime.now(tz=timezone.utc).timestamp())} ago' if mtime else ''
|
|
if ip:
|
|
return ip, domains_sub, last_obtained
|
|
return 'Offline', domains_sub, ''
|
|
|
|
|
|
def ddns_last_checked():
|
|
from datetime import datetime, timezone
|
|
try:
|
|
mtime = os.path.getmtime(f'{config_utils.CONFIGS_DIR}/.ddns-last-service')
|
|
return f'Last checked: {config_utils.relative_time(mtime, datetime.now(tz=timezone.utc).timestamp())} ago'
|
|
except OSError:
|
|
return 'Last checked: ---'
|
|
|
|
|
|
def collect_tokens(cfg):
|
|
tokens = config_utils.collect_layout_tokens(cfg)
|
|
ddns = factory.load_ddns()
|
|
ddns_gen = ddns.get('general', {})
|
|
tokens['DDNS_TIMER_INTERVAL'] = ddns_gen.get('timer_interval', '-')
|
|
interval_secs = _parse_interval_to_seconds(ddns_gen.get('timer_interval', '')) or 600
|
|
tokens['DDNS_TIMER_INTERVAL_MINS'] = str(interval_secs // 60)
|
|
tokens['DDNS_GEN_LOG_MAX_KB'] = str(ddns_gen.get('log_max_kb', 1024))
|
|
tokens['DDNS_GEN_LOG_ERRORS_ONLY'] = 'true' if ddns_gen.get('log_errors_only') else 'false'
|
|
ip_check = ddns.get('ip_check_services', [])
|
|
http_svc = [s['url'] for s in ip_check if s.get('type') == 'http']
|
|
dig_svc = [s['url'] for s in ip_check if s.get('type') == 'dig']
|
|
tokens['STAT_IP_CHECK_TOTAL'] = str(len(ip_check))
|
|
tokens['STAT_IP_CHECK_SUB'] = f'{len(http_svc)} http and {len(dig_svc)} dig'
|
|
tokens['IP_CHECK_HTTP_JSON'] = json.dumps(http_svc)
|
|
tokens['IP_CHECK_DIG_JSON'] = json.dumps(dig_svc)
|
|
ddns_labels = {'noip': 'No-IP', 'cloudflare': 'Cloudflare', 'duckdns': 'DuckDNS'}
|
|
tokens['DDNS_PROVIDER_OPTIONS'] = json.dumps([
|
|
{'value': p, 'label': ddns_labels.get(p, p.title())}
|
|
for p in validate.VALID_DDNS_PROVIDERS
|
|
])
|
|
ip_str, domains_sub, last_obtained = public_ip_info(ddns)
|
|
tokens['STAT_PUBLIC_IP'] = ip_str
|
|
tokens['STAT_PUBLIC_IP_LAST_OBTAINED'] = last_obtained
|
|
tokens['STAT_PUBLIC_IP_LAST_CHECKED'] = ddns_last_checked()
|
|
tokens['DDNS_LOG_TAIL'], tokens['DDNS_LOG_SUMMARY'] = _ddns_log_tail()
|
|
content = factory.load_json(f'{factory.PAGES_DIR}/ddns/content.json')
|
|
for table_item in factory.iter_table_items(content.get('items', [])):
|
|
ds = table_item.get('datasource', '')
|
|
tokens[factory.table_token_key(ds)] = factory.build_table(table_item, tokens, config_utils.load_datasource(ds))
|
|
return tokens
|