Build packages / Version (push) Waiting to run
- Components tab replaces Updates: Dawnline, the AmneziaWG build for this firmware (Slava-Shchipunov 2.0 or 2Grey 3.1, Russian translation) and the system packages Dawnline adds, each checked, installed, reinstalled or rolled back in place, with What's new, versions and an activity log - Automatic updates: daily check, install at a set time or right away, per component; AmneziaWG is left out by default and an automatic run never switches its build or generation - Downloads verified against GitHub's sha256; mirrors are used only when GitHub is unreachable and the hash is known - New installer: checks firmware, clock, space and DNS, lets you pick a release, shows the plan and asks first; --dry-run - New uninstaller removes everything Dawnline added (cron, nft, firewall, routing, interfaces, packages it installed); --dry-run - Works without AmneziaWG on the router: Overview, the setup wizard, Health and Components say what is missing and offer to install it - Overview shows failed health checks as notices with their fix - People list no longer reads the config from the browser: private keys stay on the router; personal links are fetched on demand - Config changes are serialized under one lock, the nft table loads atomically and fails closed, and Dawnline never touches network sections it did not create - The portal never opens system ports, keeps disabled devices disabled, rate-limits per address and counts days by the router's clock - Settings and Diagnostics load their heavy parts in the background - Release notes are written from the commits since the previous release - Backend and admin UI split into small single-purpose modules
109 lines
3.2 KiB
Ucode
109 lines
3.2 KiB
Ucode
// Dawnline — read models shared by the admin RPC and the portal: people and
|
|
// devices merged with live peer state and usage.
|
|
|
|
import * as core from 'dawnline.core';
|
|
import * as live from 'dawnline.live';
|
|
import * as awg from 'dawnline.awg';
|
|
import { day_key_ago, month_key } from 'dawnline.util';
|
|
|
|
/** Daily totals (rx+tx) for the last `n` days, oldest first. */
|
|
export function spark(rec, n) {
|
|
let out = [];
|
|
for (let i = n - 1; i >= 0; i--) {
|
|
let v = rec?.days?.[day_key_ago(i)];
|
|
push(out, v ? v[0] + v[1] : 0);
|
|
}
|
|
return out;
|
|
};
|
|
|
|
/** The device holds an older configuration than the one it would get now. */
|
|
function config_stale(m, d) {
|
|
m._issued ??= awg.issued();
|
|
let was = m._issued[d.id];
|
|
return was != null && was != awg.config_fingerprint(m, d);
|
|
}
|
|
|
|
export function device_view(m, d, usage, dmp) {
|
|
let u = usage.devices?.[d.id];
|
|
let peer = dmp.peers[d.public_key];
|
|
let ts = time();
|
|
let hs = peer?.handshake || u?.handshake || 0;
|
|
let p = m.people[d.person];
|
|
let v = {
|
|
id: d.id,
|
|
name: d.name,
|
|
kind: d.kind,
|
|
address: d.address,
|
|
disabled: d.disabled,
|
|
created: d.created,
|
|
created_by: d.created_by,
|
|
online: !!(peer && peer.handshake > 0 && ts - peer.handshake < live.ONLINE_WINDOW),
|
|
handshake: hs,
|
|
endpoint: live.endpoint_ip(peer?.endpoint) || u?.endpoint || '',
|
|
active: !!peer,
|
|
month: live.month(u),
|
|
total: u?.total ?? [ 0, 0 ],
|
|
spark: spark(u, 7),
|
|
hostname: m.settings.hostnames && p ? `${replace(replace(lc(d.name), /[^a-z0-9]+/g, '-'), /^-+|-+$/g, '') || 'device'}.${p.id}.${m.settings.domain}` : '',
|
|
browser_key: d.private_key == '',
|
|
// Its configuration changed since it was last shown or downloaded.
|
|
config_stale: config_stale(m, d),
|
|
};
|
|
return v;
|
|
};
|
|
|
|
export function person_view(m, p, usage, dmp, states, opts) {
|
|
opts ??= {};
|
|
let u = usage.people?.[p.id];
|
|
let devs = [];
|
|
for (let id in p.devices)
|
|
push(devs, device_view(m, m.devices[id], usage, dmp));
|
|
devs = sort(devs, (a, b) => a.created - b.created);
|
|
let used = core.person_usage(p, usage);
|
|
let v = {
|
|
id: p.id,
|
|
name: p.name,
|
|
server: p.server,
|
|
access: p.access,
|
|
device_limit: p.device_limit,
|
|
expires: p.expires,
|
|
quota_gb: p.quota_gb,
|
|
quota_period: p.quota_period,
|
|
quota_used: used,
|
|
quota_limit: core.person_quota(p),
|
|
bonus_gb: (p.bonus_gb > 0 && p.bonus_month == month_key()) ? p.bonus_gb : 0,
|
|
expire_action: p.expire_action,
|
|
dns_mode: p.dns_mode,
|
|
expire_warn: p.expire_warn,
|
|
paused: p.paused,
|
|
hours: p.hours,
|
|
state: states[p.id] ?? core.person_state(m, p, usage),
|
|
month: live.month(u),
|
|
total: u?.total ?? [ 0, 0 ],
|
|
online: length(filter(devs, (d) => d.online)),
|
|
last_seen: 0,
|
|
devices: devs,
|
|
};
|
|
for (let d in devs)
|
|
if (d.handshake > v.last_seen)
|
|
v.last_seen = d.handshake;
|
|
if (opts.admin) {
|
|
// The code and links themselves are person_links' (admins only): the
|
|
// code opens the person's portal and their devices' configurations.
|
|
v.has_link = core.portal_url(m, p) != null;
|
|
v.note = p.note;
|
|
v.services = p.services;
|
|
v.home_nets = p.home_nets;
|
|
v.circle = p.circle;
|
|
v.created = p.created;
|
|
}
|
|
return v;
|
|
};
|
|
|
|
export function states(m, usage) {
|
|
let out = {};
|
|
for (let id, p in m.people)
|
|
out[id] = core.person_state(m, p, usage);
|
|
return out;
|
|
};
|