mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
The map stacks' imagery, terrain and Google 3D factories move into the Cesium adapter (src/render/cesium/mapImagery.js, mapTerrain.js, google3d.js); the ./maps/imagery, ./maps/terrain and ./maps/3d exports point there. The catalog names its ion stacks by asset number, and the map source controller and default sources are Cesium-free: they build providers and switch imagery layers, terrain, tilesets and the globe's visibility through a map engine (src/maps/engine.js) that the Cesium adapter provides as it loads (mapEngine.js), through the application's renderer or the ./render/cesium/unbound export. The controller and createDefaultMapSources also take it as an `engine` option. src/maps/catalog.js, controller.js, imagery.js, terrain.js and google3d.js leave the allow-list.
363 lines
12 KiB
JavaScript
363 lines
12 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
* Keyless terrain throttling probe.
|
|
*
|
|
* On the keyless map source the browser fetches Re:Earth quantized-mesh tiles
|
|
* (`terrain.reearth.land/cesium-mesh/ellipsoid/{z}/{x}/{y}.terrain`) directly.
|
|
* A zoom-out burst asks for a few dozen shallow tiles at once and the upstream
|
|
* answers HTTP 429 for most of them. This harness drives that burst, counts the
|
|
* throttled responses, keeps the first 429's headers as evidence, and then
|
|
* checks whether every throttled tile eventually loaded — the contract the
|
|
* client-side retry in `src/render/cesium/mapTerrain.js` provides.
|
|
*
|
|
* Run against a keyless dev server (no Google or ion credentials):
|
|
* env -u GOOGLE_MAPS_API_KEY -u CESIUM_ION_TOKEN npm run dev -- --port 4180
|
|
* QA_BASE_URL=http://localhost:4180 node scripts/qa-terrain-429.mjs
|
|
*
|
|
* Flags: `--mode zoomOut|wheel` (default zoomOut), `--notches N` (default 12),
|
|
* `--settle MS` (default 25000), `--rounds N` (default 1), `--inject N`
|
|
* (answer the first N tile requests of each burst with a synthetic 429),
|
|
* `--headful`.
|
|
* Exits 1 when a throttled tile never recovered or a terrain tile is left in
|
|
* Cesium's FAILED state.
|
|
*/
|
|
import fs from 'node:fs';
|
|
import puppeteer from 'puppeteer';
|
|
|
|
const appUrl = process.env.QA_BASE_URL || 'http://localhost:4173';
|
|
const argv = process.argv.slice(2);
|
|
const flag = (name, fallback) => {
|
|
const index = argv.indexOf(`--${name}`);
|
|
return index >= 0 && argv[index + 1] !== undefined
|
|
? argv[index + 1]
|
|
: fallback;
|
|
};
|
|
const mode = flag('mode', 'zoomOut');
|
|
const notches = Number(flag('notches', 12));
|
|
const settleMs = Number(flag('settle', 25000));
|
|
const rounds = Number(flag('rounds', 1));
|
|
// The upstream throttle is load-dependent and does not fire on demand. With
|
|
// `--inject N`, the first N tile requests of each burst are answered 429 by an
|
|
// XMLHttpRequest shim inside the page so the recovery contract can be proven
|
|
// deterministically; real 429s are still counted and kept as evidence. (CDP
|
|
// request interception is not used: it stalls Cesium's request scheduler.)
|
|
const inject = Number(flag('inject', 0));
|
|
const headful = argv.includes('--headful');
|
|
const TERRAIN_HOST = 'terrain.reearth.land';
|
|
const TILE_PATTERN = /\/cesium-mesh\/ellipsoid\/\d+\/\d+\/\d+\.terrain/;
|
|
|
|
const executablePath =
|
|
process.env.PUPPETEER_EXECUTABLE_PATH ||
|
|
(await puppeteer.executablePath().catch(() => null));
|
|
if (!executablePath || !fs.existsSync(executablePath)) {
|
|
throw new Error('Puppeteer Chrome for Testing is unavailable');
|
|
}
|
|
|
|
const browser = await puppeteer.launch({
|
|
headless: headful ? false : 'new',
|
|
executablePath,
|
|
args: [
|
|
...(process.platform === 'darwin'
|
|
? ['--use-angle=metal', '--enable-gpu']
|
|
: ['--use-gl=angle', '--use-angle=swiftshader']),
|
|
'--no-sandbox',
|
|
],
|
|
});
|
|
const page = await browser.newPage();
|
|
await page.setViewport({ width: 1280, height: 800 });
|
|
|
|
/** @type {Map<string, {statuses: number[], failures: number}>} per tile URL. */
|
|
const tiles = new Map();
|
|
const evidence = [];
|
|
let layerJsonSeen = false;
|
|
let recording = false;
|
|
let requestsInWindow = 0;
|
|
let throttledInWindow = 0;
|
|
const tileEntry = (url) => {
|
|
if (!tiles.has(url)) tiles.set(url, { statuses: [], failures: 0 });
|
|
return tiles.get(url);
|
|
};
|
|
|
|
if (inject > 0) {
|
|
// Cesium fetches terrain through XMLHttpRequest and reads status, response
|
|
// and getAllResponseHeaders() in its onload handler; shadowing those on the
|
|
// instance is enough to make it see a throttled reply.
|
|
await page.evaluateOnNewDocument((pattern) => {
|
|
const tilePattern = new RegExp(pattern);
|
|
const shim = { remaining: 0, injected: [] };
|
|
window.__qaTerrainThrottle = shim;
|
|
const open = XMLHttpRequest.prototype.open;
|
|
const send = XMLHttpRequest.prototype.send;
|
|
XMLHttpRequest.prototype.open = function (method, url, ...rest) {
|
|
this.__qaUrl = String(url);
|
|
return open.call(this, method, url, ...rest);
|
|
};
|
|
XMLHttpRequest.prototype.send = function (...args) {
|
|
if (!(shim.remaining > 0 && tilePattern.test(this.__qaUrl || ''))) {
|
|
return send.apply(this, args);
|
|
}
|
|
shim.remaining -= 1;
|
|
shim.injected.push(this.__qaUrl);
|
|
const xhr = this;
|
|
setTimeout(() => {
|
|
for (const [key, value] of [
|
|
['status', 429],
|
|
['readyState', 4],
|
|
['response', null],
|
|
]) {
|
|
Object.defineProperty(xhr, key, { value, configurable: true });
|
|
}
|
|
xhr.getAllResponseHeaders = () => 'retry-after: 1\r\n';
|
|
xhr.onload?.(new Event('load'));
|
|
}, 30);
|
|
return undefined;
|
|
};
|
|
}, TILE_PATTERN.source);
|
|
}
|
|
|
|
page.on('response', async (response) => {
|
|
const url = response.url();
|
|
if (!url.includes(TERRAIN_HOST)) return;
|
|
if (url.endsWith('layer.json')) layerJsonSeen = true;
|
|
if (!TILE_PATTERN.test(url)) return;
|
|
const status = response.status();
|
|
tileEntry(url).statuses.push(status);
|
|
if (recording) requestsInWindow += 1;
|
|
if (status !== 429) return;
|
|
if (recording) throttledInWindow += 1;
|
|
if (evidence.length < 3) {
|
|
let body = '';
|
|
try {
|
|
body = (await response.text()).slice(0, 160);
|
|
} catch {
|
|
/* body unavailable */
|
|
}
|
|
evidence.push({ url, status, headers: response.headers(), body });
|
|
}
|
|
});
|
|
page.on('requestfailed', (request) => {
|
|
const url = request.url();
|
|
if (!TILE_PATTERN.test(url)) return;
|
|
tileEntry(url).failures += 1;
|
|
if (recording) requestsInWindow += 1;
|
|
});
|
|
|
|
const consoleErrors = [];
|
|
page.on('pageerror', (error) => consoleErrors.push(error.message));
|
|
page.on('console', (message) => {
|
|
if (message.type() === 'error') consoleErrors.push(message.text());
|
|
});
|
|
|
|
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
const waitFor = async (predicate, timeoutMs, label) => {
|
|
const deadline = Date.now() + timeoutMs;
|
|
while (Date.now() < deadline) {
|
|
if (await predicate()) return;
|
|
await sleep(250);
|
|
}
|
|
throw new Error(`timed out waiting for ${label}`);
|
|
};
|
|
|
|
const setCamera = (lon, lat, height) =>
|
|
page.evaluate(
|
|
({ lon, lat, height }) => {
|
|
const viewer = window.__godsEyeView.viewer;
|
|
// The app's own startup flight would otherwise keep steering the camera
|
|
// through the burst and turn the zoom-out into a zoom-in.
|
|
viewer.camera.cancelFlight();
|
|
const cartographic =
|
|
viewer.camera.positionCartographic.constructor.fromDegrees(
|
|
lon,
|
|
lat,
|
|
height,
|
|
);
|
|
viewer.camera.setView({
|
|
destination:
|
|
viewer.scene.globe.ellipsoid.cartographicToCartesian(cartographic),
|
|
orientation: { heading: 0, pitch: -Math.PI / 2, roll: 0 },
|
|
});
|
|
window.__godsEyeView.requestRender?.();
|
|
},
|
|
{ lon, lat, height },
|
|
);
|
|
|
|
const cameraHeight = () =>
|
|
page.evaluate(
|
|
() => window.__godsEyeView.viewer.camera.positionCartographic.height,
|
|
);
|
|
|
|
const globeState = () =>
|
|
page.evaluate(() => {
|
|
const viewer = window.__godsEyeView.viewer;
|
|
const surface = viewer.scene.globe._surface;
|
|
let failed = 0;
|
|
let loaded = 0;
|
|
const visit = (tile) => {
|
|
if (!tile) return;
|
|
const state = tile.data?.terrainState;
|
|
if (state === 0) failed += 1;
|
|
else if (state === 6) loaded += 1;
|
|
for (const child of tile._children || []) visit(child);
|
|
};
|
|
for (const tile of surface._levelZeroTiles || []) visit(tile);
|
|
return {
|
|
failed,
|
|
loaded,
|
|
tilesLoaded: viewer.scene.globe.tilesLoaded,
|
|
provider: viewer.terrainProvider?.constructor?.name,
|
|
};
|
|
});
|
|
|
|
const burst = async () => {
|
|
if (mode === 'zoomOut') {
|
|
for (let i = 0; i < notches; i += 1) {
|
|
await page.evaluate(() => {
|
|
const viewer = window.__godsEyeView.viewer;
|
|
viewer.camera.zoomOut(viewer.camera.positionCartographic.height * 0.6);
|
|
window.__godsEyeView.requestRender?.();
|
|
});
|
|
await sleep(40);
|
|
}
|
|
return;
|
|
}
|
|
await page.mouse.move(640, 400);
|
|
for (let i = 0; i < notches; i += 1) {
|
|
await page.mouse.wheel({ deltaY: 200 });
|
|
await page.evaluate(() => window.__godsEyeView.requestRender?.());
|
|
await sleep(40);
|
|
}
|
|
};
|
|
|
|
try {
|
|
await page.goto(appUrl, { waitUntil: 'domcontentloaded', timeout: 60000 });
|
|
await page.waitForFunction(() => Boolean(window.__godsEyeView?.viewer), {
|
|
timeout: 60000,
|
|
});
|
|
await waitFor(() => layerJsonSeen, 60000, 'the Re:Earth layer.json fetch');
|
|
await waitFor(
|
|
async () => (await globeState()).provider === 'CesiumTerrainProvider',
|
|
30000,
|
|
'the keyless terrain provider',
|
|
);
|
|
|
|
const summaries = [];
|
|
for (let round = 1; round <= rounds; round += 1) {
|
|
// Re-apply the view until it sticks: a still-running startup flight can
|
|
// overwrite the first setView on the very next frame.
|
|
for (let attempt = 0; attempt < 5; attempt += 1) {
|
|
await setCamera(-97.7431, 30.2672, 40000);
|
|
await sleep(1500);
|
|
const height = await cameraHeight();
|
|
if (Math.abs(height - 40000) < 1000) break;
|
|
}
|
|
await waitFor(
|
|
async () => (await globeState()).tilesLoaded,
|
|
30000,
|
|
'the 40 km view to settle',
|
|
).catch(() => {});
|
|
await sleep(2000);
|
|
const settledHeight = await cameraHeight();
|
|
if (Math.abs(settledHeight - 40000) > 1000) {
|
|
throw new Error(
|
|
`camera did not hold the 40 km start view (at ${Math.round(settledHeight)} m)`,
|
|
);
|
|
}
|
|
const before = await globeState();
|
|
tiles.clear();
|
|
requestsInWindow = 0;
|
|
throttledInWindow = 0;
|
|
if (inject > 0) {
|
|
await page.evaluate((count) => {
|
|
window.__qaTerrainThrottle.remaining = count;
|
|
window.__qaTerrainThrottle.injected = [];
|
|
}, inject);
|
|
}
|
|
recording = true;
|
|
const startHeight = await cameraHeight();
|
|
await burst();
|
|
const endHeight = await cameraHeight();
|
|
await sleep(settleMs);
|
|
recording = false;
|
|
|
|
// Injected throttles never reach the network, so fold them in from the
|
|
// page: a later real 200 for the same tile is the retry succeeding.
|
|
const injected =
|
|
inject > 0
|
|
? await page.evaluate(() => window.__qaTerrainThrottle.injected)
|
|
: [];
|
|
for (const url of injected) tileEntry(url).statuses.unshift(429);
|
|
const throttled = [...tiles.entries()].filter(([, entry]) =>
|
|
entry.statuses.includes(429),
|
|
);
|
|
const recovered = throttled.filter(([, entry]) =>
|
|
entry.statuses.includes(200),
|
|
);
|
|
const unrecovered = throttled.filter(
|
|
([, entry]) => !entry.statuses.includes(200),
|
|
);
|
|
const after = await globeState();
|
|
summaries.push({
|
|
round,
|
|
mode,
|
|
notches,
|
|
startHeightKm: Math.round(startHeight / 1000),
|
|
endHeightKm: Math.round(endHeight / 1000),
|
|
tileResponses: requestsInWindow,
|
|
throttledResponses: throttledInWindow,
|
|
injectedThrottles: injected.length,
|
|
throttledTiles: throttled.length,
|
|
recoveredTiles: recovered.length,
|
|
unrecoveredTiles: unrecovered.length,
|
|
failedTilesBefore: before.failed,
|
|
failedTilesAfter: after.failed,
|
|
loadedTilesAfter: after.loaded,
|
|
});
|
|
console.log(JSON.stringify(summaries.at(-1)));
|
|
if (unrecovered.length) {
|
|
console.log(
|
|
' unrecovered: ' +
|
|
unrecovered
|
|
.slice(0, 8)
|
|
.map(
|
|
([url, entry]) =>
|
|
`${new URL(url).pathname} [${entry.statuses.join(',')}]`,
|
|
)
|
|
.join(' · '),
|
|
);
|
|
}
|
|
}
|
|
if (evidence.length) {
|
|
console.log('first 429 evidence:');
|
|
for (const item of evidence) {
|
|
const headers = Object.fromEntries(
|
|
Object.entries(item.headers).filter(([name]) =>
|
|
/^(cf-|retry-after|server|content-type|date|x-ratelimit|ratelimit|access-control)/i.test(
|
|
name,
|
|
),
|
|
),
|
|
);
|
|
console.log(
|
|
` ${new URL(item.url).pathname} ${JSON.stringify(headers)} body=${JSON.stringify(item.body)}`,
|
|
);
|
|
}
|
|
}
|
|
const failures = summaries.filter(
|
|
(summary) => summary.unrecoveredTiles > 0 || summary.failedTilesAfter > 0,
|
|
);
|
|
const terrainErrors = consoleErrors.filter((text) =>
|
|
/terrain tile/i.test(text),
|
|
);
|
|
if (terrainErrors.length) {
|
|
console.log(`terrain console errors: ${terrainErrors.length}`);
|
|
console.log(` ${terrainErrors[0].slice(0, 200)}`);
|
|
}
|
|
console.log(
|
|
failures.length
|
|
? `FAIL — ${failures.length}/${summaries.length} round(s) left throttled terrain tiles unloaded`
|
|
: `PASS — every throttled terrain tile recovered in ${summaries.length} round(s)`,
|
|
);
|
|
process.exitCode = failures.length ? 1 : 0;
|
|
} finally {
|
|
await browser.close();
|
|
}
|