You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/web/public/cloud/traffic.js

312 lines
13 KiB
JavaScript

const assetVersion = new URL(import.meta.url).searchParams.get('v');
function versionedModuleUrl(path) {
const url = new URL(path, import.meta.url);
url.search = '';
if (assetVersion) url.searchParams.set('v', assetVersion);
return url.href;
}
const {
api, byId, initializeSession, readBootstrap, showError,
} = await import(versionedModuleUrl('./runtime.js'));
const i18n = globalThis.VenixUserCopy;
const t = (key, parameters = {}) => i18n.text(key, parameters);
const state = {
linePools: [], linePoolCount: 0,
loading: false, controller: null,
};
function element(tag, className = '', content) {
const node = document.createElement(tag);
if (className) node.className = className;
if (content !== undefined) node.textContent = String(content);
return node;
}
function poolIcon() {
const wrapper = element('span', 'cloud-traffic-icon');
const icon = element('i', 'mdi mdi-chart-donut-variant');
icon.setAttribute('aria-hidden', 'true');
wrapper.append(icon);
return wrapper;
}
function formatBytes(value) {
let amount = Number(value);
if (!Number.isFinite(amount) || amount < 0) return t('traffic.value.unavailable');
const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB'];
let index = 0;
while (amount >= 1024 && index < units.length - 1) {
amount /= 1024;
index += 1;
}
const precision = index === 0 ? 0 : amount >= 100 ? 0 : amount >= 10 ? 1 : 2;
return `${amount.toFixed(precision)} ${units[index]}`;
}
function formatDate(value, fallback) {
const raw = Number(value);
if (!Number.isFinite(raw) || raw <= 0) return fallback;
return i18n.date(raw);
}
function poolState(value) {
return ({
available: [t('traffic.status.pool.available'), 'running'],
exhausted: [t('traffic.status.pool.exhausted'), 'stopped'],
attention: [t('traffic.status.pool.attention'), 'stopped'],
preparing: [t('traffic.status.pool.preparing'), 'warning'],
})[String(value || '')] || [t('traffic.status.unknown'), 'other'];
}
function restrictionState(value) {
return ({
clear: [t('traffic.status.restriction.clear'), 'running'],
applying: [t('traffic.status.restriction.applying'), 'warning'],
restricted: [t('traffic.status.restriction.restricted'), 'stopped'],
attention: [t('traffic.status.restriction.attention'), 'stopped'],
})[String(value || '')] || [t('traffic.status.restriction.unknown'), 'other'];
}
function linePoolState(value) {
return ({
available: [t('traffic.status.line.available'), 'running'],
preparing: [t('traffic.status.line.preparing'), 'warning'],
applying: [t('traffic.status.line.applying'), 'warning'],
exhausted: [t('traffic.status.line.exhausted'), 'stopped'],
restricted: [t('traffic.status.line.restricted'), 'stopped'],
attention: [t('traffic.status.line.attention'), 'stopped'],
})[String(value || '')] || [t('traffic.status.unknown'), 'other'];
}
function instanceNetwork(value) {
return ({
active: [t('traffic.status.instance.active'), 'running'],
blocking: [t('traffic.status.instance.blocking'), 'warning'],
blocked_traffic: [t('traffic.status.instance.blocked_traffic'), 'stopped'],
blocked_expired: [t('traffic.status.instance.blocked_expired'), 'stopped'],
restoring: [t('traffic.status.instance.restoring'), 'warning'],
restore_pending: [t('traffic.status.instance.restore_pending'), 'warning'],
})[String(value || '')] || [t('traffic.status.unknown'), 'other'];
}
function fact(labelKey, value, note = '') {
const row = document.createElement('div');
const dd = element('dd', '', value);
if (note) dd.append(element('small', '', note));
const label = element('dt', '', t(labelKey));
i18n.bind(label, labelKey);
row.append(label, dd);
return row;
}
function renderInstances(pool, section) {
const instances = Array.isArray(pool.instances) ? pool.instances : [];
const heading = element('div', 'cloud-traffic-instances-heading');
const title = element('h4', '', t('traffic.instances.title'));
i18n.bind(title, 'traffic.instances.title');
heading.append(title,
element('span', '', t('traffic.instances.count', { count: instances.length })));
const list = element('div', 'cloud-traffic-instance-list');
if (!instances.length) {
list.append(element('p', 'cloud-traffic-instance-empty',
t('traffic.empty.instances')));
}
for (const instance of instances) {
const link = element('a', 'cloud-traffic-instance');
link.href = `/user/cloud/instances/${encodeURIComponent(String(instance.id || ''))}`;
const header = element('span', 'cloud-traffic-instance-header');
const identity = element('span', 'cloud-traffic-instance-identity');
const regionName = String(instance?.region?.name || '').trim()
|| t('traffic.instance.region_unknown');
identity.append(element('strong', '', instance.name
|| t('traffic.instance.fallback', { id: instance.id || '' })),
element('small', '', t('traffic.instance.expiry', {
region: regionName,
date: formatDate(instance.service_expires_at, t('traffic.value.time_missing')),
})));
const [networkLabel, networkClass] = instanceNetwork(instance.network_status);
header.append(identity, element('span', `state-pill ${networkClass}`, networkLabel));
const facts = document.createElement('dl');
facts.append(fact('traffic.instance.period_quota', formatBytes(instance.period_traffic_quota_bytes)),
fact('traffic.instance.used', formatBytes(instance.traffic_used_bytes)),
fact('traffic.instance.download', formatBytes(instance.traffic_download_bytes)),
fact('traffic.instance.upload', formatBytes(instance.traffic_upload_bytes)));
link.append(header, facts);
list.append(link);
}
section.append(heading, list);
}
function coverageLabel(pool) {
const names = [];
for (const region of Array.isArray(pool?.coverage_regions) ? pool.coverage_regions : []) {
const name = String(region?.name || '').trim();
if (name && !names.includes(name)) names.push(name);
}
return names.length ? t('traffic.coverage.label', {
regions: names.join(t('traffic.value.list_separator')),
})
: t('traffic.coverage.unknown');
}
function renderLineContent(pool) {
const projectionReady = pool.projection_ready === true;
const card = element('article', 'cloud-traffic-card cloud-traffic-line-content');
const intro = element('div', 'cloud-traffic-line-intro');
intro.append(element('p', '', t('traffic.intro')));
const states = element('div', 'cloud-traffic-state-group');
const [stateLabel, stateClass] = poolState(pool.state);
const [networkLabel, networkClass] = restrictionState(pool.network_restriction_state);
states.append(element('span', `state-pill ${stateClass}`, stateLabel),
element('span', `state-pill ${networkClass}`, networkLabel));
intro.append(states);
const facts = element('dl', 'cloud-traffic-facts');
const pending = t('traffic.value.preparing');
facts.append(fact('traffic.fact.entitlement', projectionReady
? formatBytes(pool.active_entitlement_bytes) : pending),
fact('traffic.fact.consumed', projectionReady
? formatBytes(pool.active_consumed_bytes) : pending),
fact('traffic.fact.available', projectionReady
? formatBytes(pool.available_bytes) : pending),
fact('traffic.fact.overage', projectionReady
? formatBytes(pool.overage_bytes) : pending),
fact('traffic.fact.next_expiry', projectionReady
? formatDate(pool.next_expiry_at, t('traffic.value.no_expiry')) : t('traffic.status.pool.preparing'),
projectionReady ? t('traffic.fact.expiry_note', { amount: formatBytes(pool.next_expiry_bytes) })
: t('traffic.value.ledger_pending')),
fact('traffic.fact.last_observed', projectionReady
? formatDate(pool.last_observed_at, t('traffic.value.no_sample'))
: t('traffic.value.waiting_sample')));
const instances = element('section', 'cloud-traffic-instances');
instances.setAttribute('aria-label', t('traffic.instances.aria', {
name: pool.name || t('traffic.pool.fallback'),
}));
renderInstances(pool, instances);
card.append(intro, facts, instances);
return card;
}
function existingLinePoolState(list) {
const result = new Map();
for (const details of list.querySelectorAll(
'details.cloud-traffic-line[data-line-key]',
)) {
result.set(details.getAttribute('data-line-key'), {
open: details.open === true,
requiresAttention: details.getAttribute('data-requires-attention') === '1',
});
}
return result;
}
function renderLinePool(pool, previousState) {
const key = String(pool.key || `line-group:${Number(pool.group_id) || 0}`);
const details = element('details', 'cloud-traffic-line');
details.setAttribute('data-line-key', key);
const requiresAttention = pool.requires_attention === true;
details.setAttribute('data-requires-attention', requiresAttention ? '1' : '0');
const previous = previousState.get(key);
details.open = previous
? (requiresAttention && !previous.requiresAttention ? true : previous.open)
: pool.default_open === true;
const summary = element('summary', 'cloud-traffic-line-summary');
const identity = element('span', 'cloud-traffic-line-identity');
const icon = element('span', 'cloud-traffic-line-icon');
const marker = element('i', 'mdi mdi-lan-connect');
marker.setAttribute('aria-hidden', 'true');
icon.append(marker);
const title = element('span', 'cloud-traffic-line-title');
title.append(element('strong', '', pool.name || t('traffic.line.fallback')),
element('small', '', coverageLabel(pool)));
identity.append(icon, title);
const meta = element('span', 'cloud-traffic-line-meta');
const counts = element('span', 'cloud-traffic-line-counts');
counts.append(element('span', '', t('traffic.coverage.regions', {
count: Number(pool.coverage_region_count) || 0,
})), element('span', '', t('traffic.coverage.instances', {
count: Number(pool.instance_count) || 0,
})));
const [statusLabel, statusClass] = linePoolState(pool.summary_state);
const arrow = element('span', 'cloud-traffic-line-arrow', '⌄');
arrow.setAttribute('aria-hidden', 'true');
meta.append(counts, element('span', `state-pill ${statusClass}`, statusLabel), arrow);
summary.append(identity, meta);
const body = element('div', 'cloud-traffic-line-body');
body.append(renderLineContent(pool));
details.append(summary, body);
return details;
}
function render() {
const list = byId('cloud-traffic-list');
const previousState = existingLinePoolState(list);
list.replaceChildren();
if (!state.linePools.length) {
const empty = element('div', 'cloud-traffic-empty');
empty.append(poolIcon(), element('strong', '', t('traffic.empty.title')),
element('span', '', t('traffic.empty.body')));
list.append(empty);
}
for (const pool of state.linePools) {
list.append(renderLinePool(pool, previousState));
}
byId('cloud-traffic-count').textContent =
t('traffic.count', { count: state.linePoolCount });
byId('cloud-traffic-refresh').disabled = state.loading;
}
function applyPayload(payload) {
const values = Array.isArray(payload?.line_pools) ? payload.line_pools : [];
state.linePools = values.filter(pool => pool && typeof pool === 'object'
&& typeof pool.key === 'string' && pool.key !== ''
&& Array.isArray(pool.instances));
state.linePoolCount = Math.max(0, Number(payload?.line_pool_count) || 0);
render();
}
async function load() {
if (state.loading) return;
state.loading = true;
state.controller?.abort();
const controller = new AbortController();
state.controller = controller;
const status = byId('cloud-traffic-status');
status.hidden = false;
status.className = 'vm-settings-status';
status.textContent = t('traffic.status.loading');
render();
try {
const payload = await api('/api/v1/traffic-pools', { signal: controller.signal });
if (controller.signal.aborted) return;
applyPayload(payload);
status.hidden = true;
} catch (error) {
if (controller.signal.aborted) return;
status.className = 'vm-settings-status error';
status.textContent = t('traffic.error.load');
} finally {
if (state.controller === controller) state.controller = null;
state.loading = false;
render();
}
}
export async function initialize() {
try {
const bootstrap = readBootstrap('cloud-traffic-bootstrap');
const hasBootstrap = Array.isArray(bootstrap?.line_pools);
// Browser-localise the SSR fallback before the asynchronous session
// handshake. The bootstrap is already owner-scoped by the page request.
if (hasBootstrap) applyPayload(bootstrap);
if (!await initializeSession('traffic', bootstrap?.user)) return;
if (!hasBootstrap) applyPayload(bootstrap);
byId('cloud-traffic-refresh')?.addEventListener('click', () => void load());
window.addEventListener('pagehide', () => state.controller?.abort());
} catch (error) {
showError('cloud-page-error', t('traffic.error.page'));
}
}