mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-17 08:42:21 +00:00
194 lines
6.6 KiB
JavaScript
194 lines
6.6 KiB
JavaScript
import {
|
|
GFS_BUCKET,
|
|
gfsObjectKey,
|
|
selectLatestGfsCycle,
|
|
} from './wind/catalog.js';
|
|
import {
|
|
fetchText,
|
|
fetchRange,
|
|
parseGfsIdx,
|
|
windMessageRanges,
|
|
} from './wind/gfs.js';
|
|
import { decodeWindGribMessage } from './wind/decode.js';
|
|
import { resampleWindGrid } from './wind/grid.js';
|
|
|
|
/**
|
|
* NOAA GFS 10 m wind proxy.
|
|
*
|
|
* Selects the latest available GFS cycle, reads its `.idx` inventory, byte-range
|
|
* fetches only the UGRD/VGRD 10 m GRIB2 messages, decodes them with ecCodes
|
|
* (WASM), resamples to a compact grid, and serves a manifest plus a Float32
|
|
* grid (U values then V values). Keyless; cached per cycle for an hour.
|
|
*
|
|
* Routes (mounted at `/api/wind`):
|
|
* GET /api/wind/manifest → manifest JSON
|
|
* GET /api/wind/grid/<id>.bin → Float32 U…V payload
|
|
* GET /api/wind/status → manifest without `gridUrl`
|
|
*
|
|
* @param {{fetchImpl?: Function, now?: Function, decodeImpl?: Function,
|
|
* targetDx?: number, ttlMs?: number}} [options]
|
|
* @returns {import('vite').Plugin}
|
|
*/
|
|
export function windProxy({
|
|
fetchImpl = fetch,
|
|
now = () => Date.now(),
|
|
decodeImpl = decodeWindGribMessage,
|
|
targetDx = 1,
|
|
ttlMs = 3600_000,
|
|
} = {}) {
|
|
/** @type {?{id: string, idGrid: string, fetchedAt: number, manifest: object, grid: ?object}} */
|
|
let cached = null;
|
|
/** @type {?Promise<object>} */
|
|
let loading = null;
|
|
let lastAttempt = -Infinity;
|
|
let controller = null;
|
|
let waiters = 0;
|
|
|
|
const sendJson = (res, value, status = 200) => {
|
|
res.writeHead(status, {
|
|
'Content-Type': 'application/json',
|
|
'Cache-Control': 'no-store',
|
|
});
|
|
res.end(JSON.stringify(value));
|
|
};
|
|
|
|
const cycleRunIso = (cycle) =>
|
|
`${cycle.date.slice(0, 4)}-${cycle.date.slice(4, 6)}-${cycle.date.slice(6)}T${String(cycle.hour).padStart(2, '0')}:00:00.000Z`;
|
|
|
|
async function refresh() {
|
|
const cycle = selectLatestGfsCycle(now());
|
|
const id = `${cycle.date}-${cycle.hour}`;
|
|
if (cached && cached.id === id && now() - cached.fetchedAt < ttlMs)
|
|
return cached;
|
|
if (loading) return loading;
|
|
if (cached && now() - lastAttempt < 60_000) return cached;
|
|
lastAttempt = now();
|
|
controller = new AbortController();
|
|
const signal = controller.signal;
|
|
const timer = setTimeout(() => controller.abort(), 40_000);
|
|
loading = (async () => {
|
|
try {
|
|
const base = `https://${GFS_BUCKET}.s3.amazonaws.com/${gfsObjectKey(cycle)}`;
|
|
const index = await fetchText({ url: `${base}.idx`, fetchImpl, signal });
|
|
const ranges = windMessageRanges(parseGfsIdx(index.toString()));
|
|
const [uBuffer, vBuffer] = await Promise.all([
|
|
fetchRange({ url: base, ...ranges.u, fetchImpl, signal }),
|
|
fetchRange({ url: base, ...ranges.v, fetchImpl, signal }),
|
|
]);
|
|
const [u, v] = await Promise.all([
|
|
decodeImpl(uBuffer),
|
|
decodeImpl(vBuffer),
|
|
]);
|
|
const grid = resampleWindGrid({
|
|
u: u.values,
|
|
v: v.values,
|
|
ni: u.ni,
|
|
nj: u.nj,
|
|
lo1: u.lo1,
|
|
la1: u.la1,
|
|
di: u.di,
|
|
dj: u.dj,
|
|
dx: targetDx,
|
|
dy: targetDx,
|
|
});
|
|
signal.throwIfAborted();
|
|
if ((!grid.u.every(Number.isFinite) || !grid.v.every(Number.isFinite))) throw new Error('Invalid wind grid');
|
|
const idGrid = `${id}-${targetDx}`;
|
|
const manifest = {
|
|
schemaVersion: 1,
|
|
model: 'gfs',
|
|
cycle: { ...cycle, forecastHour: 0, runIso: cycleRunIso(cycle), validIso: cycleRunIso(cycle) },
|
|
fetchedAt: now(),
|
|
level: '10 m above ground',
|
|
units: 'm/s',
|
|
grid: {
|
|
nx: grid.nx,
|
|
ny: grid.ny,
|
|
lo1: grid.lo1,
|
|
la1: grid.la1,
|
|
dx: grid.dx,
|
|
dy: grid.dy,
|
|
},
|
|
stale: false,
|
|
unavailable: false,
|
|
reason: null,
|
|
gridUrl: `/api/wind/grid/${idGrid}.bin`,
|
|
};
|
|
cached = { id, idGrid, fetchedAt: manifest.fetchedAt, manifest, grid };
|
|
return cached;
|
|
} catch (error) {
|
|
if (cached) {
|
|
cached = {
|
|
...cached,
|
|
manifest: { ...cached.manifest, stale: true, reason: 'Wind upstream unavailable' },
|
|
};
|
|
} else {
|
|
cached = {
|
|
id: null,
|
|
idGrid: null,
|
|
fetchedAt: now(),
|
|
grid: null,
|
|
manifest: {
|
|
schemaVersion: 1,
|
|
model: 'gfs',
|
|
stale: true,
|
|
unavailable: true,
|
|
reason: 'Wind upstream unavailable',
|
|
},
|
|
};
|
|
}
|
|
return cached;
|
|
} finally {
|
|
clearTimeout(timer);
|
|
loading = null;
|
|
controller = null;
|
|
}
|
|
})();
|
|
return loading;
|
|
}
|
|
|
|
const handler = async (req, res) => {
|
|
const path = new URL(req.url, 'http://localhost').pathname;
|
|
if (req.method !== 'GET') return sendJson(res, { error: 'method_not_allowed' }, 405);
|
|
if (!['/', '/manifest', '/status'].includes(path) && !/^\/grid\/[\w.-]+\.bin$/.test(path)) return sendJson(res, { error: 'not_found' }, 404);
|
|
// Grid reads never initiate acquisition; an issued manifest owns its cached grid.
|
|
if (path.startsWith('/grid/') && (!cached?.grid || path !== `/grid/${cached.idGrid}.bin`)) return sendJson(res, { error: 'unknown_grid' }, 404);
|
|
let disconnected = false;
|
|
const close = () => { disconnected = true; waiters -= 1; if (waiters === 0) controller?.abort(); };
|
|
waiters += 1;
|
|
res.once?.('close', close);
|
|
let state;
|
|
try { state = path.startsWith('/grid/') ? cached : await refresh(); }
|
|
finally { res.removeListener?.('close', close); if (!disconnected) waiters -= 1; }
|
|
if (disconnected) return;
|
|
if (path === '/status') {
|
|
const { gridUrl, ...manifest } = state.manifest;
|
|
return sendJson(res, manifest);
|
|
}
|
|
if (path.startsWith('/grid/')) {
|
|
if (!state.grid || path !== `/grid/${state.idGrid}.bin`)
|
|
return sendJson(res, { error: 'unknown_grid' }, 404);
|
|
const payload = Buffer.concat([
|
|
Buffer.from(state.grid.u.buffer, state.grid.u.byteOffset, state.grid.u.byteLength),
|
|
Buffer.from(state.grid.v.buffer, state.grid.v.byteOffset, state.grid.v.byteLength),
|
|
]);
|
|
res.writeHead(200, {
|
|
'Content-Type': 'application/octet-stream',
|
|
'Cache-Control': 'public, max-age=3600, immutable',
|
|
});
|
|
return res.end(payload);
|
|
}
|
|
return sendJson(res, state.manifest);
|
|
};
|
|
|
|
return {
|
|
name: 'wind',
|
|
configureServer({ middlewares }) {
|
|
middlewares.use('/api/wind', handler);
|
|
},
|
|
configurePreviewServer({ middlewares }) {
|
|
middlewares.use('/api/wind', handler);
|
|
},
|
|
};
|
|
}
|