|
|
import assert from 'node:assert/strict';
|
|
|
import { readFile } from 'node:fs/promises';
|
|
|
import vm from 'node:vm';
|
|
|
|
|
|
const source = await readFile(new URL('../public/cloud/admin-fabric.js', import.meta.url), 'utf8');
|
|
|
|
|
|
class Node {
|
|
|
constructor(tag = 'div') {
|
|
|
this.tagName = tag.toUpperCase(); this.children = []; this.dataset = {};
|
|
|
this.listeners = new Map(); this.attributes = new Map(); this.hidden = false;
|
|
|
this.disabled = false; this.value = ''; this.className = ''; this._text = '';
|
|
|
const classes = new Set();
|
|
|
this.classList = {
|
|
|
add: (...values) => values.forEach(value => classes.add(value)),
|
|
|
remove: (...values) => values.forEach(value => classes.delete(value)),
|
|
|
contains: value => classes.has(value),
|
|
|
};
|
|
|
}
|
|
|
set textContent(value) { this._text = String(value); this.children = []; }
|
|
|
get textContent() { return this._text + this.children.map(child => child.textContent).join(''); }
|
|
|
set innerHTML(_) { throw new Error('Fabric content must never be interpreted as HTML.'); }
|
|
|
get options() { return this.children; }
|
|
|
append(...values) { this.children.push(...values); }
|
|
|
replaceChildren(...values) { this._text = ''; this.children = []; this.append(...values); }
|
|
|
setAttribute(key, value) { this.attributes.set(key, String(value)); }
|
|
|
removeAttribute(key) { this.attributes.delete(key); }
|
|
|
getAttribute(key) { return this.attributes.get(key) ?? null; }
|
|
|
addEventListener(key, handler) {
|
|
|
const handlers = this.listeners.get(key) || []; handlers.push(handler);
|
|
|
this.listeners.set(key, handlers);
|
|
|
}
|
|
|
dispatch(key, fields = {}) {
|
|
|
const event = { target: this, currentTarget: this, preventDefault() {}, ...fields };
|
|
|
for (const handler of this.listeners.get(key) || []) handler(event);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const flush = async () => { for (let index = 0; index < 30; index += 1) await Promise.resolve(); };
|
|
|
|
|
|
function workflow(stage, changes = {}) {
|
|
|
return {
|
|
|
stage, can_probe: stage === 'needs_probe' || stage === 'blocked',
|
|
|
can_apply: stage === 'ready_to_apply',
|
|
|
can_reconcile: stage === 'needs_reconcile' || stage === 'active'
|
|
|
|| stage === 'operation_running',
|
|
|
blocking_reasons: stage === 'blocked' ? ['firewall_owner_not_nftables'] : [],
|
|
|
action_mode: stage === 'ready_to_apply' ? 'apply'
|
|
|
: stage === 'needs_reconcile' || stage === 'active'
|
|
|
|| stage === 'operation_running' ? 'reconcile' : 'probe',
|
|
|
...changes,
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function region(id, stage, changes = {}) {
|
|
|
return {
|
|
|
region_id: id, region_code: id === 1 ? 'hk' : 'sg',
|
|
|
region_name: id === 1 ? 'Hong Kong' : 'Singapore', region_status: 'active',
|
|
|
host_count: 2, required_host_count: 2, ready_host_count: 0,
|
|
|
blocked_host_count: 0, hosts: [], ready: stage === 'active',
|
|
|
mapping_state: stage === 'active' ? 'active' : 'unconfigured',
|
|
|
fabric_state: stage === 'active' ? 'active' : null,
|
|
|
workflow: workflow(stage), plan_preview: null,
|
|
|
...changes,
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function preview(code = 'hk') {
|
|
|
return {
|
|
|
mode: 'automatic', fabric_id: `fabric-${code}`, fabric_region: code,
|
|
|
revision: 1, listen_port: 51820, overlay_cidr: '100.64.7.0/24', host_count: 2,
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function operation(status = 'running', kind = 'apply', changes = {}) {
|
|
|
return {
|
|
|
id: 'a'.repeat(32), kind, status,
|
|
|
started_at: 1791501000, updated_at: 1791501010,
|
|
|
finished_at: ['succeeded', 'failed', 'uncertain', 'interrupted'].includes(status)
|
|
|
? 1791501020 : null,
|
|
|
...changes,
|
|
|
};
|
|
|
}
|
|
|
|
|
|
function fixture(initialRegions, canManage = true) {
|
|
|
const ids = [...source.matchAll(/byId\('([^']+)'\)/g)].map(match => match[1]);
|
|
|
ids.push('fabric-detect-hosts', 'fabric-auto-configure', 'fabric-reconcile');
|
|
|
const nodes = Object.fromEntries([...new Set(ids)].map(id => [id,
|
|
|
new Node(id === 'fabric-region-select' ? 'select' : 'div')]));
|
|
|
const actions = ['probe', 'apply', 'reconcile'].map(action => {
|
|
|
const id = { probe: 'fabric-detect-hosts', apply: 'fabric-auto-configure',
|
|
|
reconcile: 'fabric-reconcile' }[action];
|
|
|
const button = nodes[id]; button.tagName = 'BUTTON';
|
|
|
button.dataset.fabricPrimaryAction = ''; button.dataset.fabricAction = action;
|
|
|
return button;
|
|
|
});
|
|
|
const steps = ['select', 'probe', 'apply', 'reconcile'].map(step => {
|
|
|
const item = new Node('li'); item.dataset.fabricWizardStep = step; return item;
|
|
|
});
|
|
|
const root = new Node('main'); root.dataset.canManage = canManage ? '1' : '0';
|
|
|
const document = {
|
|
|
getElementById: id => nodes[id] || null,
|
|
|
createElement: tag => new Node(tag),
|
|
|
querySelector: selector => selector === '[data-admin-fabric]' ? root : null,
|
|
|
querySelectorAll: selector => selector === '[data-fabric-primary-action]'
|
|
|
? actions : selector === '[data-fabric-wizard-step]' ? steps : [],
|
|
|
};
|
|
|
let now = 0; let clockOffset = 0; let timerId = 0;
|
|
|
const timers = new Map(); const requests = [];
|
|
|
const setTimeout = (callback, delay) => {
|
|
|
const id = ++timerId; timers.set(id, { callback, due: now + delay }); return id;
|
|
|
};
|
|
|
const clearTimeout = id => timers.delete(id);
|
|
|
class ClockDate extends Date {
|
|
|
static now() { return 1791501100000 + now + clockOffset; }
|
|
|
}
|
|
|
const window = { ADMIN_CSRF_TOKEN: 'csrf-test', setTimeout, clearTimeout };
|
|
|
const fetch = (url, options) => new Promise((resolve, reject) => {
|
|
|
const request = { url: String(url), options, resolve, reject, settled: false };
|
|
|
requests.push(request);
|
|
|
options.signal.addEventListener('abort', () => {
|
|
|
if (!request.settled) { request.settled = true; reject(new Error('aborted')); }
|
|
|
});
|
|
|
});
|
|
|
vm.runInNewContext(source, { document, window, fetch, AbortController, Date: ClockDate, console },
|
|
|
{ filename: 'admin-fabric.js' });
|
|
|
|
|
|
async function respond(request, payload, status = 200) {
|
|
|
assert.ok(request, 'Expected an outstanding Fabric request.');
|
|
|
request.settled = true;
|
|
|
request.resolve({ ok: status >= 200 && status < 300, status, json: async () => payload });
|
|
|
await flush();
|
|
|
}
|
|
|
async function reject(request, error = new TypeError('network failed')) {
|
|
|
assert.ok(request, 'Expected an outstanding Fabric request.');
|
|
|
request.settled = true; request.reject(error); await flush();
|
|
|
}
|
|
|
async function advance(milliseconds) {
|
|
|
const end = now + milliseconds;
|
|
|
for (;;) {
|
|
|
const next = [...timers.entries()].filter(([, item]) => item.due <= end)
|
|
|
.sort((left, right) => left[1].due - right[1].due)[0];
|
|
|
if (!next) break;
|
|
|
now = next[1].due; timers.delete(next[0]); next[1].callback(); await flush();
|
|
|
}
|
|
|
now = end; await flush();
|
|
|
}
|
|
|
return { nodes, actions, steps, requests, respond, reject, advance, initialRegions,
|
|
|
setClockOffset(value) { clockOffset = value; } };
|
|
|
}
|
|
|
|
|
|
// The server workflow, not browser-invented conditions, owns every enabled
|
|
|
// action and the read-only plan rendered after a successful fresh probe.
|
|
|
{
|
|
|
const test = fixture([region(1, 'needs_probe')]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
assert.equal(test.nodes['fabric-detect-hosts'].disabled, false);
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, true);
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, true);
|
|
|
test.nodes['fabric-detect-hosts'].dispatch('click'); await flush();
|
|
|
const mutation = test.requests[1];
|
|
|
assert.equal(mutation.url, '/api/v1/admin/fabric/regions/1/probe');
|
|
|
assert.equal(mutation.options.body, '{}');
|
|
|
assert.equal(mutation.options.headers['X-CSRF-Token'], 'csrf-test');
|
|
|
const ready = region(1, 'ready_to_apply', { ready_host_count: 2,
|
|
|
plan_preview: preview() });
|
|
|
await test.respond(mutation, { region: ready, engine_available: true });
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, false);
|
|
|
assert.equal(test.nodes['fabric-plan-id'].textContent, 'fabric-hk');
|
|
|
assert.equal(test.nodes['fabric-plan-overlay'].textContent, '100.64.7.0/24');
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /检测通过/);
|
|
|
}
|
|
|
|
|
|
// rp_filter diagnostics expose the bounded values that affect the policy
|
|
|
// decision. Alma/RHEL strict defaults and the public underlay stay visible as
|
|
|
// preserved OS/operator policy; an absent owned Fabric interface is pending
|
|
|
// automatic configuration, not a failed vnet/tap probe.
|
|
|
{
|
|
|
const host = {
|
|
|
host_id: '1', host_name: 'alma', engine_region: 'hk', host_enabled: true,
|
|
|
scheduler_state: 'active', pool_name: 'hk', pool_status: 'active',
|
|
|
line_name: 'Hong Kong', line_status: 'active', platform_ready: true,
|
|
|
configured: true, reachable: true, endpoint_ip: '203.0.113.11',
|
|
|
endpoint_source: 'ssh_host_ipv4', probe_checked: true, probed_at: 1770000100,
|
|
|
fabric_member: false, fabric_state: 'unchecked', transport_verified: false,
|
|
|
observed_revision: 0, readiness_state: 'ready', reasons: [],
|
|
|
capabilities: {
|
|
|
ip_forward: 1, rp_filter: 0, rp_filter_all: 0,
|
|
|
rp_filter_default: 1, rp_filter_default_effective: 1,
|
|
|
underlay_interface: 'br0', rp_filter_underlay_raw: 1,
|
|
|
rp_filter_underlay_effective: 1, rp_filter_fabric_raw: null,
|
|
|
rp_filter_fabric_effective: null, public_selector: 'bridge:br0',
|
|
|
public_verified: true, interfaces: ['br0', 'vnet3', 'vnet10'],
|
|
|
},
|
|
|
};
|
|
|
const strictFabricHost = {
|
|
|
...host, host_id: '2', host_name: 'existing-strict',
|
|
|
capabilities: {
|
|
|
...host.capabilities, rp_filter_fabric_raw: 1,
|
|
|
rp_filter_fabric_effective: 1,
|
|
|
},
|
|
|
};
|
|
|
const test = fixture([region(1, 'ready_to_apply', {
|
|
|
host_count: 2, required_host_count: 2, ready_host_count: 2,
|
|
|
hosts: [host, strictFabricHost], plan_preview: preview(),
|
|
|
})]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
const copy = test.nodes['fabric-hosts-body'].textContent;
|
|
|
assert.match(copy, /rp_filter all:raw 0 · effective 0(关闭,兼容)/);
|
|
|
assert.match(copy, /rp_filter default:raw 1 · effective 1(strict,发行版默认保留)/);
|
|
|
assert.match(copy, /Endpoint br0:raw 1 · effective 1(strict,公网接口保留)/);
|
|
|
assert.match(copy, /wg-fabric0:未创建(自动配置时由平台设为 2)/);
|
|
|
assert.match(copy, /wg-fabric0:raw 1 · effective 1(strict,自动配置将收敛为 2)/);
|
|
|
assert.match(copy, /仅平台自有 wg-fabric0 与 VPC bridge 设为 2/);
|
|
|
assert.doesNotMatch(copy, /vnet3|vnet10/);
|
|
|
}
|
|
|
|
|
|
// Mixed-version responses keep the legacy all value useful without claiming
|
|
|
// that omitted detailed evidence was checked.
|
|
|
{
|
|
|
const host = {
|
|
|
host_id: '1', host_name: 'legacy', engine_region: 'hk',
|
|
|
capabilities: { ip_forward: 1, rp_filter: 2, underlay_interface: 'br0' },
|
|
|
};
|
|
|
const test = fixture([region(1, 'needs_probe', { host_count: 1, hosts: [host] })]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
const copy = test.nodes['fabric-hosts-body'].textContent;
|
|
|
assert.match(copy, /rp_filter all:raw 2 · effective 2(loose,兼容)/);
|
|
|
assert.match(copy, /rp_filter default:未检测/);
|
|
|
assert.match(copy, /Endpoint br0:未检测/);
|
|
|
assert.match(copy, /wg-fabric0:未检测/);
|
|
|
}
|
|
|
|
|
|
// A persisted Engine failure phase is shown as historical Fabric evidence,
|
|
|
// not as the outcome of the fresh capability probe rendered beside it. Older
|
|
|
// Engine responses without the optional field remain quiet.
|
|
|
{
|
|
|
const failedHost = {
|
|
|
host_id: '1', host_name: 'failed', engine_region: 'hk',
|
|
|
fabric_member: true, fabric_state: 'uncertain', transport_verified: false,
|
|
|
observed_revision: 0, readiness_state: 'uncertain',
|
|
|
last_error_code: 'fabric_remote_command_failed', last_error_phase: 'apply',
|
|
|
reasons: ['fabric_remote_command_failed'], capabilities: {},
|
|
|
};
|
|
|
const legacyHost = { ...failedHost, host_id: '2', host_name: 'legacy' };
|
|
|
delete legacyHost.last_error_phase;
|
|
|
const staleSuccessHost = {
|
|
|
...failedHost, host_id: '3', host_name: 'active', fabric_state: 'active',
|
|
|
transport_verified: true, last_error_code: null, last_error_phase: 'apply',
|
|
|
reasons: [],
|
|
|
};
|
|
|
const test = fixture([region(1, 'needs_reconcile', {
|
|
|
hosts: [failedHost, legacyHost, staleSuccessHost],
|
|
|
plan_preview: { ...preview(), mode: 'existing' },
|
|
|
})]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
const copy = test.nodes['fabric-hosts-body'].textContent;
|
|
|
assert.equal((copy.match(/上次 Fabric 失败阶段:/g) || []).length, 1);
|
|
|
assert.match(copy, /上次 Fabric 失败阶段:apply(应用)/);
|
|
|
assert.match(copy, /宿主机远程配置命令失败/);
|
|
|
assert.doesNotMatch(copy, /本次探测失败阶段/);
|
|
|
}
|
|
|
|
|
|
// Double activation emits one apply only. A 200 response that has not reached
|
|
|
// the authoritative active stage is never painted as success and advances to
|
|
|
// the server-selected reconcile step.
|
|
|
{
|
|
|
const ready = region(1, 'ready_to_apply', { plan_preview: preview() });
|
|
|
const test = fixture([ready]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click');
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 1);
|
|
|
const pending = region(1, 'needs_reconcile', { plan_preview: { ...preview(), mode: 'existing' } });
|
|
|
await test.respond(test.requests[1], { regions: [pending], engine_available: true });
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /尚未 active/);
|
|
|
assert.ok(!test.nodes['fabric-notice'].className.includes('is-success'));
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, true);
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, false);
|
|
|
}
|
|
|
|
|
|
// Apply/reconcile host writes are accepted as asynchronous operations. The
|
|
|
// page correlates node evidence to the root operation id, exposes only fixed
|
|
|
// labels, permits only same-operation reconcile recovery, and polls the
|
|
|
// existing read endpoint until a terminal state is observed.
|
|
|
{
|
|
|
const ready = region(1, 'ready_to_apply', { plan_preview: preview() });
|
|
|
const test = fixture([ready]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
const rootOperation = operation('running');
|
|
|
const matchedHost = {
|
|
|
host_id: '1', host_name: 'matched', fabric_member: true,
|
|
|
fabric_state: 'applying', readiness_state: 'uncertain', capabilities: {},
|
|
|
operation: {
|
|
|
id: rootOperation.id, status: 'running', phase: 'apply',
|
|
|
checkpoint: 'future_untrusted_checkpoint', reason: 'future_untrusted_reason',
|
|
|
started_at: 1791501000, updated_at: 1791501010, finished_at: null,
|
|
|
},
|
|
|
};
|
|
|
const staleHost = {
|
|
|
...matchedHost, host_id: '2', host_name: 'stale',
|
|
|
operation: { ...matchedHost.operation, id: 'b'.repeat(32), checkpoint: 'nft_install' },
|
|
|
};
|
|
|
const running = region(1, 'operation_running', {
|
|
|
operation: rootOperation, hosts: [matchedHost, staleHost],
|
|
|
plan_preview: { ...preview(), mode: 'existing' },
|
|
|
});
|
|
|
await test.respond(test.requests[1], {
|
|
|
operation: rootOperation, regions: [running], engine_available: true,
|
|
|
}, 202);
|
|
|
assert.match(test.nodes['fabric-notice'].textContent,
|
|
|
new RegExp('已受理 operation ' + rootOperation.id));
|
|
|
assert.equal(test.nodes['fabric-detect-hosts'].disabled, true);
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, true);
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, false);
|
|
|
const runningCopy = test.nodes['fabric-hosts-body'].textContent;
|
|
|
assert.equal((runningCopy.match(/本轮 operation:/g) || []).length, 1);
|
|
|
assert.match(runningCopy, /本轮检查点:未知检查点/);
|
|
|
assert.match(runningCopy, /本轮原因:未识别原因(已隐藏原始值)/);
|
|
|
assert.doesNotMatch(runningCopy, /future_untrusted/);
|
|
|
|
|
|
test.nodes['fabric-reconcile'].dispatch('click');
|
|
|
test.nodes['fabric-reconcile'].dispatch('click'); await flush();
|
|
|
assert.equal(test.requests.filter(request =>
|
|
|
request.options.method === 'POST').length, 2);
|
|
|
assert.equal(test.requests[2].url,
|
|
|
'/api/v1/admin/fabric/regions/1/reconcile');
|
|
|
assert.equal(test.actions.every(button => button.disabled), true);
|
|
|
await test.respond(test.requests[2], {
|
|
|
operation: rootOperation, regions: [running], engine_available: true,
|
|
|
}, 202);
|
|
|
assert.equal(test.nodes['fabric-detect-hosts'].disabled, true);
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, true);
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, false);
|
|
|
|
|
|
await test.advance(2000);
|
|
|
assert.equal(test.requests[3].url, '/api/v1/admin/fabric');
|
|
|
await test.respond(test.requests[3], { regions: [running], engine_available: true });
|
|
|
await test.advance(2000);
|
|
|
const completedOperation = operation('succeeded');
|
|
|
const completed = region(1, 'needs_reconcile', {
|
|
|
operation: completedOperation,
|
|
|
plan_preview: { ...preview(), mode: 'existing' },
|
|
|
workflow: workflow('needs_reconcile', { can_probe: true }),
|
|
|
});
|
|
|
await test.respond(test.requests[4], { regions: [completed], engine_available: true });
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /宿主机任务已成功/);
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /完成最终回读确认/);
|
|
|
assert.doesNotMatch(test.nodes['fabric-notice'].textContent, /重新检测/,
|
|
|
'A succeeded apply must not direct the administrator back to host detection.');
|
|
|
assert.equal(test.nodes['fabric-detect-hosts'].disabled, false,
|
|
|
'A succeeded apply may retain the optional read-only host detection action.');
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, false,
|
|
|
'A succeeded apply must advance to the explicit final reconcile.');
|
|
|
assert.match(test.nodes['fabric-readback-summary'].textContent,
|
|
|
new RegExp(completedOperation.id));
|
|
|
assert.match(test.nodes['fabric-readback-summary'].textContent, /succeeded(成功)/);
|
|
|
assert.match(test.nodes['fabric-readback-summary'].textContent,
|
|
|
new RegExp('journalctl --utc -u virt-cloud-fabric-apply-'
|
|
|
+ completedOperation.id + '\\.service --no-pager'));
|
|
|
}
|
|
|
|
|
|
// A completed asynchronous reconcile is not the final region mapping
|
|
|
// publication. The server keeps the fixed plan at needs_reconcile (without
|
|
|
// sending the wizard back to a redundant host probe), and only a new explicit
|
|
|
// reconcile followed by an authoritative load may advance the UI to active.
|
|
|
{
|
|
|
const pending = region(1, 'needs_reconcile', {
|
|
|
plan_preview: { ...preview(), mode: 'existing' },
|
|
|
});
|
|
|
const test = fixture([pending]);
|
|
|
await test.respond(test.requests[0], { regions: [pending], engine_available: true });
|
|
|
test.nodes['fabric-reconcile'].dispatch('click'); await flush();
|
|
|
|
|
|
const runningOperation = operation('running', 'reconcile', { id: 'c'.repeat(32) });
|
|
|
const running = region(1, 'operation_running', {
|
|
|
operation: runningOperation,
|
|
|
plan_preview: { ...preview(), mode: 'existing' },
|
|
|
});
|
|
|
await test.respond(test.requests[1], {
|
|
|
operation: runningOperation, regions: [running], engine_available: true,
|
|
|
}, 202);
|
|
|
|
|
|
await test.advance(2000);
|
|
|
assert.equal(test.requests[2].url, '/api/v1/admin/fabric');
|
|
|
const succeededOperation = {
|
|
|
...runningOperation, status: 'succeeded', finished_at: runningOperation.updated_at + 10,
|
|
|
};
|
|
|
const awaitingFinalReadback = region(1, 'needs_reconcile', {
|
|
|
operation: succeededOperation,
|
|
|
plan_preview: { ...preview(), mode: 'existing' },
|
|
|
workflow: workflow('needs_reconcile', { can_probe: true }),
|
|
|
});
|
|
|
await test.respond(test.requests[2], {
|
|
|
regions: [awaitingFinalReadback], engine_available: true,
|
|
|
});
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /完成最终回读确认/);
|
|
|
assert.match(test.nodes['fabric-wizard-stage'].textContent, /配置需要重新核对/);
|
|
|
assert.equal(test.nodes['fabric-step-probe-state'].textContent, '检测已通过');
|
|
|
assert.equal(test.nodes['fabric-detect-hosts'].disabled, false,
|
|
|
'A succeeded reconcile may retain the optional read-only host detection action.');
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, false,
|
|
|
'The server-selected final reconcile must remain available.');
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 1,
|
|
|
'Polling a succeeded reconcile must not publish the mapping automatically.');
|
|
|
|
|
|
test.nodes['fabric-reconcile'].dispatch('click'); await flush();
|
|
|
assert.equal(test.requests[3].url, '/api/v1/admin/fabric/regions/1/reconcile');
|
|
|
await test.respond(test.requests[3], {});
|
|
|
assert.equal(test.requests[4].url, '/api/v1/admin/fabric');
|
|
|
assert.equal(test.requests[4].options.method, 'GET');
|
|
|
const active = region(1, 'active', {
|
|
|
operation: succeededOperation,
|
|
|
plan_preview: { ...preview(), mode: 'existing' },
|
|
|
});
|
|
|
await test.respond(test.requests[4], { regions: [active], engine_available: true });
|
|
|
assert.match(test.nodes['fabric-wizard-stage'].textContent, /地区私网已就绪/);
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /重新核对并通过全部门禁/);
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, false);
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 2);
|
|
|
}
|
|
|
|
|
|
// A missing or replaced authoritative operation cannot leave the browser
|
|
|
// polling a stale id forever. It stops the old read-only loop, marks the
|
|
|
// outcome unknown, and never adopts or POSTs the replacement operation.
|
|
|
{
|
|
|
const rootOperation = operation('running');
|
|
|
const running = region(1, 'operation_running', {
|
|
|
operation: rootOperation, plan_preview: { ...preview(), mode: 'existing' },
|
|
|
});
|
|
|
const test = fixture([running]);
|
|
|
await test.respond(test.requests[0], { regions: [running], engine_available: true });
|
|
|
await test.advance(2000);
|
|
|
const replacement = operation('running', 'reconcile', { id: 'b'.repeat(32) });
|
|
|
const replaced = region(1, 'operation_running', {
|
|
|
operation: replacement, plan_preview: { ...preview(), mode: 'existing' },
|
|
|
});
|
|
|
await test.respond(test.requests[1], { regions: [replaced], engine_available: true });
|
|
|
assert.match(test.nodes['fabric-notice'].textContent,
|
|
|
new RegExp('operation ' + rootOperation.id + ' 已无法与服务端当前回读对应'));
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /不会重复提交/);
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 0);
|
|
|
await test.advance(10000);
|
|
|
assert.equal(test.requests.length, 2);
|
|
|
}
|
|
|
|
|
|
// An empty successful region projection is authoritative too. If the region
|
|
|
// was removed while its operation was running, polling must stop instead of
|
|
|
// retaining the stale in-memory row forever.
|
|
|
{
|
|
|
const rootOperation = operation('running');
|
|
|
const running = region(1, 'operation_running', {
|
|
|
operation: rootOperation, plan_preview: { ...preview(), mode: 'existing' },
|
|
|
});
|
|
|
const test = fixture([running]);
|
|
|
await test.respond(test.requests[0], { regions: [running], engine_available: true });
|
|
|
await test.advance(2000);
|
|
|
await test.respond(test.requests[1], { regions: [], engine_available: true });
|
|
|
assert.match(test.nodes['fabric-notice'].textContent,
|
|
|
new RegExp('operation ' + rootOperation.id + ' 已无法与服务端当前回读对应'));
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 0);
|
|
|
await test.advance(10000);
|
|
|
assert.equal(test.requests.length, 2);
|
|
|
}
|
|
|
|
|
|
// A region change while a request is in flight cannot redirect the returned
|
|
|
// projection into the newly selected region or redraw that region as active.
|
|
|
{
|
|
|
const first = region(1, 'ready_to_apply', { plan_preview: preview() });
|
|
|
const second = region(2, 'needs_probe');
|
|
|
const test = fixture([first, second]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
test.nodes['fabric-region-select'].value = '2';
|
|
|
test.nodes['fabric-region-select'].dispatch('change'); await flush();
|
|
|
await test.respond(test.requests[1], { regions: [region(1, 'active'), second], engine_available: true });
|
|
|
assert.equal(test.nodes['fabric-region-select'].value, '2');
|
|
|
assert.match(test.nodes['fabric-wizard-stage'].textContent, /等待检测/);
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /后来选择的地区/);
|
|
|
}
|
|
|
|
|
|
// A write timeout is an unknown outcome. It releases the in-flight lock but
|
|
|
// prevents replay of automatic apply from the stale preflight projection.
|
|
|
{
|
|
|
const ready = region(1, 'ready_to_apply', { plan_preview: preview() });
|
|
|
const test = fixture([ready]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
await test.advance(240000);
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /结果尚未确认/);
|
|
|
assert.match(test.nodes['fabric-wizard-stage'].textContent, /尚未确认/);
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, true);
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, true,
|
|
|
'A lost receipt must not open another host-writing reconcile request.');
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 1,
|
|
|
'An unknown apply outcome must never be replayed from stale browser state.');
|
|
|
test.nodes['fabric-reconcile'].dispatch('click'); await flush();
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 1);
|
|
|
await test.advance(5000);
|
|
|
assert.equal(test.requests[2].url, '/api/v1/admin/fabric');
|
|
|
assert.equal(test.requests[2].options.method, 'GET');
|
|
|
const finished = operation('succeeded');
|
|
|
await test.respond(test.requests[2], {
|
|
|
regions: [region(1, 'active', { operation: finished })], engine_available: true,
|
|
|
});
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /成功并通过全部门禁/);
|
|
|
}
|
|
|
|
|
|
// Once a write has been dispatched, a non-HTTP fetch failure and every HTTP
|
|
|
// 5xx response are unknown outcomes. An explicit 4xx rejection remains
|
|
|
// definitive and does not invent an in-flight apply.
|
|
|
{
|
|
|
const ready = region(1, 'ready_to_apply', { plan_preview: preview() });
|
|
|
const test = fixture([ready]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
await test.reject(test.requests[1]);
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /网络连接中断.*尚未确认/);
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, true);
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, true);
|
|
|
}
|
|
|
{
|
|
|
const ready = region(1, 'ready_to_apply', { plan_preview: preview() });
|
|
|
const test = fixture([ready]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
await test.respond(test.requests[1], { detail: '网关等待引擎超时' }, 504);
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /504.*结果尚未确认/);
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, true,
|
|
|
'A gateway timeout must never leave stale automatic apply available.');
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, true,
|
|
|
'A gateway timeout must recover only through GET, without enabling another POST.');
|
|
|
}
|
|
|
{
|
|
|
const ready = region(1, 'ready_to_apply', { plan_preview: preview() });
|
|
|
const test = fixture([ready]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
await test.respond(test.requests[1], { detail: '地区宿主机集合已经变化' }, 409);
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /集合已经变化/);
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, false,
|
|
|
'A definitive HTTP rejection must not be converted into an unknown write outcome.');
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, true);
|
|
|
await test.advance(10000);
|
|
|
assert.equal(test.requests.length, 2, 'A definitive 409 must not start lost-receipt GET recovery.');
|
|
|
}
|
|
|
|
|
|
// Unknown outcomes are isolated by region. A later successful action for a
|
|
|
// different region must not clear the first region's stale-write guard.
|
|
|
{
|
|
|
const first = region(1, 'ready_to_apply', { plan_preview: preview() });
|
|
|
const second = region(2, 'ready_to_apply', { plan_preview: preview('sg') });
|
|
|
const test = fixture([first, second]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions, engine_available: true });
|
|
|
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
await test.reject(test.requests[1]);
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, true);
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, true);
|
|
|
|
|
|
test.nodes['fabric-region-select'].value = '2';
|
|
|
test.nodes['fabric-region-select'].dispatch('change'); await flush();
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, false);
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
await test.respond(test.requests[2], {
|
|
|
regions: [first, region(2, 'active', { plan_preview: { ...preview('sg'), mode: 'existing' } })],
|
|
|
engine_available: true,
|
|
|
});
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /通过权威回读/);
|
|
|
|
|
|
test.nodes['fabric-region-select'].value = '1';
|
|
|
test.nodes['fabric-region-select'].dispatch('change'); await flush();
|
|
|
assert.match(test.nodes['fabric-wizard-stage'].textContent, /尚未确认/);
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, true,
|
|
|
'A successful action in region 2 must not unlock region 1 stale apply.');
|
|
|
assert.equal(test.nodes['fabric-reconcile'].disabled, true,
|
|
|
'Region 1 must keep its own GET-only lost-receipt guard.');
|
|
|
}
|
|
|
|
|
|
// The real gateway-502 case has no accepted-operation receipt. GET may still
|
|
|
// show an old failed id while admission waits behind a host observer. It must
|
|
|
// neither finish this request nor release writes. A later new id resumes the
|
|
|
// normal exact-id poller, without generating another POST.
|
|
|
{
|
|
|
const old = operation('failed', 'reconcile');
|
|
|
const initial = region(1, 'needs_reconcile', { operation: old });
|
|
|
const test = fixture([initial]);
|
|
|
await test.respond(test.requests[0], { regions: [initial], engine_available: true });
|
|
|
test.nodes['fabric-reconcile'].dispatch('click'); await flush();
|
|
|
await test.respond(test.requests[1], { detail: 'gateway failed' }, 502);
|
|
|
assert.equal(test.actions.every(button => button.disabled), true);
|
|
|
await test.advance(4999);
|
|
|
assert.equal(test.requests.length, 2, 'Lost-receipt GET recovery has a 5-second interval.');
|
|
|
await test.advance(1);
|
|
|
await test.respond(test.requests[2], { regions: [initial], engine_available: true });
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /不会把旧任务状态当成本轮结果/);
|
|
|
assert.equal(test.actions.every(button => button.disabled), true);
|
|
|
|
|
|
const fresh = operation('running', 'reconcile', {
|
|
|
id: 'b'.repeat(32), started_at: old.updated_at + 1,
|
|
|
});
|
|
|
const running = region(1, 'operation_running', { operation: fresh });
|
|
|
await test.advance(5000);
|
|
|
await test.respond(test.requests[3], { regions: [running], engine_available: true });
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /只读发现 operation b{32}/);
|
|
|
assert.equal(test.actions.every(button => button.disabled), true,
|
|
|
'Discovering an in-flight job must not enable another host write.');
|
|
|
await test.advance(2000);
|
|
|
const succeeded = region(1, 'active', {
|
|
|
operation: { ...fresh, status: 'succeeded', finished_at: old.updated_at + 20 },
|
|
|
});
|
|
|
await test.respond(test.requests[4], { regions: [succeeded], engine_available: true });
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /成功并通过全部门禁/);
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 1);
|
|
|
await test.advance(10000);
|
|
|
assert.equal(test.requests.length, 5);
|
|
|
}
|
|
|
|
|
|
// Reconcile is allowed to resume an already-known unsettled id. An old
|
|
|
// terminal id or a new wrong-kind/older operation is not a recovered receipt.
|
|
|
{
|
|
|
const old = operation('running', 'apply');
|
|
|
const initial = region(1, 'operation_running', { operation: old });
|
|
|
const test = fixture([initial]);
|
|
|
await test.respond(test.requests[0], { regions: [initial], engine_available: true });
|
|
|
test.nodes['fabric-reconcile'].dispatch('click'); await flush();
|
|
|
await test.reject(test.requests[1]);
|
|
|
await test.advance(5000);
|
|
|
await test.respond(test.requests[2], { regions: [initial], engine_available: true });
|
|
|
assert.match(test.nodes['fabric-notice'].textContent,
|
|
|
new RegExp('只读发现 operation ' + old.id));
|
|
|
assert.equal(test.actions.every(button => button.disabled), true);
|
|
|
await test.advance(2000);
|
|
|
await test.respond(test.requests[3], {
|
|
|
regions: [region(1, 'needs_reconcile', {
|
|
|
operation: { ...old, status: 'failed', finished_at: old.updated_at + 10 },
|
|
|
})], engine_available: true,
|
|
|
});
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /failed(失败)/);
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 1);
|
|
|
}
|
|
|
|
|
|
// A backwards client clock cannot evade the independent finite read count.
|
|
|
{
|
|
|
const old = operation('failed', 'reconcile');
|
|
|
const initial = region(1, 'needs_reconcile', { operation: old });
|
|
|
const test = fixture([initial]);
|
|
|
await test.respond(test.requests[0], { regions: [initial], engine_available: true });
|
|
|
test.nodes['fabric-reconcile'].dispatch('click'); await flush();
|
|
|
await test.respond(test.requests[1], {}, 502);
|
|
|
test.setClockOffset(-86400000);
|
|
|
for (let index = 0; index < 36; index += 1) {
|
|
|
await test.advance(5000);
|
|
|
await test.respond(test.requests.at(-1), { regions: [initial], engine_available: true });
|
|
|
}
|
|
|
await test.advance(5000);
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /只读恢复已达到上限/);
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'GET').length, 37,
|
|
|
'Only the initial load plus at most 36 recovery GETs may run.');
|
|
|
const reads = test.requests.length;
|
|
|
await test.advance(60000);
|
|
|
assert.equal(test.requests.length, reads);
|
|
|
assert.equal(test.actions.every(button => button.disabled), true);
|
|
|
}
|
|
|
|
|
|
// Selection changes cannot redirect a recovered receipt or unlock another
|
|
|
// unknown region. A late origin-region GET remains a read-only origin result.
|
|
|
{
|
|
|
const first = region(1, 'needs_reconcile', { operation: operation('failed', 'reconcile') });
|
|
|
const second = region(2, 'ready_to_apply', { plan_preview: preview('sg') });
|
|
|
const test = fixture([first, second]);
|
|
|
await test.respond(test.requests[0], { regions: [first, second], engine_available: true });
|
|
|
test.nodes['fabric-reconcile'].dispatch('click'); await flush();
|
|
|
await test.respond(test.requests[1], {}, 502);
|
|
|
test.nodes['fabric-region-select'].value = '2';
|
|
|
test.nodes['fabric-region-select'].dispatch('change'); await flush();
|
|
|
await test.advance(5000);
|
|
|
const fresh = operation('running', 'reconcile', {
|
|
|
id: 'c'.repeat(32), started_at: first.operation.updated_at + 1,
|
|
|
});
|
|
|
await test.respond(test.requests[2], {
|
|
|
regions: [region(1, 'operation_running', { operation: fresh }), second], engine_available: true,
|
|
|
});
|
|
|
assert.equal(test.nodes['fabric-region-select'].value, '2');
|
|
|
assert.match(test.nodes['fabric-wizard-stage'].textContent, /检测通过/);
|
|
|
assert.equal(test.nodes['fabric-auto-configure'].disabled, false);
|
|
|
test.nodes['fabric-region-select'].value = '1';
|
|
|
test.nodes['fabric-region-select'].dispatch('change'); await flush();
|
|
|
assert.equal(test.actions.every(button => button.disabled), true);
|
|
|
assert.match(test.nodes['fabric-readback-summary'].textContent, /c{32}/);
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 1);
|
|
|
}
|
|
|
{
|
|
|
const old = operation('failed', 'reconcile');
|
|
|
const initial = region(1, 'needs_reconcile', { operation: old });
|
|
|
const test = fixture([initial]);
|
|
|
await test.respond(test.requests[0], { regions: [initial], engine_available: true });
|
|
|
test.nodes['fabric-reconcile'].dispatch('click'); await flush();
|
|
|
await test.respond(test.requests[1], {}, 502);
|
|
|
for (const invalid of [
|
|
|
{ ...old, status: 'succeeded', updated_at: old.updated_at + 20 },
|
|
|
operation('succeeded', 'apply', { id: 'b'.repeat(32), started_at: old.updated_at + 1 }),
|
|
|
operation('succeeded', 'reconcile', { id: 'b'.repeat(32), started_at: old.updated_at - 1 }),
|
|
|
operation('succeeded', 'reconcile', { id: 'b'.repeat(32), started_at: null }),
|
|
|
]) {
|
|
|
await test.advance(5000);
|
|
|
await test.respond(test.requests.at(-1), {
|
|
|
regions: [region(1, 'active', { operation: invalid })], engine_available: true,
|
|
|
});
|
|
|
assert.equal(test.actions.every(button => button.disabled), true);
|
|
|
assert.match(test.nodes['fabric-wizard-stage'].textContent, /尚未确认/);
|
|
|
assert.doesNotMatch(test.nodes['fabric-notice'].textContent, /成功并通过/);
|
|
|
}
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 1);
|
|
|
}
|
|
|
|
|
|
// Recovery remains bounded even if GET succeeds forever with a stale failed
|
|
|
// id. Missing regions, diagnostic engine-unavailable shells and read errors
|
|
|
// do not release the stale-write guard or silently trigger a second POST.
|
|
|
{
|
|
|
const old = operation('failed', 'reconcile');
|
|
|
const initial = region(1, 'needs_reconcile', { operation: old });
|
|
|
const test = fixture([initial]);
|
|
|
await test.respond(test.requests[0], { regions: [initial], engine_available: true });
|
|
|
test.nodes['fabric-reconcile'].dispatch('click'); await flush();
|
|
|
await test.respond(test.requests[1], {}, 502);
|
|
|
for (let index = 0; index < 35; index += 1) {
|
|
|
await test.advance(5000);
|
|
|
await test.respond(test.requests.at(-1), { regions: [initial], engine_available: true });
|
|
|
}
|
|
|
await test.advance(5000);
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /只读恢复已达到上限/);
|
|
|
assert.equal(test.actions.every(button => button.disabled), true);
|
|
|
const reads = test.requests.length;
|
|
|
await test.advance(60000);
|
|
|
assert.equal(test.requests.length, reads);
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 1);
|
|
|
}
|
|
|
{
|
|
|
const initial = region(1, 'ready_to_apply', { plan_preview: preview() });
|
|
|
const test = fixture([initial]);
|
|
|
await test.respond(test.requests[0], { regions: [initial], engine_available: true });
|
|
|
test.nodes['fabric-auto-configure'].dispatch('click'); await flush();
|
|
|
await test.reject(test.requests[1]);
|
|
|
await test.advance(5000);
|
|
|
await test.respond(test.requests[2], { regions: [], engine_available: true });
|
|
|
await test.advance(5000);
|
|
|
await test.respond(test.requests[3], {
|
|
|
regions: [region(1, 'active', { operation: operation('succeeded') })],
|
|
|
engine_available: false,
|
|
|
});
|
|
|
assert.equal(test.actions.every(button => button.disabled), true);
|
|
|
assert.doesNotMatch(test.nodes['fabric-notice'].textContent, /成功并通过/);
|
|
|
for (let index = 0; index < 11; index += 1) {
|
|
|
await test.advance(5000);
|
|
|
await test.reject(test.requests.at(-1));
|
|
|
}
|
|
|
assert.match(test.nodes['fabric-notice'].textContent, /状态连续读取失败/);
|
|
|
const reads = test.requests.length;
|
|
|
await test.advance(60000);
|
|
|
assert.equal(test.requests.length, reads);
|
|
|
assert.equal(test.requests.filter(request => request.options.method === 'POST').length, 1);
|
|
|
}
|
|
|
|
|
|
// The diagnostic HTTP-200 shell is not a successful load and never enables a
|
|
|
// write, even when a stale region projection is present.
|
|
|
{
|
|
|
const stale = region(1, 'engine_unavailable', {
|
|
|
workflow: workflow('engine_unavailable', { can_probe: false, action_mode: 'none',
|
|
|
blocking_reasons: ['engine_unavailable'] }),
|
|
|
});
|
|
|
const test = fixture([stale]);
|
|
|
await test.respond(test.requests[0], { regions: test.initialRegions,
|
|
|
engine_available: false, engine_error: 'Fabric 引擎状态暂时无法读取。' });
|
|
|
assert.equal(test.actions.every(button => button.disabled), true);
|
|
|
assert.ok(test.nodes['fabric-notice'].className.includes('is-error'));
|
|
|
}
|
|
|
|
|
|
console.log('Administrator Fabric wizard gating, bounded GET-only lost-receipt recovery, exact operation identity and timeout safety passed.');
|