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.
313 lines
13 KiB
JavaScript
313 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, renderAccountingFreshness,
|
|
} = 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'],
|
|
delayed: [t('traffic.status.line.delayed'), 'warning'],
|
|
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, renderAccountingFreshness(pool), 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'));
|
|
}
|
|
}
|