1282 lines
49 KiB
JavaScript
1282 lines
49 KiB
JavaScript
// Renderer-side app logic. Uses window.api exposed by preload.js.
|
|
// No framework — vanilla DOM.
|
|
|
|
// -------- State --------
|
|
const state = {
|
|
fleet: [], // array of ONU-CFG documents (shallow — see main.js projection)
|
|
filtered: [],
|
|
selected: new Set(),
|
|
firmwareList: [], // GET /files/onu-firmware/ result
|
|
plan: [], // result of api.planUpgrade
|
|
fecHealth: new Map(), // onuId -> { flag, detail, sampleTime, error? }
|
|
campaignMode: 'task', // 'task' | 'peronu'
|
|
verify: null, // { sourcePath, beforeRows, snapshotById, comparisons }
|
|
};
|
|
|
|
// -------- Helpers --------
|
|
const $ = (sel) => document.querySelector(sel);
|
|
const $$ = (sel) => document.querySelectorAll(sel);
|
|
|
|
function showView(id) {
|
|
for (const v of $$('.view')) v.classList.add('hidden');
|
|
$(id).classList.remove('hidden');
|
|
}
|
|
|
|
function activeBank(cfg) {
|
|
const ptr = cfg?.ONU?.['FW Bank Ptr'];
|
|
return typeof ptr === 'number' ? ptr : null;
|
|
}
|
|
function versionAt(cfg, slot) {
|
|
return cfg?.ONU?.['FW Bank Versions']?.[slot] || '';
|
|
}
|
|
function fileAt(cfg, slot) {
|
|
return cfg?.ONU?.['FW Bank Files']?.[slot] || '';
|
|
}
|
|
function activeVersion(cfg) {
|
|
const ptr = activeBank(cfg);
|
|
if (ptr === null || ptr === 65535) return '(unset)';
|
|
return versionAt(cfg, ptr) || '(empty)';
|
|
}
|
|
function inactiveVersion(cfg) {
|
|
const ptr = activeBank(cfg);
|
|
if (ptr === null || ptr === 65535) return '(unset)';
|
|
const other = ptr === 0 ? 1 : 0;
|
|
return versionAt(cfg, other) || '(empty)';
|
|
}
|
|
|
|
// Equipment ID is device-reported and lives on ONU-STATE (joined into
|
|
// `_state` by main.js). Some deployments also surface it under ONU-CFG
|
|
// directly; check both paths so the filter works regardless.
|
|
function equipmentId(cfg) {
|
|
return (
|
|
cfg?._state?.ONU?.['Equipment ID'] ||
|
|
cfg?._state?.['Equipment ID'] ||
|
|
cfg?.ONU?.['Equipment ID'] ||
|
|
''
|
|
);
|
|
}
|
|
function vendor(cfg) {
|
|
return (
|
|
cfg?._state?.ONU?.Vendor ||
|
|
cfg?._state?.Vendor ||
|
|
cfg?.ONU?.Vendor ||
|
|
''
|
|
);
|
|
}
|
|
|
|
// Registration bucket from OLT-STATE["ONU States"] (see 323-1961-306
|
|
// Procedure 2). null means the ONU didn't appear in any OLT bucket —
|
|
// usually a preprovisioned ONU that has never registered.
|
|
function onuStatus(cfg) {
|
|
return cfg?._status?.status || null;
|
|
}
|
|
|
|
// Statuses we consider "down" for the bulk-down filter + delete workflow.
|
|
// "Disallowed *" are admin/config states rather than fault states, but
|
|
// from a "this ONU isn't carrying traffic" perspective they behave the
|
|
// same — group them in when the user picks the "Down" aggregate.
|
|
const DOWN_STATUSES = new Set([
|
|
'Deregistered',
|
|
'Dying Gasp',
|
|
'Disabled',
|
|
'Disallowed Admin',
|
|
'Disallowed Error',
|
|
'Disallowed Reg ID',
|
|
]);
|
|
|
|
// Timestamp of the most recent MCMS update to this ONU's STATE doc. For
|
|
// a down ONU this is a proxy for "last heard from" — the OLT refreshes
|
|
// ONU-STATE on registration events, alarms, and periodic stats, so an
|
|
// ONU that's been dark for a month will have a correspondingly old Time.
|
|
function lastSeenDate(cfg) {
|
|
const t = cfg?._state?.Time;
|
|
if (!t) return null;
|
|
// MCMS emits timestamps as "YYYY-MM-DD HH:MM:SS[.ffffff]" in UTC.
|
|
// Replace the space with 'T' and append 'Z' so Date parses as UTC.
|
|
const iso = String(t).replace(' ', 'T') + (String(t).endsWith('Z') ? '' : 'Z');
|
|
const d = new Date(iso);
|
|
return isNaN(d.getTime()) ? null : d;
|
|
}
|
|
function daysSince(date) {
|
|
if (!date) return null;
|
|
return (Date.now() - date.getTime()) / 86400000;
|
|
}
|
|
function formatRelative(days) {
|
|
if (days === null || days === undefined) return '';
|
|
if (days < 1) return `${Math.round(days * 24)}h ago`;
|
|
if (days < 60) return `${Math.round(days)}d ago`;
|
|
return `${Math.round(days / 30)}mo ago`;
|
|
}
|
|
|
|
// FEC health pill. The mapping mirrors the user-guide green-LED
|
|
// criteria (323-1961-302 p149): post-FEC nonzero is the bright red
|
|
// signal, pre-FEC alone (post=0) is "FEC is doing its job, marginal"
|
|
// and shows yellow. Blue ("buggy") is added on top of the user-guide
|
|
// rules: when pre-FEC == post-FEC and both > 0, the ONU firmware is
|
|
// almost certainly mirroring one counter into the other rather than
|
|
// the link being identically broken — surface it distinctly so the
|
|
// operator doesn't waste time troubleshooting a phantom.
|
|
const FEC_LABELS = {
|
|
ok: { text: 'OK', cls: 'status-ok' },
|
|
pre: { text: 'Pre-FEC errors', cls: 'status-warn' },
|
|
post: { text: 'Post-FEC errors', cls: 'status-err' },
|
|
buggy: { text: 'Pre==Post (ONU bug?)', cls: 'status-info' },
|
|
nodata: { text: 'no recent stats', cls: 'muted' },
|
|
error: { text: 'fetch failed', cls: 'muted' },
|
|
pending: { text: 'checking…', cls: 'muted' },
|
|
};
|
|
|
|
// Mirror of formatFecNumber in src/mcms-api.js. Kept in the renderer so
|
|
// we don't have to round-trip through IPC to format a number — and so
|
|
// we can re-format if the structure ever changes.
|
|
function formatFecNumber(n) {
|
|
if (n === 0) return '0';
|
|
const abs = Math.abs(n);
|
|
if (Number.isInteger(n)) return String(n);
|
|
if (abs < 0.01 || abs >= 1e6) return n.toExponential(2);
|
|
return Number(n.toPrecision(3)).toString();
|
|
}
|
|
|
|
function fecCountersHtml(health) {
|
|
const list = Array.isArray(health?.counters) ? health.counters : [];
|
|
const optical = health?.optical || {};
|
|
if (!list.length && optical.rx == null && optical.tx == null) return '';
|
|
|
|
const lines = [];
|
|
|
|
// FEC counters: ONU side first (most relevant — the ONU is the device
|
|
// we're about to upgrade), then OLT side. Skip counters whose scope
|
|
// we don't recognise.
|
|
const order = (c) => (c.scope === 'onu' ? 0 : c.scope === 'olt' ? 1 : 2);
|
|
const sorted = [...list].sort((a, b) => {
|
|
const so = order(a) - order(b);
|
|
if (so) return so;
|
|
return a.kind === b.kind ? 0 : a.kind === 'pre' ? -1 : 1;
|
|
});
|
|
for (const c of sorted) {
|
|
const cls = c.value > 0 ? c.kind : 'ok';
|
|
lines.push(
|
|
`<span class="${cls}">${escapeHtml(c.tail)}=${escapeHtml(formatFecNumber(c.value))}</span>`,
|
|
);
|
|
}
|
|
|
|
// Optical levels (dBm). User-guide green-LED threshold is RX >= -30
|
|
// dBm and TX >= 3 dBm (323-1961-302 p149). We highlight RX in red
|
|
// below -30 and yellow as it approaches the floor (-28 dBm), so the
|
|
// operator sees the marginal links during the FEC sweep.
|
|
if (optical.rx != null || optical.tx != null) {
|
|
const opticalParts = [];
|
|
if (optical.rx != null) {
|
|
const rxCls = optical.rx < -30 ? 'post' : optical.rx < -28 ? 'pre' : 'ok';
|
|
opticalParts.push(
|
|
`<span class="${rxCls}">RX ${escapeHtml(optical.rx.toFixed(1))} dBm</span>`,
|
|
);
|
|
}
|
|
if (optical.tx != null) {
|
|
const txCls = optical.tx < 3 ? 'post' : 'ok';
|
|
opticalParts.push(
|
|
`<span class="${txCls}">TX ${escapeHtml(optical.tx.toFixed(1))} dBm</span>`,
|
|
);
|
|
}
|
|
lines.push(opticalParts.join(' '));
|
|
}
|
|
|
|
return `<span class="fec-counters">${lines.join('<br/>')}</span>`;
|
|
}
|
|
|
|
function fecPillHtml(health) {
|
|
const f = (health && health.flag) || 'pending';
|
|
const label = FEC_LABELS[f] || FEC_LABELS.pending;
|
|
const title = health?.detail || health?.error?.message || '';
|
|
const titleAttr = title ? ` title="${escapeHtml(title)}"` : '';
|
|
return (
|
|
`<span class="fec-pill ${label.cls}"${titleAttr}>${escapeHtml(label.text)}</span>` +
|
|
fecCountersHtml(health)
|
|
);
|
|
}
|
|
|
|
// -------- Login --------
|
|
$('#btn-login').addEventListener('click', async () => {
|
|
$('#login-error').textContent = '';
|
|
const baseUrl = $('#in-host').value.trim();
|
|
const username = $('#in-user').value.trim();
|
|
const password = $('#in-pass').value;
|
|
const acceptSelfSigned = $('#in-self-signed').checked;
|
|
if (!baseUrl || !username || !password) {
|
|
$('#login-error').textContent = 'Host, username and password are required.';
|
|
return;
|
|
}
|
|
$('#btn-login').disabled = true;
|
|
$('#btn-login').textContent = 'Connecting…';
|
|
const res = await window.api.login({ baseUrl, username, password, acceptSelfSigned });
|
|
$('#btn-login').disabled = false;
|
|
$('#btn-login').textContent = 'Connect';
|
|
if (!res.ok) {
|
|
$('#login-error').textContent = res.error?.message || 'Login failed';
|
|
return;
|
|
}
|
|
$('#session-label').textContent = `${username} @ ${baseUrl}`;
|
|
$('#btn-logout').classList.remove('hidden');
|
|
showView('#view-fleet');
|
|
});
|
|
|
|
$('#btn-logout').addEventListener('click', async () => {
|
|
await window.api.logout();
|
|
$('#session-label').textContent = 'Not connected';
|
|
$('#btn-logout').classList.add('hidden');
|
|
state.fleet = []; state.filtered = []; state.selected.clear();
|
|
showView('#view-login');
|
|
});
|
|
|
|
// -------- Fleet loading + filtering --------
|
|
$('#btn-refresh').addEventListener('click', loadFleet);
|
|
|
|
async function loadFleet() {
|
|
$('#fleet-status').textContent = 'Loading fleet…';
|
|
const res = await window.api.listFleet({});
|
|
if (!res.ok) {
|
|
$('#fleet-status').textContent = `Error: ${res.error?.message || 'unknown'}`;
|
|
return;
|
|
}
|
|
state.fleet = res.data || [];
|
|
applyFilters();
|
|
const meta = res.meta || {};
|
|
const withEq = state.fleet.filter((c) => equipmentId(c)).length;
|
|
|
|
if (meta.statesError) {
|
|
// Bulk state fetch failed — fall back to per-ONU streaming fetch.
|
|
$('#fleet-status').textContent =
|
|
`Loaded ${state.fleet.length} ONUs. Fetching hardware info per-ONU…`;
|
|
const byId = new Map(state.fleet.map((c) => [c._id, c]));
|
|
const unbind = window.api.onStatesProgress(({ onuId, state: s, done, total }) => {
|
|
const cfg = byId.get(onuId);
|
|
if (cfg && s) cfg._state = s;
|
|
// Throttle full re-renders: update every 50 results (or on last).
|
|
if (done === total || done % 50 === 0) {
|
|
applyFilters();
|
|
const eq = state.fleet.filter((c) => equipmentId(c)).length;
|
|
$('#fleet-status').textContent =
|
|
`Loaded ${state.fleet.length} ONUs. Hardware info: ${done}/${total} (${eq} with Equipment ID).`;
|
|
}
|
|
});
|
|
const fetchRes = await window.api.fetchStates({
|
|
onuIds: state.fleet.map((c) => c._id),
|
|
});
|
|
unbind();
|
|
applyFilters();
|
|
const eq = state.fleet.filter((c) => equipmentId(c)).length;
|
|
if (!fetchRes.ok) {
|
|
$('#fleet-status').textContent =
|
|
`Loaded ${state.fleet.length} ONUs. Hardware info fetch failed: ${fetchRes.error?.message}`;
|
|
} else {
|
|
$('#fleet-status').textContent =
|
|
`Loaded ${state.fleet.length} ONUs (${eq} with Equipment ID).`;
|
|
}
|
|
return;
|
|
}
|
|
|
|
const stateNote = meta.stateCount === 0
|
|
? ' — no ONU states returned (Equipment ID will be blank)'
|
|
: withEq
|
|
? ` (${withEq} with Equipment ID)`
|
|
: '';
|
|
const oltNote = meta.oltStatesError
|
|
? ` — OLT-STATE fetch failed (${meta.oltStatesError.message}); status filter unavailable`
|
|
: meta.oltStateCount
|
|
? `, ${meta.oltStateCount} OLT(s) for status`
|
|
: '';
|
|
$('#fleet-status').textContent =
|
|
`Loaded ${state.fleet.length} ONUs${stateNote}${oltNote}.`;
|
|
}
|
|
|
|
function applyFilters() {
|
|
const text = $('#filter-text').value.trim().toLowerCase();
|
|
const equipment = $('#filter-equipment').value.trim().toLowerCase();
|
|
const ponMode = $('#filter-pon').value.trim();
|
|
const version = $('#filter-version').value.trim().toLowerCase();
|
|
const excludeVersion = $('#filter-exclude-version').value.trim().toLowerCase();
|
|
const model = $('#filter-model').value.trim().toLowerCase();
|
|
const statusFilter = $('#filter-status').value;
|
|
const downDaysRaw = $('#filter-down-days').value.trim();
|
|
const downDays = downDaysRaw ? Number(downDaysRaw) : null;
|
|
|
|
state.filtered = state.fleet.filter((cfg) => {
|
|
if (text) {
|
|
const hay = `${cfg?.ONU?.Name || ''} ${cfg?.ONU?.Address || ''} ${cfg?._id || ''}`.toLowerCase();
|
|
if (!hay.includes(text)) return false;
|
|
}
|
|
if (equipment) {
|
|
const eid = equipmentId(cfg).toLowerCase();
|
|
if (!eid.includes(equipment)) return false;
|
|
}
|
|
if (ponMode) {
|
|
// PON Mode is a CFG field — client-side exact match now.
|
|
if ((cfg?.ONU?.['PON Mode'] || '') !== ponMode) return false;
|
|
}
|
|
if (version) {
|
|
const v = activeVersion(cfg).toLowerCase();
|
|
if (!v.includes(version)) return false;
|
|
}
|
|
if (excludeVersion) {
|
|
// Drop devices whose active version matches — useful for "already
|
|
// upgraded" devices during a rolling fleet rollout.
|
|
const v = activeVersion(cfg).toLowerCase();
|
|
if (v.includes(excludeVersion)) return false;
|
|
}
|
|
if (model) {
|
|
// "model" here is matched against either slot's version string, so a
|
|
// prefix like "EV051" catches the whole Everest 5.1x family whether
|
|
// the device is currently on 5.11 or 5.12.
|
|
const v0 = versionAt(cfg, 0).toLowerCase();
|
|
const v1 = versionAt(cfg, 1).toLowerCase();
|
|
if (!v0.includes(model) && !v1.includes(model)) return false;
|
|
}
|
|
if (statusFilter) {
|
|
const s = onuStatus(cfg);
|
|
if (statusFilter === '__down__') {
|
|
if (!DOWN_STATUSES.has(s)) return false;
|
|
} else if (statusFilter === '__unknown__') {
|
|
if (s !== null) return false;
|
|
} else {
|
|
if (s !== statusFilter) return false;
|
|
}
|
|
}
|
|
if (downDays !== null && !Number.isNaN(downDays)) {
|
|
// "Down for at least N days" — only meaningful for ONUs that are
|
|
// actually down AND have a last-seen timestamp. Registered ONUs and
|
|
// those without an ONU-STATE doc are excluded when this filter is
|
|
// active (otherwise we'd show a bunch of online ONUs whose Time
|
|
// field happens to be old just because they're idle).
|
|
const s = onuStatus(cfg);
|
|
if (!DOWN_STATUSES.has(s)) return false;
|
|
const d = daysSince(lastSeenDate(cfg));
|
|
if (d === null || d < downDays) return false;
|
|
}
|
|
return true;
|
|
});
|
|
renderFleet();
|
|
}
|
|
|
|
for (const el of [
|
|
$('#filter-text'),
|
|
$('#filter-equipment'),
|
|
$('#filter-version'),
|
|
$('#filter-exclude-version'),
|
|
$('#filter-model'),
|
|
$('#filter-down-days'),
|
|
]) {
|
|
el.addEventListener('input', applyFilters);
|
|
}
|
|
$('#filter-pon').addEventListener('change', applyFilters);
|
|
$('#filter-status').addEventListener('change', applyFilters);
|
|
|
|
function renderFleet() {
|
|
const tbody = $('#fleet-tbody');
|
|
tbody.innerHTML = '';
|
|
for (const cfg of state.filtered) {
|
|
const tr = document.createElement('tr');
|
|
const id = cfg._id;
|
|
if (state.selected.has(id)) tr.classList.add('selected');
|
|
const ptr = activeBank(cfg);
|
|
const s = onuStatus(cfg);
|
|
const statusCls = s === 'Registered'
|
|
? 'status-ok'
|
|
: DOWN_STATUSES.has(s)
|
|
? 'status-err'
|
|
: s
|
|
? 'status-pending'
|
|
: 'muted';
|
|
const statusText = s || 'unknown';
|
|
const seen = lastSeenDate(cfg);
|
|
const seenDays = daysSince(seen);
|
|
tr.innerHTML = `
|
|
<td><input type="checkbox" data-id="${id}" ${state.selected.has(id) ? 'checked' : ''}/></td>
|
|
<td>${escapeHtml(id)}</td>
|
|
<td>${escapeHtml(cfg?.ONU?.Name || cfg?.ONU?.Address || '')}</td>
|
|
<td>${escapeHtml(equipmentId(cfg))}</td>
|
|
<td>${escapeHtml(cfg?.ONU?.['PON Mode'] || '')}</td>
|
|
<td class="${statusCls}">${escapeHtml(statusText)}</td>
|
|
<td>${seenDays === null ? '<span class="muted">—</span>' : escapeHtml(formatRelative(seenDays))}</td>
|
|
<td>${ptr === null || ptr === 65535 ? '<span class="muted">unset</span>' : ptr}</td>
|
|
<td>${escapeHtml(activeVersion(cfg))}</td>
|
|
<td>${escapeHtml(inactiveVersion(cfg))}</td>
|
|
`;
|
|
tbody.appendChild(tr);
|
|
}
|
|
$('#fleet-count').textContent = state.filtered.length;
|
|
updateSelectionSummary();
|
|
// Wire checkboxes
|
|
for (const cb of tbody.querySelectorAll('input[type="checkbox"]')) {
|
|
cb.addEventListener('change', () => {
|
|
const id = cb.getAttribute('data-id');
|
|
if (cb.checked) state.selected.add(id); else state.selected.delete(id);
|
|
cb.closest('tr').classList.toggle('selected', cb.checked);
|
|
updateSelectionSummary();
|
|
});
|
|
}
|
|
}
|
|
|
|
$('#th-check').addEventListener('change', (e) => {
|
|
if (e.target.checked) {
|
|
for (const cfg of state.filtered) state.selected.add(cfg._id);
|
|
} else {
|
|
for (const cfg of state.filtered) state.selected.delete(cfg._id);
|
|
}
|
|
renderFleet();
|
|
});
|
|
|
|
$('#btn-select-all').addEventListener('click', () => {
|
|
for (const cfg of state.filtered) state.selected.add(cfg._id);
|
|
renderFleet();
|
|
});
|
|
$('#btn-select-none').addEventListener('click', () => {
|
|
state.selected.clear();
|
|
renderFleet();
|
|
});
|
|
|
|
function updateSelectionSummary() {
|
|
$('#sel-count').textContent = state.selected.size;
|
|
$('#btn-to-campaign').disabled = state.selected.size === 0;
|
|
$('#btn-delete-selected').disabled = state.selected.size === 0;
|
|
}
|
|
|
|
// -------- Delete --------
|
|
$('#btn-delete-selected').addEventListener('click', async () => {
|
|
const ids = Array.from(state.selected);
|
|
if (!ids.length) return;
|
|
// Two-step confirmation: summary dialog first, then require typing
|
|
// DELETE to proceed. This is destructive (Procedure 43 removes the
|
|
// ONU-CFG document from MongoDB) and there's no undo from inside this
|
|
// app — a returning ONU will re-register but service-config is gone.
|
|
const downCount = ids.filter((id) => {
|
|
const cfg = state.fleet.find((c) => c._id === id);
|
|
return DOWN_STATUSES.has(onuStatus(cfg));
|
|
}).length;
|
|
const summary =
|
|
`You're about to DELETE ${ids.length} ONU(s) from MCMS ` +
|
|
`(${downCount} currently down).\n\n` +
|
|
`This removes the ONU-CFG document and service configuration. ` +
|
|
`Physical ONUs that come back online will re-register from scratch.\n\n` +
|
|
`Click OK to continue to the final confirmation.`;
|
|
if (!confirm(summary)) return;
|
|
const typed = prompt(`Type DELETE to confirm removal of ${ids.length} ONU(s):`);
|
|
if (typed !== 'DELETE') {
|
|
$('#delete-status').textContent = 'Cancelled.';
|
|
return;
|
|
}
|
|
|
|
$('#btn-delete-selected').disabled = true;
|
|
$('#btn-to-campaign').disabled = true;
|
|
$('#delete-status').textContent = `Deleting 0/${ids.length}…`;
|
|
|
|
const unbind = window.api.onDeleteProgress(({ done, total, ok, onuId, error }) => {
|
|
$('#delete-status').textContent =
|
|
`Deleting ${done}/${total}${error ? ` (last error on ${onuId}: ${error.message})` : ''}`;
|
|
});
|
|
const res = await window.api.deleteOnus({ onuIds: ids });
|
|
unbind();
|
|
if (!res.ok) {
|
|
$('#delete-status').textContent = `Delete failed: ${res.error?.message}`;
|
|
$('#btn-delete-selected').disabled = false;
|
|
return;
|
|
}
|
|
const okCount = res.data.filter((r) => r.ok).length;
|
|
const failed = res.data.filter((r) => !r.ok);
|
|
// Drop successfully-deleted ONUs from local state so the table reflects
|
|
// the new reality without needing a full reload.
|
|
const deletedIds = new Set(res.data.filter((r) => r.ok).map((r) => r.onuId));
|
|
state.fleet = state.fleet.filter((c) => !deletedIds.has(c._id));
|
|
for (const id of deletedIds) state.selected.delete(id);
|
|
applyFilters();
|
|
|
|
let msg = `Deleted ${okCount}/${res.data.length}.`;
|
|
if (failed.length) {
|
|
msg += ` Failures: ` + failed.slice(0, 3).map((f) => `${f.onuId} (${f.error?.message || '?'})`).join(', ');
|
|
if (failed.length > 3) msg += ` and ${failed.length - 3} more`;
|
|
}
|
|
$('#delete-status').textContent = msg;
|
|
});
|
|
|
|
// -------- Campaign --------
|
|
$('#btn-to-campaign').addEventListener('click', async () => {
|
|
showView('#view-campaign');
|
|
await refreshFirmwareList();
|
|
});
|
|
$('#btn-back').addEventListener('click', () => showView('#view-fleet'));
|
|
$('#btn-reload-fw').addEventListener('click', refreshFirmwareList);
|
|
|
|
$('#btn-upload-fw').addEventListener('click', async () => {
|
|
$('#exec-status').textContent = 'Uploading firmware…';
|
|
const res = await window.api.uploadFirmware();
|
|
if (!res.ok) {
|
|
if (res.error?.message === 'cancelled') {
|
|
$('#exec-status').textContent = '';
|
|
} else {
|
|
$('#exec-status').textContent = `Upload failed: ${res.error?.message}`;
|
|
}
|
|
return;
|
|
}
|
|
$('#exec-status').textContent = `Uploaded ${res.data.filename}.`;
|
|
await refreshFirmwareList();
|
|
});
|
|
|
|
async function refreshFirmwareList() {
|
|
const res = await window.api.listOnuFirmware();
|
|
if (!res.ok) {
|
|
$('#exec-status').textContent = `Firmware list error: ${res.error?.message}`;
|
|
return;
|
|
}
|
|
state.firmwareList = res.data || [];
|
|
const sel = $('#fw-select');
|
|
sel.innerHTML = '';
|
|
for (const fw of state.firmwareList) {
|
|
const opt = document.createElement('option');
|
|
// The firmware list entries are GridFS file metadata; shape varies
|
|
// slightly by MCMS version but _id / filename is always present.
|
|
const filename = fw.filename || fw._id || JSON.stringify(fw);
|
|
const version = fw?.metadata?.Version || fw?.Version || '';
|
|
opt.value = filename;
|
|
opt.textContent = version ? `${filename} — ${version}` : filename;
|
|
opt.dataset.version = version;
|
|
sel.appendChild(opt);
|
|
}
|
|
if (state.firmwareList.length) {
|
|
sel.selectedIndex = 0;
|
|
$('#fw-version').value = sel.options[0].dataset.version || '';
|
|
}
|
|
}
|
|
|
|
$('#fw-select').addEventListener('change', () => {
|
|
const opt = $('#fw-select').selectedOptions[0];
|
|
if (opt) $('#fw-version').value = opt.dataset.version || '';
|
|
});
|
|
|
|
$('#mode-select').addEventListener('change', () => {
|
|
state.campaignMode = $('#mode-select').value;
|
|
$('#row-schedule').style.display = state.campaignMode === 'task' ? '' : 'none';
|
|
});
|
|
|
|
$('#btn-preview').addEventListener('click', async () => {
|
|
const targetFile = $('#fw-select').value;
|
|
const targetVersion = $('#fw-version').value.trim();
|
|
if (!targetFile || !targetVersion) {
|
|
$('#exec-status').textContent = 'Pick a firmware file and fill in the version string.';
|
|
return;
|
|
}
|
|
$('#exec-status').textContent = 'Computing plan…';
|
|
const onuIds = Array.from(state.selected);
|
|
// Fresh FEC results for each preview — link health can change between
|
|
// hitting Preview and hitting Execute, so don't carry stale flags.
|
|
state.fecHealth = new Map();
|
|
const res = await window.api.planUpgrade({ onuIds, targetFile, targetVersion });
|
|
if (!res.ok) {
|
|
$('#exec-status').textContent = `Plan failed: ${res.error?.message}`;
|
|
return;
|
|
}
|
|
state.plan = res.data;
|
|
renderPreview();
|
|
$('#btn-execute').disabled = false;
|
|
$('#exec-status').textContent =
|
|
`Previewed ${state.plan.length} ONUs. Checking FEC health…`;
|
|
|
|
// Kick off the FEC pre-flight in parallel. Each result paints its row
|
|
// immediately so the operator can spot "Post-FEC errors" rows before
|
|
// committing the upgrade. The MCMS /onus/stats/<id>/ endpoint is
|
|
// per-ONU, so this is bounded to the selected set rather than the
|
|
// whole fleet (per Jon's preference: "before committing the firmware
|
|
// update, not for the entire fleet").
|
|
const planIds = state.plan.filter((p) => !p.error).map((p) => p.onuId);
|
|
if (!planIds.length) return;
|
|
const unbind = window.api.onFecProgress((p) => {
|
|
state.fecHealth.set(p.onuId, p);
|
|
paintFecCell(p.onuId);
|
|
if (p.done === p.total) {
|
|
const counts = countFecFlags();
|
|
$('#exec-status').textContent =
|
|
`FEC pre-flight complete: ` +
|
|
`${counts.ok} OK, ${counts.pre} pre-FEC, ${counts.post} post-FEC, ` +
|
|
`${counts.buggy} pre==post (ONU bug?), ` +
|
|
`${counts.nodata + counts.error} unknown.`;
|
|
}
|
|
});
|
|
const fecRes = await window.api.fetchFecHealth({ onuIds: planIds });
|
|
unbind();
|
|
if (!fecRes.ok) {
|
|
$('#exec-status').textContent =
|
|
`Plan ready (FEC fetch failed: ${fecRes.error?.message}). ` +
|
|
`You can still execute, but pre-flight health is unavailable.`;
|
|
return;
|
|
}
|
|
// Final paint in case any progress events were missed.
|
|
for (const r of fecRes.data) state.fecHealth.set(r.onuId, r);
|
|
for (const r of fecRes.data) paintFecCell(r.onuId);
|
|
});
|
|
|
|
function countFecFlags() {
|
|
const c = { ok: 0, pre: 0, post: 0, buggy: 0, nodata: 0, error: 0 };
|
|
for (const v of state.fecHealth.values()) {
|
|
if (c[v.flag] !== undefined) c[v.flag] += 1;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
function paintFecCell(onuId) {
|
|
const tbody = $('#preview-tbody');
|
|
const tr = tbody.querySelector(`tr[data-onu="${cssEscape(onuId)}"]`);
|
|
if (!tr) return;
|
|
const cell = tr.querySelector('td.fec-cell');
|
|
if (!cell) return;
|
|
cell.innerHTML = fecPillHtml(state.fecHealth.get(onuId));
|
|
}
|
|
|
|
function cssEscape(s) {
|
|
// Minimal CSS attribute selector escaping. ONU IDs are MAC addresses /
|
|
// hex strings on this MCMS build so this is mostly belt-and-braces.
|
|
return String(s).replace(/(["\\])/g, '\\$1');
|
|
}
|
|
|
|
function renderPreview() {
|
|
const tbody = $('#preview-tbody');
|
|
tbody.innerHTML = '';
|
|
for (const p of state.plan) {
|
|
const tr = document.createElement('tr');
|
|
tr.setAttribute('data-onu', p.onuId);
|
|
if (p.error) {
|
|
tr.innerHTML = `
|
|
<td>${escapeHtml(p.onuId)}</td>
|
|
<td colspan="5"></td>
|
|
<td class="fec-cell muted">—</td>
|
|
<td class="status-err">${escapeHtml(p.error)}</td>`;
|
|
} else {
|
|
const prevPtr = p.previousActiveSlot;
|
|
const arrow = `<span class="slot-arrow">${prevPtr} → ${p.writeSlot}</span>`;
|
|
const fec = state.fecHealth.get(p.onuId);
|
|
tr.innerHTML = `
|
|
<td>${escapeHtml(p.onuId)}</td>
|
|
<td>${escapeHtml(p.name || p.address || '')}</td>
|
|
<td>${arrow}</td>
|
|
<td>${escapeHtml(p.currentVersionInSlot0)}</td>
|
|
<td>${escapeHtml(p.currentVersionInSlot1)}</td>
|
|
<td>${escapeHtml(p.targetVersion)}</td>
|
|
<td class="fec-cell">${fecPillHtml(fec)}</td>
|
|
<td class="status-pending">ready</td>`;
|
|
}
|
|
tbody.appendChild(tr);
|
|
}
|
|
}
|
|
|
|
$('#btn-execute').addEventListener('click', async () => {
|
|
const onuIds = state.plan.filter((p) => !p.error).map((p) => p.onuId);
|
|
const targetFile = $('#fw-select').value;
|
|
const targetVersion = $('#fw-version').value.trim();
|
|
if (!onuIds.length) {
|
|
$('#exec-status').textContent = 'No valid ONUs in plan.';
|
|
return;
|
|
}
|
|
// Warn (but don't block) if any ONU shows post-FEC errors or the
|
|
// pre==post buggy signature. Operators sometimes intentionally
|
|
// upgrade marginal links — that's exactly what the new firmware
|
|
// might be fixing — and the buggy-counter case is itself a reason
|
|
// to upgrade. So this is a soft gate, not a hard one.
|
|
const counts = countFecFlags();
|
|
const warnings = [];
|
|
if (counts.post) {
|
|
warnings.push(
|
|
`${counts.post} ONU(s) currently report Post-FEC errors ` +
|
|
`(uncorrected bits hitting the user).`,
|
|
);
|
|
}
|
|
if (counts.buggy) {
|
|
warnings.push(
|
|
`${counts.buggy} ONU(s) report identical pre/post FEC values ` +
|
|
`— likely an ONU firmware bug. Upgrading may be the fix.`,
|
|
);
|
|
}
|
|
const fecWarning = warnings.length ? `\n\nWARNING:\n • ${warnings.join('\n • ')}` : '';
|
|
if (!confirm(
|
|
`About to stage ${targetVersion} to the inactive bank on ${onuIds.length} ONU(s). ` +
|
|
`Proceed?${fecWarning}`,
|
|
)) {
|
|
return;
|
|
}
|
|
$('#btn-execute').disabled = true;
|
|
|
|
// Save the plan to CSV BEFORE writing anything to MCMS, so even if
|
|
// the API call dies mid-way we have a record of what we were about
|
|
// to do (and which links looked sketchy at the time).
|
|
const csvHeaders = [
|
|
'ONU ID',
|
|
'Name',
|
|
'Address',
|
|
'PON Mode',
|
|
'Active slot (before)',
|
|
'Write slot (target)',
|
|
'Slot 0 version (before)',
|
|
'Slot 1 version (before)',
|
|
'Target version',
|
|
'Target file',
|
|
'FEC health',
|
|
'ONU RX Pre-FEC BER',
|
|
'ONU RX Post-FEC BER',
|
|
'OLT RX Pre-FEC BER',
|
|
'OLT RX Post-FEC BER',
|
|
'ONU RX Optical (dBm)',
|
|
'ONU TX Optical (dBm)',
|
|
'FEC sample time',
|
|
'Mode',
|
|
'Notes',
|
|
];
|
|
// Helper: pluck a counter by (scope, kind) from the structured array.
|
|
const counterValue = (counters, scope, kind) => {
|
|
if (!Array.isArray(counters)) return '';
|
|
const c = counters.find((x) => x.scope === scope && x.kind === kind);
|
|
return c ? c.value : '';
|
|
};
|
|
const csvRows = state.plan.map((p) => {
|
|
const fec = state.fecHealth.get(p.onuId) || {};
|
|
const label = FEC_LABELS[fec.flag]?.text || '';
|
|
return {
|
|
'ONU ID': p.onuId,
|
|
'Name': p.name || '',
|
|
'Address': p.address || '',
|
|
'PON Mode': p.ponMode || '',
|
|
'Active slot (before)': p.error ? '' : p.previousActiveSlot,
|
|
'Write slot (target)': p.error ? '' : p.writeSlot,
|
|
'Slot 0 version (before)': p.error ? '' : p.currentVersionInSlot0,
|
|
'Slot 1 version (before)': p.error ? '' : p.currentVersionInSlot1,
|
|
'Target version': targetVersion,
|
|
'Target file': targetFile,
|
|
'FEC health': label,
|
|
'ONU RX Pre-FEC BER': counterValue(fec.counters, 'onu', 'pre'),
|
|
'ONU RX Post-FEC BER': counterValue(fec.counters, 'onu', 'post'),
|
|
'OLT RX Pre-FEC BER': counterValue(fec.counters, 'olt', 'pre'),
|
|
'OLT RX Post-FEC BER': counterValue(fec.counters, 'olt', 'post'),
|
|
'ONU RX Optical (dBm)': fec.optical?.rx ?? '',
|
|
'ONU TX Optical (dBm)': fec.optical?.tx ?? '',
|
|
'FEC sample time': fec.sampleTime || '',
|
|
'Mode': state.campaignMode,
|
|
'Notes': p.error || (fec.error ? `FEC fetch: ${fec.error.message}` : ''),
|
|
};
|
|
});
|
|
const csvSave = await window.api.savePlanCsv({
|
|
rows: csvRows,
|
|
headers: csvHeaders,
|
|
filenameHint: `${targetVersion || 'unknown'}-${state.campaignMode}-${onuIds.length}onus`,
|
|
});
|
|
if (csvSave.ok) {
|
|
$('#exec-status').textContent = `Plan saved → ${csvSave.data.path}. Submitting upgrade…`;
|
|
} else {
|
|
$('#exec-status').textContent =
|
|
`(CSV save failed: ${csvSave.error?.message}) Submitting upgrade anyway…`;
|
|
}
|
|
|
|
if (state.campaignMode === 'task') {
|
|
// Procedure 8 — single scheduled task.
|
|
const scheduleLocal = $('#in-schedule').value;
|
|
// Convert local datetime to MCMS "YYYY-MM-DD HH:MM:SS" in UTC. If the
|
|
// field is blank, start immediately (now).
|
|
const when = scheduleLocal ? new Date(scheduleLocal) : new Date();
|
|
const pad = (n) => String(n).padStart(2, '0');
|
|
const scheduledStart =
|
|
`${when.getUTCFullYear()}-${pad(when.getUTCMonth() + 1)}-${pad(when.getUTCDate())} ` +
|
|
`${pad(when.getUTCHours())}:${pad(when.getUTCMinutes())}:${pad(when.getUTCSeconds())}`;
|
|
|
|
// All ONUs in the plan currently share a single inactive bank target
|
|
// because we compute per-ONU. For the task endpoint we need ONE bank
|
|
// number, so we bucket by writeSlot and create one task per slot.
|
|
const buckets = { 0: [], 1: [] };
|
|
for (const p of state.plan) {
|
|
if (p.error) continue;
|
|
buckets[p.writeSlot].push(p.onuId);
|
|
}
|
|
const results = [];
|
|
for (const [slotStr, serials] of Object.entries(buckets)) {
|
|
if (!serials.length) continue;
|
|
const slot = Number(slotStr);
|
|
const taskId = `FwUp-${targetVersion}-slot${slot}-${Date.now()}`;
|
|
$('#exec-status').textContent = `Creating task ${taskId} (${serials.length} ONUs)…`;
|
|
const res = await window.api.executeBulkTask({
|
|
taskId,
|
|
serials,
|
|
scheduledStart,
|
|
fwBankPtr: slot,
|
|
targetFile,
|
|
targetVersion,
|
|
});
|
|
results.push({ taskId, slot, count: serials.length, res });
|
|
}
|
|
$('#exec-status').textContent =
|
|
`Submitted ${results.length} task(s): ` +
|
|
results.map((r) => `${r.taskId} (${r.count} ONUs, slot ${r.slot}, ${r.res.ok ? 'ok' : 'FAILED'})`).join('; ');
|
|
markAllPreviewRows(results.every((r) => r.res.ok) ? 'submitted' : 'error');
|
|
} else {
|
|
// Procedure 7 — per-ONU PUTs. Slower but gives immediate feedback.
|
|
const unbind = window.api.onUpgradeProgress((p) => {
|
|
$('#exec-status').textContent = `[${p.index + 1}/${p.total}] ${p.phase} ${p.onuId}` +
|
|
(p.writeSlot !== undefined ? ` (slot ${p.writeSlot})` : '');
|
|
});
|
|
const res = await window.api.executePerOnu({ onuIds, targetFile, targetVersion });
|
|
unbind();
|
|
if (!res.ok) {
|
|
$('#exec-status').textContent = `Execution failed: ${res.error?.message}`;
|
|
$('#btn-execute').disabled = false;
|
|
return;
|
|
}
|
|
// Apply per-row status back onto the preview table.
|
|
const byId = new Map(res.data.map((r) => [r.onuId, r]));
|
|
const rows = $('#preview-tbody').querySelectorAll('tr');
|
|
let i = 0;
|
|
for (const p of state.plan) {
|
|
const row = rows[i++];
|
|
const cell = row?.querySelector('td:last-child');
|
|
if (!cell) continue;
|
|
if (p.error) continue;
|
|
const r = byId.get(p.onuId);
|
|
if (!r) { cell.textContent = 'skipped'; continue; }
|
|
if (r.ok) { cell.textContent = `wrote slot ${r.writeSlot}`; cell.className = 'status-ok'; }
|
|
else { cell.textContent = r.error?.message || 'failed'; cell.className = 'status-err'; }
|
|
}
|
|
const okCount = res.data.filter((r) => r.ok).length;
|
|
$('#exec-status').textContent = `Done: ${okCount}/${res.data.length} succeeded.`;
|
|
}
|
|
});
|
|
|
|
function markAllPreviewRows(state) {
|
|
const rows = $('#preview-tbody').querySelectorAll('tr');
|
|
for (const r of rows) {
|
|
const cell = r.querySelector('td:last-child');
|
|
if (!cell) continue;
|
|
if (state === 'submitted') { cell.textContent = 'submitted to MCMS'; cell.className = 'status-ok'; }
|
|
else if (state === 'error') { cell.textContent = 'task submission failed'; cell.className = 'status-err'; }
|
|
}
|
|
}
|
|
|
|
// -------- Verify view: open saved plan CSV, re-fetch, compare, save --------
|
|
|
|
$('#btn-to-verify').addEventListener('click', () => {
|
|
showView('#view-verify');
|
|
resetVerifyView();
|
|
});
|
|
$('#btn-verify-back').addEventListener('click', () => showView('#view-fleet'));
|
|
$('#btn-pick-plan').addEventListener('click', runVerifyFlow);
|
|
$('#btn-save-verify').addEventListener('click', saveVerifyReport);
|
|
|
|
function resetVerifyView() {
|
|
$('#verify-status').textContent = '';
|
|
$('#verify-save-status').textContent = '';
|
|
$('#verify-tbody').innerHTML = '';
|
|
$('#verify-count').textContent = '0';
|
|
$('#btn-save-verify').disabled = true;
|
|
$('#verify-summary').innerHTML = '<div class="muted small">Open a CSV to start.</div>';
|
|
state.verify = null;
|
|
}
|
|
|
|
async function runVerifyFlow() {
|
|
$('#verify-status').textContent = 'Picking file…';
|
|
const fileRes = await window.api.openCsvFile();
|
|
if (!fileRes.ok) {
|
|
$('#verify-status').textContent = fileRes.error?.message === 'cancelled'
|
|
? '' : `Open failed: ${fileRes.error?.message || 'unknown'}`;
|
|
return;
|
|
}
|
|
const { path: sourcePath, text } = fileRes.data;
|
|
|
|
let beforeRows;
|
|
try {
|
|
beforeRows = parsePlanCsv(text);
|
|
} catch (e) {
|
|
$('#verify-status').textContent = `CSV parse failed: ${e.message}`;
|
|
return;
|
|
}
|
|
if (!beforeRows.length) {
|
|
$('#verify-status').textContent = 'No ONU rows found in CSV.';
|
|
return;
|
|
}
|
|
const ids = beforeRows.map((r) => r.onuId).filter(Boolean);
|
|
$('#verify-status').textContent =
|
|
`Loaded ${beforeRows.length} rows from ${sourcePath}. Fetching current state…`;
|
|
|
|
const unbind = window.api.onVerifyProgress(({ done, total }) => {
|
|
$('#verify-status').textContent =
|
|
`Loaded ${beforeRows.length} from ${sourcePath}. Fetching current state… ${done}/${total}`;
|
|
});
|
|
const snap = await window.api.fetchOnuSnapshot({ onuIds: ids });
|
|
unbind();
|
|
if (!snap.ok) {
|
|
$('#verify-status').textContent = `Fetch failed: ${snap.error?.message}`;
|
|
return;
|
|
}
|
|
const snapshotById = new Map(snap.data.map((r) => [r.onuId, r]));
|
|
const comparisons = beforeRows.map((b) => buildComparison(b, snapshotById.get(b.onuId)));
|
|
state.verify = { sourcePath, beforeRows, snapshotById, comparisons };
|
|
renderVerifyTable(comparisons);
|
|
$('#btn-save-verify').disabled = false;
|
|
$('#verify-status').textContent =
|
|
`Compared ${comparisons.length} ONUs from ${sourcePath}. Saving report…`;
|
|
|
|
// Auto-save the verification report immediately, mirroring the
|
|
// auto-save behavior on Execute.
|
|
await saveVerifyReport();
|
|
}
|
|
|
|
// CSV parsing -----------------------------------------------------------
|
|
|
|
// Lenient CSV reader. Handles quoted cells with embedded commas, escaped
|
|
// quotes ("" inside quoted strings), CRLF or LF line endings, and a
|
|
// leading UTF-8 BOM. Returns a 2-D array of strings.
|
|
function parseCsvText(text) {
|
|
if (text.charCodeAt(0) === 0xFEFF) text = text.slice(1);
|
|
const rows = [];
|
|
let row = [];
|
|
let cell = '';
|
|
let inQuotes = false;
|
|
for (let i = 0; i < text.length; i++) {
|
|
const ch = text[i];
|
|
if (inQuotes) {
|
|
if (ch === '"') {
|
|
if (text[i + 1] === '"') { cell += '"'; i++; }
|
|
else { inQuotes = false; }
|
|
} else {
|
|
cell += ch;
|
|
}
|
|
} else {
|
|
if (ch === '"') inQuotes = true;
|
|
else if (ch === ',') { row.push(cell); cell = ''; }
|
|
else if (ch === '\r') { /* swallow; \n closes the row */ }
|
|
else if (ch === '\n') { row.push(cell); rows.push(row); row = []; cell = ''; }
|
|
else cell += ch;
|
|
}
|
|
}
|
|
if (cell !== '' || row.length) { row.push(cell); rows.push(row); }
|
|
return rows;
|
|
}
|
|
|
|
// Locate a column in a header row by trying a list of candidate names
|
|
// (case-insensitive, trimmed). Returns -1 if none match.
|
|
function findColumn(headers, candidates) {
|
|
const norm = headers.map((h) => String(h).trim().toLowerCase());
|
|
for (const cand of candidates) {
|
|
const idx = norm.indexOf(String(cand).toLowerCase());
|
|
if (idx >= 0) return idx;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Parse the saved plan CSV into structured "before" rows. Tolerant of
|
|
// missing columns (a CSV authored by an older version of this app).
|
|
function parsePlanCsv(text) {
|
|
const matrix = parseCsvText(text);
|
|
if (matrix.length < 2) return [];
|
|
const headers = matrix[0];
|
|
const idCol = findColumn(headers, ['ONU ID', 'Serial', 'serial']);
|
|
if (idCol < 0) throw new Error('No "ONU ID" column found in CSV header');
|
|
|
|
const cellOf = (row, ...names) => {
|
|
const i = findColumn(headers, names);
|
|
return i >= 0 ? (row[i] ?? '') : '';
|
|
};
|
|
const numOf = (row, ...names) => {
|
|
const v = String(cellOf(row, ...names)).trim();
|
|
if (v === '' || v === '—') return null;
|
|
const n = Number(v);
|
|
return Number.isFinite(n) ? n : null;
|
|
};
|
|
|
|
const rows = [];
|
|
for (let r = 1; r < matrix.length; r++) {
|
|
const row = matrix[r];
|
|
if (!row || row.length === 0) continue;
|
|
const id = (row[idCol] || '').trim();
|
|
if (!id) continue;
|
|
rows.push({
|
|
onuId: id,
|
|
name: cellOf(row, 'Name'),
|
|
address: cellOf(row, 'Address'),
|
|
ponMode: cellOf(row, 'PON Mode'),
|
|
writeSlot: cellOf(row, 'Write slot (target)'),
|
|
targetVersion: cellOf(row, 'Target version'),
|
|
targetFile: cellOf(row, 'Target file'),
|
|
fecHealthBefore: cellOf(row, 'FEC health'),
|
|
onuPreBefore: numOf(row, 'ONU RX Pre-FEC BER'),
|
|
onuPostBefore: numOf(row, 'ONU RX Post-FEC BER'),
|
|
oltPreBefore: numOf(row, 'OLT RX Pre-FEC BER'),
|
|
oltPostBefore: numOf(row, 'OLT RX Post-FEC BER'),
|
|
rxBefore: numOf(row, 'ONU RX Optical (dBm)'),
|
|
txBefore: numOf(row, 'ONU TX Optical (dBm)'),
|
|
});
|
|
}
|
|
return rows;
|
|
}
|
|
|
|
// Comparison logic ------------------------------------------------------
|
|
|
|
// Map the before-row's "FEC health" label string back to a flag so the
|
|
// verdict logic can compare against the live `after.flag`. The labels
|
|
// come from FEC_LABELS so this is the inverse of that lookup.
|
|
function flagFromLabel(label) {
|
|
if (!label) return 'unknown';
|
|
const l = String(label).trim().toLowerCase();
|
|
for (const [flag, lab] of Object.entries(FEC_LABELS)) {
|
|
if (lab.text.toLowerCase() === l) return flag;
|
|
}
|
|
return 'unknown';
|
|
}
|
|
|
|
function buildComparison(before, after) {
|
|
const cfg = after?.cfg || null;
|
|
const activeNow = cfg ? activeVersion(cfg) : '';
|
|
const target = before.targetVersion;
|
|
let upgradeApplied = null; // null = unknown
|
|
if (target && activeNow && activeNow !== '(unset)' && activeNow !== '(empty)') {
|
|
upgradeApplied = activeNow === target;
|
|
}
|
|
|
|
const counterAfter = (scope, kind) => {
|
|
if (!after?.counters) return null;
|
|
const c = after.counters.find((x) => x.scope === scope && x.kind === kind);
|
|
return c ? c.value : null;
|
|
};
|
|
|
|
const beforeFlag = flagFromLabel(before.fecHealthBefore);
|
|
const afterFlag = after?.flag || 'error';
|
|
|
|
return {
|
|
onuId: before.onuId,
|
|
name: before.name,
|
|
address: before.address,
|
|
target,
|
|
activeNow,
|
|
upgradeApplied,
|
|
|
|
beforeFlag,
|
|
afterFlag,
|
|
fecBeforeLabel: before.fecHealthBefore,
|
|
fecAfterLabel: FEC_LABELS[afterFlag]?.text || afterFlag,
|
|
|
|
onuPreBefore: before.onuPreBefore,
|
|
onuPreAfter: counterAfter('onu', 'pre'),
|
|
onuPostBefore: before.onuPostBefore,
|
|
onuPostAfter: counterAfter('onu', 'post'),
|
|
oltPreBefore: before.oltPreBefore,
|
|
oltPreAfter: counterAfter('olt', 'pre'),
|
|
oltPostBefore: before.oltPostBefore,
|
|
oltPostAfter: counterAfter('olt', 'post'),
|
|
|
|
rxBefore: before.rxBefore,
|
|
rxAfter: after?.optical?.rx ?? null,
|
|
txBefore: before.txBefore,
|
|
txAfter: after?.optical?.tx ?? null,
|
|
|
|
afterError: after?.error || null,
|
|
sampleTime: after?.sampleTime || '',
|
|
verdict: computeVerdict(beforeFlag, afterFlag, upgradeApplied, after),
|
|
};
|
|
}
|
|
|
|
// Single-line verdict per ONU. The verdict is mostly about the FEC flag
|
|
// transition because the raw counters reset on the upgrade reboot, so
|
|
// "delta is negative" is normal and not informative.
|
|
function computeVerdict(beforeFlag, afterFlag, upgradeApplied, after) {
|
|
if (!after) return 'fetch failed';
|
|
if (afterFlag === 'error') return 'fetch failed';
|
|
if (upgradeApplied === false) return 'upgrade NOT applied (active version unchanged)';
|
|
if (afterFlag === 'nodata') return 'no current FEC data';
|
|
|
|
const wasGood = beforeFlag === 'ok';
|
|
const isGood = afterFlag === 'ok';
|
|
const wasBuggy = beforeFlag === 'buggy';
|
|
const isBuggy = afterFlag === 'buggy';
|
|
|
|
if (wasBuggy && isBuggy) return 'still buggy (firmware bug persists)';
|
|
if (wasBuggy && isGood) return 'fixed (was buggy)';
|
|
if (wasBuggy && afterFlag === 'pre') return 'improved (no longer mirroring counters)';
|
|
if (wasBuggy && afterFlag === 'post') return 'changed: now reporting genuine post-FEC errors';
|
|
|
|
if (wasGood && isGood) return 'still healthy';
|
|
if (wasGood && afterFlag === 'pre') return 'regressed (now marginal)';
|
|
if (wasGood && afterFlag === 'post') return 'regressed (now post-FEC errors)';
|
|
if (wasGood && afterFlag === 'buggy') return 'regressed (now buggy)';
|
|
|
|
if (!wasGood && isGood) return 'improved';
|
|
if (beforeFlag === 'post' && afterFlag === 'pre') return 'improved (post→pre)';
|
|
if (beforeFlag === 'pre' && afterFlag === 'post') return 'regressed (pre→post)';
|
|
|
|
if (afterFlag === 'post') return 'still has post-FEC errors';
|
|
if (afterFlag === 'pre') return 'still marginal (pre-FEC only)';
|
|
return 'unchanged';
|
|
}
|
|
|
|
const VERDICT_CLASSES = [
|
|
{ match: /fixed|improved|still healthy/i, cls: 'status-ok' },
|
|
{ match: /still buggy/i, cls: 'status-info' },
|
|
{ match: /regressed|NOT applied|fetch failed|post-FEC/i, cls: 'status-err' },
|
|
{ match: /marginal|pre-FEC/i, cls: 'status-warn' },
|
|
];
|
|
function verdictCls(v) {
|
|
for (const r of VERDICT_CLASSES) if (r.match.test(v)) return r.cls;
|
|
return 'muted';
|
|
}
|
|
|
|
// Render -----------------------------------------------------------------
|
|
|
|
function renderVerifyTable(comparisons) {
|
|
const tbody = $('#verify-tbody');
|
|
tbody.innerHTML = '';
|
|
|
|
// Counts for the side-panel summary.
|
|
const tally = { applied: 0, notApplied: 0, fixed: 0, stillBuggy: 0, regressed: 0, healthy: 0, other: 0 };
|
|
|
|
for (const c of comparisons) {
|
|
const tr = document.createElement('tr');
|
|
tr.setAttribute('data-onu', c.onuId);
|
|
|
|
if (c.upgradeApplied === true) tally.applied++;
|
|
else if (c.upgradeApplied === false) tally.notApplied++;
|
|
if (/fixed|improved/.test(c.verdict)) tally.fixed++;
|
|
else if (/still buggy/.test(c.verdict)) tally.stillBuggy++;
|
|
else if (/regressed|NOT applied|fetch failed/.test(c.verdict)) tally.regressed++;
|
|
else if (/still healthy/.test(c.verdict)) tally.healthy++;
|
|
else tally.other++;
|
|
|
|
const appliedCls = c.upgradeApplied === true ? 'status-ok'
|
|
: c.upgradeApplied === false ? 'status-err'
|
|
: 'muted';
|
|
const appliedTxt = c.upgradeApplied === true ? 'yes'
|
|
: c.upgradeApplied === false ? 'no'
|
|
: '?';
|
|
|
|
const beforeFecBlock =
|
|
`<span class="${FEC_LABELS[c.beforeFlag]?.cls || 'muted'} fec-pill">${escapeHtml(c.fecBeforeLabel || c.beforeFlag)}</span>` +
|
|
`<span class="fec-counters">` +
|
|
`<span>pre=${escapeHtml(formatFecOrDash(c.onuPreBefore))}</span><br/>` +
|
|
`<span>post=${escapeHtml(formatFecOrDash(c.onuPostBefore))}</span>` +
|
|
`</span>`;
|
|
|
|
const afterFecBlock =
|
|
`<span class="${FEC_LABELS[c.afterFlag]?.cls || 'muted'} fec-pill">${escapeHtml(c.fecAfterLabel)}</span>` +
|
|
`<span class="fec-counters">` +
|
|
`<span>pre=${escapeHtml(formatFecOrDash(c.onuPreAfter))}</span><br/>` +
|
|
`<span>post=${escapeHtml(formatFecOrDash(c.onuPostAfter))}</span>` +
|
|
`</span>`;
|
|
|
|
const opticalBlock = renderOpticalCompare(c);
|
|
|
|
const targetCol = c.target
|
|
? `<div>${escapeHtml(c.target)}</div><div class="muted small">now: ${escapeHtml(c.activeNow || '?')}</div>`
|
|
: `<div class="muted">${escapeHtml(c.activeNow || '?')}</div>`;
|
|
|
|
tr.innerHTML = `
|
|
<td>${escapeHtml(c.onuId)}</td>
|
|
<td>${escapeHtml(c.name || '')}</td>
|
|
<td>${targetCol}</td>
|
|
<td class="${appliedCls}">${appliedTxt}</td>
|
|
<td class="fec-cell">${beforeFecBlock}</td>
|
|
<td class="fec-cell">${afterFecBlock}</td>
|
|
<td class="fec-cell">${opticalBlock}</td>
|
|
<td class="${verdictCls(c.verdict)}">${escapeHtml(c.verdict)}</td>
|
|
`;
|
|
tbody.appendChild(tr);
|
|
}
|
|
$('#verify-count').textContent = comparisons.length;
|
|
|
|
$('#verify-summary').innerHTML = `
|
|
<div><strong>${tally.applied}</strong> upgrade applied · <strong>${tally.notApplied}</strong> not applied</div>
|
|
<div><span class="status-ok">${tally.fixed} improved/fixed</span></div>
|
|
<div><span class="status-ok">${tally.healthy} still healthy</span></div>
|
|
<div><span class="status-info">${tally.stillBuggy} still buggy</span></div>
|
|
<div><span class="status-err">${tally.regressed} regressed/failed</span></div>
|
|
<div class="muted">${tally.other} other</div>
|
|
`;
|
|
}
|
|
|
|
function renderOpticalCompare(c) {
|
|
const fmt = (n) => n == null ? '—' : `${n.toFixed(1)} dBm`;
|
|
const cls = (n) => n == null ? 'muted' : n < -30 ? 'status-err' : n < -28 ? 'status-warn' : 'status-ok';
|
|
const rxBefore = `<span class="before-line">RX before: ${escapeHtml(fmt(c.rxBefore))}</span>`;
|
|
const rxAfter = `<span class="after-line ${c.rxAfter == null ? 'muted' : cls(c.rxAfter)}">RX now: ${escapeHtml(fmt(c.rxAfter))}</span>`;
|
|
const txBefore = `<span class="before-line">TX before: ${escapeHtml(fmt(c.txBefore))}</span>`;
|
|
const txAfter = `<span class="after-line ${c.txAfter == null ? 'muted' : (c.txAfter < 3 ? 'status-err' : 'status-ok')}">TX now: ${escapeHtml(fmt(c.txAfter))}</span>`;
|
|
return rxBefore + rxAfter + txBefore + txAfter;
|
|
}
|
|
|
|
function formatFecOrDash(n) {
|
|
if (n === null || n === undefined) return '—';
|
|
return formatFecNumber(n);
|
|
}
|
|
|
|
// Save ------------------------------------------------------------------
|
|
|
|
async function saveVerifyReport() {
|
|
if (!state.verify) return;
|
|
const headers = [
|
|
'ONU ID', 'Name', 'Address',
|
|
'Target version', 'Active version (after)', 'Upgrade applied?',
|
|
'FEC health (before)', 'FEC health (after)',
|
|
'ONU RX Pre-FEC BER (before)', 'ONU RX Pre-FEC BER (after)',
|
|
'ONU RX Post-FEC BER (before)', 'ONU RX Post-FEC BER (after)',
|
|
'OLT RX Pre-FEC BER (before)', 'OLT RX Pre-FEC BER (after)',
|
|
'OLT RX Post-FEC BER (before)', 'OLT RX Post-FEC BER (after)',
|
|
'ONU RX Optical dBm (before)', 'ONU RX Optical dBm (after)',
|
|
'ONU TX Optical dBm (before)', 'ONU TX Optical dBm (after)',
|
|
'After sample time', 'Verdict', 'Fetch error',
|
|
];
|
|
const num = (n) => (n === null || n === undefined ? '' : n);
|
|
const rows = state.verify.comparisons.map((c) => ({
|
|
'ONU ID': c.onuId,
|
|
'Name': c.name || '',
|
|
'Address': c.address || '',
|
|
'Target version': c.target || '',
|
|
'Active version (after)': c.activeNow || '',
|
|
'Upgrade applied?': c.upgradeApplied === true ? 'yes' : c.upgradeApplied === false ? 'no' : 'unknown',
|
|
'FEC health (before)': c.fecBeforeLabel || '',
|
|
'FEC health (after)': c.fecAfterLabel || '',
|
|
'ONU RX Pre-FEC BER (before)': num(c.onuPreBefore),
|
|
'ONU RX Pre-FEC BER (after)': num(c.onuPreAfter),
|
|
'ONU RX Post-FEC BER (before)': num(c.onuPostBefore),
|
|
'ONU RX Post-FEC BER (after)': num(c.onuPostAfter),
|
|
'OLT RX Pre-FEC BER (before)': num(c.oltPreBefore),
|
|
'OLT RX Pre-FEC BER (after)': num(c.oltPreAfter),
|
|
'OLT RX Post-FEC BER (before)': num(c.oltPostBefore),
|
|
'OLT RX Post-FEC BER (after)': num(c.oltPostAfter),
|
|
'ONU RX Optical dBm (before)': num(c.rxBefore),
|
|
'ONU RX Optical dBm (after)': num(c.rxAfter),
|
|
'ONU TX Optical dBm (before)': num(c.txBefore),
|
|
'ONU TX Optical dBm (after)': num(c.txAfter),
|
|
'After sample time': c.sampleTime || '',
|
|
'Verdict': c.verdict,
|
|
'Fetch error': c.afterError ? c.afterError.message : '',
|
|
}));
|
|
|
|
// Derive a filename hint from the source CSV: keep its trailing
|
|
// descriptor (e.g. "EV05120R-task-12onus") so the verify file
|
|
// sits next to the original lexically when sorted.
|
|
const baseName = (state.verify.sourcePath || '')
|
|
.split(/[/\\]/).pop()
|
|
.replace(/\.csv$/i, '')
|
|
.replace(/^pon-upgrade-/, '');
|
|
|
|
const res = await window.api.saveCsvFile({
|
|
rows,
|
|
headers,
|
|
filenameHint: baseName || 'comparison',
|
|
prefix: 'pon-verify',
|
|
});
|
|
if (res.ok) {
|
|
$('#verify-save-status').textContent = `Comparison saved → ${res.data.path}`;
|
|
$('#verify-status').textContent =
|
|
`Compared ${rows.length} ONUs from ${state.verify.sourcePath}.`;
|
|
} else {
|
|
$('#verify-save-status').textContent = `Save failed: ${res.error?.message}`;
|
|
}
|
|
}
|
|
|
|
// -------- Utility --------
|
|
function escapeHtml(s) {
|
|
if (s === null || s === undefined) return '';
|
|
return String(s)
|
|
.replace(/&/g, '&')
|
|
.replace(/</g, '<')
|
|
.replace(/>/g, '>')
|
|
.replace(/"/g, '"')
|
|
.replace(/'/g, ''');
|
|
}
|