mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-20 18:22:25 +00:00
Merge main
This commit is contained in:
commit
4e03e82987
12 files changed
+260
-34
No files matched your search
@@ -37,6 +37,8 @@ GOOGLE_MAPS_API_KEY=
|
||||
GOOGLE_MAPS_SERVER_API_KEY=
|
||||
# Per-IP rate limit for the Google Places cost endpoints
|
||||
# (/api/google/nearby-places + /api/google/text-search), in requests per minute.
|
||||
# The CCTV Street View fallback counts in its own window with the same cap;
|
||||
# over it, a frame gets the placeholder image instead of a 429.
|
||||
# DEFAULTS TO 120, the value the Pinokio build already ships. Raise or lower it
|
||||
# with a positive integer; 60 is a sensible tightening whenever HOST is not
|
||||
# localhost. Set it to exactly 0 to run unthrottled. An unreadable value (a
|
||||
|
||||
+2
-2
@@ -68,7 +68,7 @@ browser-key fallback for existing single-key setups.
|
||||
|
||||
The data proxies under `server/providers/` are written so the browser cannot turn the server into an open relay:
|
||||
|
||||
- **No arbitrary-URL fetching.** The CCTV frame proxy fetches only server-registered camera/frame URLs — clients cannot pass an upstream URL to fetch (SSRF mitigation). Other proxies target fixed upstream hosts.
|
||||
- **No arbitrary-URL fetching.** The CCTV frame proxy fetches only server-registered camera/frame URLs — clients cannot pass an upstream URL to fetch (SSRF mitigation). The key-bearing Street View fallback likewise answers only for a registered camera, at its catalog position; a request sets only the heading, field of view and pitch, never the location. Other proxies target fixed upstream hosts.
|
||||
- **Live HLS is bounded and origin-pinned.** Registered HTTP(S) HLS sources use a Node puller that rejects redirects and off-origin playlist references, bounds playlists to 256 KiB and segment bodies to 8 MiB while streaming, and aborts timed-out or released sessions. At most two sessions retain 12 segments/24 MiB each, plus bounded download buffers. Stores are memory-only and idle sessions expire after 15 seconds. RTMP/ffmpeg execution is not enabled. Locally configured source URLs remain an operator trust boundary.
|
||||
- **Radio is not an audio relay.** `/api/radio/stations` contacts only allowlisted Radio Browser HTTPS hosts and paths, rejects redirects, rejects any hostname with a loopback/private/link-local/metadata/non-public A or AAAA result, and pins each TLS connection to a validated address. It returns normalized public HTTPS stream URLs; `/api/radio/click/:uuid` applies the same destination policy and accepts only station IDs from the current bounded catalog. The browser then connects directly to the broadcaster after an explicit playback action, so the broadcaster sees the listener's IP address. GEV never proxies, caches, records, or redistributes audio.
|
||||
- **Québec 511 video plays in the browser, opt-in and after Play.** With `CCTV_QUEBEC_VIDEO_ENABLED=1`, `/api/cctv/sources` lists, for each MTQ camera, one URL built server-side from its numeric id on `https://www.quebec511.info/Carte/Fenetres/camera.ashx`; the overlay accepts no other host, path or format. The browser loads that clip only after the viewer presses Play for the selected camera, so Québec 511 sees the viewer's IP address, and the panel says so before Play. Selecting a camera by click, auto-hop, a scene or voice never loads it, and switching cameras stops playback. GEV never proxies, caches or reads the video's pixels. With the flag unset (the default) the browser makes no request to Québec 511.
|
||||
@@ -98,7 +98,7 @@ The dev server is a **key broker**: every server-side key above is spendable by
|
||||
|
||||
- **Local-only by default.** `./scripts/dev-fresh.sh` (and the Vite config itself) bind to `localhost`, so only your machine can reach the server — and only local names are accepted (`allowedHosts` stays restricted, which also blunts DNS-rebinding tricks). Binding to all interfaces keeps that restriction: IP addresses and `localhost` work, and LAN hostnames must be listed in `GEV_ALLOWED_HOSTS` (for example `GEV_ALLOWED_HOSTS=globe.lan`); suffix and wildcard entries are ignored.
|
||||
- **LAN exposure is an explicit opt-in**: `HOST=0.0.0.0 ./scripts/dev-fresh.sh`. The launcher prints a prominent warning plus your LAN URL. Understand what opting in means: **every device on that network can drive the proxies and spend your OpenAI / Google / OpenSky / AISStream / TomTom / FIRMS quota** for as long as the server runs. Do this only on networks you trust.
|
||||
- **App-level throttles (on by default):** `GEV_RATELIMIT_OPENAI_PER_MIN` (default `30`) and `GEV_RATELIMIT_GOOGLE_PER_MIN` (default `120`) — the values the Pinokio build already ships — cap the cost-bearing endpoints per client IP per minute (over-limit requests receive a sanitized `429`). Typed chat keeps its own per-IP window, set by `GEV_RATELIMIT_OPENAI_CHAT_PER_MIN` and `GEV_RATELIMIT_GEMINI_CHAT_PER_MIN`; left unset, each takes its provider's resolved cap (`GEV_RATELIMIT_OPENAI_PER_MIN`, or `GEV_RATELIMIT_GEMINI_PER_MIN`, default `30`), so lowering a provider throttle lowers chat too, while an explicit chat value, including `0`, wins. Both defaults sit well above what the app itself generates; set either to exactly `0` to run unthrottled. They are **per-IP, process-local, in-memory guards** — they reset on restart, a caller with several addresses gets a bucket per address, and they are **not billing caps**.
|
||||
- **App-level throttles (on by default):** `GEV_RATELIMIT_OPENAI_PER_MIN` (default `30`) and `GEV_RATELIMIT_GOOGLE_PER_MIN` (default `120`) — the values the Pinokio build already ships — cap the cost-bearing endpoints per client IP per minute (over-limit requests receive a sanitized `429`). The CCTV Street View fallback has its own per-IP window on `GEV_RATELIMIT_GOOGLE_PER_MIN`, separate from the Places and Geocoding one; over it, a frame gets the placeholder instead of a `429`. Typed chat keeps its own per-IP window, set by `GEV_RATELIMIT_OPENAI_CHAT_PER_MIN` and `GEV_RATELIMIT_GEMINI_CHAT_PER_MIN`; left unset, each takes its provider's resolved cap (`GEV_RATELIMIT_OPENAI_PER_MIN`, or `GEV_RATELIMIT_GEMINI_PER_MIN`, default `30`), so lowering a provider throttle lowers chat too, while an explicit chat value, including `0`, wins. Both defaults sit well above what the app itself generates; set either to exactly `0` to run unthrottled. They are **per-IP, process-local, in-memory guards** — they reset on restart, a caller with several addresses gets a bucket per address, and they are **not billing caps**.
|
||||
- **Docker trusts one address, and only because the port is on loopback.**
|
||||
Docker delivers the host's own browser to the container from the container
|
||||
network's gateway, never from `127.0.0.1`, so a loopback-only Provider
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
- The CCTV Street View fallback answers only for cameras the server lists, at
|
||||
their catalog position; a request sets only the view. Bundled seed cameras
|
||||
get the placeholder. A per-IP limit on `GEV_RATELIMIT_GOOGLE_PER_MIN`
|
||||
(default 120) keeps the Google key from serving as an unmetered Street View
|
||||
service (asturksever, #1602).
|
||||
+10
-1
@@ -2025,7 +2025,13 @@ and follows redirects only on the camera's origin. Catalog image URLs, and
|
||||
redirects on those hosts, are pinned by parsed URL to the agency's image
|
||||
directory. Every `/api/cctv` route refuses cross-site browser requests but
|
||||
accepts forwarding headers, so cameras work behind a reverse proxy; a forwarded
|
||||
request skips the key-bearing Street View fallback and gets the placeholder.
|
||||
request skips the key-bearing Street View fallback and gets the placeholder. The
|
||||
fallback answers only for cameras the server lists, at their catalog position,
|
||||
so position calibration never reaches it. Heading, field of view (clamped to
|
||||
20–120°) and pitch (clamped to −40–20°) come from the request, else from the
|
||||
catalog pose. A bundled seed camera, shown when the server catalog is empty,
|
||||
gets the placeholder. The fallback counts in its own per-IP Google window (see
|
||||
the cost-bearing proxies below).
|
||||
|
||||
The CCTV layer draws only the cameras on or near the screen. Zoomed out, a
|
||||
ground cell with two or more cameras shows one marker at their mean position. A
|
||||
@@ -3579,6 +3585,9 @@ unaffected. `GEV_RATELIMIT_OPENAI_PER_MIN` and `GEV_RATELIMIT_GOOGLE_PER_MIN` ov
|
||||
those; exactly `0` disables the limiter, while a value that cannot be read as a
|
||||
number falls back to the default rather than to unlimited. Over-limit requests
|
||||
receive a sanitized `429` with `Retry-After: 5` and never reach the provider.
|
||||
The CCTV Street View fallback counts in a separate window with the Google cap.
|
||||
An IPv6 /64 counts as one client. Over the cap, a frame gets the placeholder
|
||||
image instead of a `429`.
|
||||
Typed chat (`/api/openai/chat`, `/api/gemini/chat`) counts in its own window,
|
||||
set by `GEV_RATELIMIT_OPENAI_CHAT_PER_MIN` and `GEV_RATELIMIT_GEMINI_CHAT_PER_MIN`.
|
||||
Left unset, each takes its provider's resolved cap — `GEV_RATELIMIT_OPENAI_PER_MIN`
|
||||
|
||||
@@ -584,7 +584,9 @@
|
||||
"src/data/cctvFootprint.js",
|
||||
"src/sources/cctvTypes.js",
|
||||
"src/sources/httpBody.js",
|
||||
"src/i18n/marker.js"
|
||||
"src/i18n/marker.js",
|
||||
"server/providers/common/rate-limit.js",
|
||||
"src/sources/rateLimit.js"
|
||||
],
|
||||
"external": []
|
||||
},
|
||||
|
||||
+36
-13
@@ -21,8 +21,13 @@ import { PROXY_SIGNALS } from '../../src/localRequestGate.mjs';
|
||||
import { createHlsPuller } from './cctv/stream.js';
|
||||
import { isMlitRiverAdjustmentImage } from './cctv/worldCameras.js';
|
||||
import { ottawaAuthorizedFrameUrl } from './cctv/ottawa.js';
|
||||
import { googleServerApiKey } from './places/google-key.js';
|
||||
import {
|
||||
GOOGLE_DEFAULT_PER_MIN,
|
||||
googleServerApiKey,
|
||||
} from './places/google-key.js';
|
||||
import { clientNetworkKey, makeCostRateLimiter } from './common/rate-limit.js';
|
||||
export { CCTV_FRAME_FETCH_TIMEOUT_MS, fetchCctvImageFromUpstream };
|
||||
|
||||
/**
|
||||
* Vite plugin: CCTV camera proxy with source registry, frame/media serving,
|
||||
* fallback chain (upstream -> Street View -> synthetic SVG), and health tracking.
|
||||
@@ -198,17 +203,31 @@ export function cctvProxy({ sourceRoot = process.cwd() } = {}) {
|
||||
};
|
||||
};
|
||||
|
||||
let streetViewBudget; // undefined = not built yet; null = the explicit 0 opt-out
|
||||
|
||||
/**
|
||||
* Fetch a Google Street View static image as a fallback frame. Server-side
|
||||
* call, never reaches the browser — prefers GOOGLE_MAPS_SERVER_API_KEY
|
||||
* (#33: a key scoped to Street View Static/Places, restricted by server IP
|
||||
* rather than HTTP referrer) and falls back to the browser-exposed
|
||||
* GOOGLE_MAPS_API_KEY for setups that haven't split the two yet.
|
||||
* Each IP (or IPv6 /64) has its own GEV_RATELIMIT_GOOGLE_PER_MIN window,
|
||||
* separate from Places. Setting it to 0 disables the limit.
|
||||
*/
|
||||
const streetViewFallback = async ({ lat, lon, heading, fov, pitch }) => {
|
||||
const streetViewFallback = async (
|
||||
client,
|
||||
{ lat, lon, heading, fov, pitch },
|
||||
) => {
|
||||
const streetViewKey = googleServerApiKey();
|
||||
if (!streetViewKey || !Number.isFinite(lat) || !Number.isFinite(lon))
|
||||
return null;
|
||||
// Built on first use, after the standalone env has loaded.
|
||||
if (streetViewBudget === undefined)
|
||||
streetViewBudget = makeCostRateLimiter(
|
||||
process.env.GEV_RATELIMIT_GOOGLE_PER_MIN,
|
||||
GOOGLE_DEFAULT_PER_MIN,
|
||||
);
|
||||
if (streetViewBudget && !streetViewBudget(client)) return null;
|
||||
try {
|
||||
const sv = new URL('https://maps.googleapis.com/maps/api/streetview');
|
||||
sv.searchParams.set('size', '960x540');
|
||||
@@ -264,6 +283,8 @@ export function cctvProxy({ sourceRoot = process.cwd() } = {}) {
|
||||
// keyless gate keeps the routes reachable behind a reverse proxy; the
|
||||
// key-bearing Street View fallback below has its own check.
|
||||
if (admitSameSiteKeyless(req, res)) return;
|
||||
// Read before any await: a socket the client has closed has no address.
|
||||
const client = clientNetworkKey(req);
|
||||
const sources = await getCctvSources();
|
||||
const sourceById = new Map(
|
||||
sources.map((source) => [source.id, source]),
|
||||
@@ -635,8 +656,7 @@ export function cctvProxy({ sourceRoot = process.cwd() } = {}) {
|
||||
const source = sourceById.get(cameraId);
|
||||
const label = url.searchParams.get('label') || source?.name || cameraId;
|
||||
const city = url.searchParams.get('city') || source?.city || '';
|
||||
const lat = Number(url.searchParams.get('lat') || source?.lat);
|
||||
const lon = Number(url.searchParams.get('lon') || source?.lon);
|
||||
// The query sets only the view, the pose the browser draws.
|
||||
const heading = Number(
|
||||
url.searchParams.get('heading') || source?.headingDeg,
|
||||
);
|
||||
@@ -731,18 +751,21 @@ export function cctvProxy({ sourceRoot = process.cwd() } = {}) {
|
||||
// request (whose client this server cannot see) gets the placeholder,
|
||||
// as if no key were configured. Any forwarding header counts, even an
|
||||
// empty one.
|
||||
// It also answers only for catalog cameras, at the catalog position;
|
||||
// the query never sets the location.
|
||||
const forwarded = PROXY_SIGNALS.some(
|
||||
(name) => req.headers?.[name] !== undefined,
|
||||
);
|
||||
const sv = forwarded
|
||||
? null
|
||||
: await streetViewFallback({
|
||||
lat,
|
||||
lon,
|
||||
heading,
|
||||
fov,
|
||||
pitch,
|
||||
});
|
||||
const sv =
|
||||
forwarded || !source
|
||||
? null
|
||||
: await streetViewFallback(client, {
|
||||
lat: source.lat,
|
||||
lon: source.lon,
|
||||
heading,
|
||||
fov,
|
||||
pitch,
|
||||
});
|
||||
if (sv?.ok) {
|
||||
setHealth(cameraId, {
|
||||
status: 'degraded',
|
||||
|
||||
@@ -1,5 +1,13 @@
|
||||
import { resolveGoogleServerKey } from '../../../scripts/google-server-key.mjs';
|
||||
|
||||
/**
|
||||
* Default GEV_RATELIMIT_GOOGLE_PER_MIN for the Places and Geocoding window
|
||||
* and the separate CCTV Street View window, in requests per minute per IP.
|
||||
* The Pinokio build sets the same default in pinokio/_ENVIRONMENT.
|
||||
* `.env.example` suggests 60 for hosts other than localhost.
|
||||
*/
|
||||
export const GOOGLE_DEFAULT_PER_MIN = 120;
|
||||
|
||||
/**
|
||||
* Optional Google place context is an empty capability when no key is present,
|
||||
* not a server outage. Returning 200 keeps a deliberately keyless session out
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import {
|
||||
GOOGLE_DEFAULT_PER_MIN,
|
||||
googleServerApiKey,
|
||||
keylessGooglePlacesResponse,
|
||||
keylessGoogleGeocodeResponse,
|
||||
@@ -15,17 +16,7 @@ import {
|
||||
// undefined = not built yet; null = the explicit 0 opt-out; fn = active limiter
|
||||
let _googleRateLimiter;
|
||||
|
||||
/**
|
||||
* Requests/min/IP applied when GEV_RATELIMIT_GOOGLE_PER_MIN is unset. This is
|
||||
* the value the Pinokio build already ships (pinokio/_ENVIRONMENT), so the
|
||||
* packaged app keeps behaving exactly as it does today and only an
|
||||
* unconfigured server changes — from unlimited to what the product already
|
||||
* runs with. Places calls are user-driven (a search, a nearby lookup, an
|
||||
* installation probe) rather than polled, so this sits far above what the app
|
||||
* generates and bites only a caller enumerating the endpoint. `.env.example`
|
||||
* suggests a tighter 60 when the host is not localhost; that still applies.
|
||||
*/
|
||||
export const GOOGLE_DEFAULT_PER_MIN = 120;
|
||||
export { GOOGLE_DEFAULT_PER_MIN };
|
||||
|
||||
/** Google cost endpoints (nearby-places, text-search, geocoding). Null only when set to 0. */
|
||||
function googleRateLimiter() {
|
||||
|
||||
@@ -111,6 +111,7 @@ function mount(t, respond) {
|
||||
austin: process.env.CCTV_FORCE_AUSTIN,
|
||||
serverKey: process.env.GOOGLE_MAPS_SERVER_API_KEY,
|
||||
browserKey: process.env.GOOGLE_MAPS_API_KEY,
|
||||
rateLimit: process.env.GEV_RATELIMIT_GOOGLE_PER_MIN,
|
||||
};
|
||||
process.env.CCTV_SOURCES_JSON = JSON.stringify([
|
||||
STILL,
|
||||
@@ -125,6 +126,8 @@ function mount(t, respond) {
|
||||
// than a network call this file does not model.
|
||||
delete process.env.GOOGLE_MAPS_SERVER_API_KEY;
|
||||
delete process.env.GOOGLE_MAPS_API_KEY;
|
||||
// The default Google budget, whatever the shell sets.
|
||||
delete process.env.GEV_RATELIMIT_GOOGLE_PER_MIN;
|
||||
const nativeFetch = globalThis.fetch;
|
||||
const requests = [];
|
||||
globalThis.fetch = async (url, init = {}) => {
|
||||
@@ -139,6 +142,7 @@ function mount(t, respond) {
|
||||
['CCTV_FORCE_AUSTIN', before.austin],
|
||||
['GOOGLE_MAPS_SERVER_API_KEY', before.serverKey],
|
||||
['GOOGLE_MAPS_API_KEY', before.browserKey],
|
||||
['GEV_RATELIMIT_GOOGLE_PER_MIN', before.rateLimit],
|
||||
]) {
|
||||
if (value === undefined) delete process.env[name];
|
||||
else process.env[name] = value;
|
||||
@@ -155,9 +159,9 @@ function mount(t, respond) {
|
||||
});
|
||||
assert.ok(handler, 'the CCTV provider must mount a middleware');
|
||||
|
||||
const call = async (path, headers = {}) => {
|
||||
const call = async (path, headers = {}, socket) => {
|
||||
const { res, done } = recordingResponse();
|
||||
await handler({ url: path, headers, method: 'GET', on() {} }, res);
|
||||
await handler({ url: path, headers, method: 'GET', on() {}, socket }, res);
|
||||
await done;
|
||||
return res;
|
||||
};
|
||||
@@ -528,3 +532,100 @@ test('a forwarded same-origin request reaches every CCTV route but not the Stree
|
||||
assert.equal(direct.body, 'street-view');
|
||||
assert.equal(streetViewCalls(), 1);
|
||||
});
|
||||
|
||||
test('the Street View fallback frames catalog cameras only, from the catalog position', async (t) => {
|
||||
const app = mount(t, ({ url }) =>
|
||||
url.startsWith('https://maps.googleapis.com/')
|
||||
? trackedUpstream({
|
||||
headers: { 'content-type': 'image/jpeg' },
|
||||
body: 'street-view',
|
||||
}).response
|
||||
: upstreamResponse({ status: 503 }),
|
||||
);
|
||||
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
||||
const streetView = () =>
|
||||
app.requests.filter(({ url }) =>
|
||||
url.startsWith('https://maps.googleapis.com/'),
|
||||
);
|
||||
|
||||
const unknown = await app.call('/frame/not-a-camera?lat=48.85&lon=2.29');
|
||||
assert.equal(unknown.headers['X-CCTV-Source'], 'synthetic');
|
||||
assert.deepEqual(streetView(), [], 'no Google call for an unknown id');
|
||||
|
||||
const steered = await app.call(
|
||||
`/frame/${STILL.id}?lat=48.85&lon=2.29&heading=90&fov=74&pitch=-17`,
|
||||
);
|
||||
assert.equal(steered.headers['X-CCTV-Source'], 'streetview');
|
||||
const sv = new URL(streetView()[0].url).searchParams;
|
||||
assert.equal(sv.get('location'), `${STILL.lat},${STILL.lon}`);
|
||||
assert.equal(sv.get('heading'), '90');
|
||||
assert.equal(sv.get('fov'), '74');
|
||||
assert.equal(sv.get('pitch'), '-17');
|
||||
});
|
||||
|
||||
test('the Street View fallback spends a per-IP Google budget, and only with a key', async (t) => {
|
||||
const app = mount(t, ({ url }) =>
|
||||
url.startsWith('https://maps.googleapis.com/')
|
||||
? trackedUpstream({
|
||||
headers: { 'content-type': 'image/jpeg' },
|
||||
body: 'street-view',
|
||||
}).response
|
||||
: upstreamResponse({ status: 503 }),
|
||||
);
|
||||
// Read when the first keyed fallback builds the limiter, so after mount().
|
||||
process.env.GEV_RATELIMIT_GOOGLE_PER_MIN = '2';
|
||||
const streetViewCalls = () =>
|
||||
app.requests.filter(({ url }) =>
|
||||
url.startsWith('https://maps.googleapis.com/'),
|
||||
).length;
|
||||
const first = { remoteAddress: '203.0.113.7' };
|
||||
const frameSource = async (socket) =>
|
||||
(await app.call(`/frame/${STILL.id}`, {}, socket)).headers['X-CCTV-Source'];
|
||||
|
||||
// Without a key nothing is spent.
|
||||
for (let i = 0; i < 3; i++)
|
||||
assert.equal(await frameSource(first), 'synthetic');
|
||||
assert.equal(streetViewCalls(), 0);
|
||||
|
||||
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
||||
// Neither an unknown id nor a forwarded request spends the window.
|
||||
assert.equal(
|
||||
(await app.call('/frame/not-a-camera', {}, first)).headers['X-CCTV-Source'],
|
||||
'synthetic',
|
||||
);
|
||||
assert.equal(
|
||||
(
|
||||
await app.call(
|
||||
`/frame/${STILL.id}`,
|
||||
{ 'x-forwarded-for': '203.0.113.9' },
|
||||
first,
|
||||
)
|
||||
).headers['X-CCTV-Source'],
|
||||
'synthetic',
|
||||
);
|
||||
assert.deepEqual(
|
||||
[
|
||||
await frameSource(first),
|
||||
await frameSource(first),
|
||||
await frameSource(first),
|
||||
],
|
||||
['streetview', 'streetview', 'synthetic'],
|
||||
);
|
||||
assert.equal(streetViewCalls(), 2, 'no Google call over the budget');
|
||||
|
||||
// Another address has a budget of its own.
|
||||
assert.equal(
|
||||
await frameSource({ remoteAddress: '203.0.113.8' }),
|
||||
'streetview',
|
||||
);
|
||||
assert.equal(streetViewCalls(), 3);
|
||||
|
||||
// Addresses within one IPv6 /64 share a budget.
|
||||
const v6 = (remoteAddress) => frameSource({ remoteAddress });
|
||||
assert.deepEqual(
|
||||
[await v6('2001:db8::1'), await v6('2001:db8::2'), await v6('2001:db8::3')],
|
||||
['streetview', 'streetview', 'synthetic'],
|
||||
);
|
||||
assert.equal(await v6('2001:db8:0:1::1'), 'streetview', 'another /64');
|
||||
assert.equal(streetViewCalls(), 6);
|
||||
});
|
||||
@@ -0,0 +1,87 @@
|
||||
// Real sockets: a client that closes its connection while the camera upstream
|
||||
// is still pending must not get a Street View call outside its own budget.
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import http from 'node:http';
|
||||
import { cctvProxy } from '../../server/providers/cctv.js';
|
||||
|
||||
const CAM = {
|
||||
id: 'still-fixture',
|
||||
name: 'Still fixture',
|
||||
lat: 30.27,
|
||||
lon: -97.74,
|
||||
feedType: 'image',
|
||||
url: 'https://cams.upstream.invalid/still.jpg',
|
||||
};
|
||||
|
||||
test('a client that disconnects mid-fetch stays inside its own Street View budget', async (t) => {
|
||||
const saved = { ...process.env };
|
||||
process.env.CCTV_SOURCES_JSON = JSON.stringify([CAM]);
|
||||
process.env.CCTV_SOURCES_FILE = 'absent-source-file.json';
|
||||
process.env.CCTV_FORCE_AUSTIN = '0';
|
||||
process.env.GOOGLE_MAPS_SERVER_API_KEY = 'fixture-key';
|
||||
delete process.env.GOOGLE_MAPS_API_KEY;
|
||||
process.env.GEV_RATELIMIT_GOOGLE_PER_MIN = '1';
|
||||
const nativeFetch = globalThis.fetch;
|
||||
let streetViewCalls = 0;
|
||||
globalThis.fetch = async (url) => {
|
||||
if (String(url).startsWith('https://maps.googleapis.com/')) {
|
||||
streetViewCalls += 1;
|
||||
return new Response('street-view', {
|
||||
headers: { 'content-type': 'image/jpeg' },
|
||||
});
|
||||
}
|
||||
await new Promise((r) => setTimeout(r, 400));
|
||||
return new Response(null, { status: 503 });
|
||||
};
|
||||
let handler;
|
||||
cctvProxy().configureServer({
|
||||
middlewares: { use: (_r, fn) => (handler = fn) },
|
||||
});
|
||||
const server = http.createServer((req, res) => {
|
||||
req.url = req.url.replace(/^\/api\/cctv/, '');
|
||||
handler(req, res, () => res.end());
|
||||
});
|
||||
await new Promise((r) => server.listen(0, '127.0.0.1', r));
|
||||
t.after(() => {
|
||||
server.close();
|
||||
globalThis.fetch = nativeFetch;
|
||||
for (const k of Object.keys(process.env))
|
||||
if (!(k in saved)) delete process.env[k];
|
||||
Object.assign(process.env, saved);
|
||||
});
|
||||
const { port } = server.address();
|
||||
const get = (abortAfterMs) =>
|
||||
new Promise((resolve) => {
|
||||
const req = http.get(
|
||||
{
|
||||
host: '127.0.0.1',
|
||||
port,
|
||||
path: `/api/cctv/frame/${CAM.id}`,
|
||||
headers: { host: `localhost:${port}` },
|
||||
agent: false,
|
||||
},
|
||||
(res) => {
|
||||
res.resume();
|
||||
res.on('end', () => resolve(res.headers['x-cctv-source']));
|
||||
},
|
||||
);
|
||||
req.on('error', () => resolve('aborted'));
|
||||
if (abortAfterMs)
|
||||
setTimeout(() => {
|
||||
req.destroy();
|
||||
resolve('aborted');
|
||||
}, abortAfterMs);
|
||||
});
|
||||
|
||||
assert.equal(await get(), 'streetview');
|
||||
assert.equal(await get(), 'synthetic', 'the cap of one is spent');
|
||||
assert.equal(streetViewCalls, 1);
|
||||
await get(50);
|
||||
await new Promise((r) => setTimeout(r, 800));
|
||||
assert.equal(
|
||||
streetViewCalls,
|
||||
1,
|
||||
'an aborted request spent the key outside its own budget',
|
||||
);
|
||||
});
|
||||
@@ -22,8 +22,6 @@ function frameUrlFor(camera, refreshMs = ACTIVE_FRAME_REFRESH_MS) {
|
||||
const params = new URLSearchParams({
|
||||
label: camera.name,
|
||||
city: camera.city,
|
||||
lat: camera.lat.toFixed(6),
|
||||
lon: camera.lon.toFixed(6),
|
||||
heading: String(Math.round(camera.headingDeg)),
|
||||
fov: String(Math.round(camera.fovDeg)),
|
||||
pitch: String(Math.round(camera.pitchDeg || -10)),
|
||||
|
||||
@@ -82,8 +82,8 @@ test('frame and media URLs preserve registered camera identity and encoded metad
|
||||
);
|
||||
assert.equal(frame.searchParams.get('label'), camera.name);
|
||||
assert.equal(frame.searchParams.get('city'), camera.city);
|
||||
assert.equal(frame.searchParams.get('lat'), '30.267000');
|
||||
assert.equal(frame.searchParams.get('lon'), '-97.744000');
|
||||
assert.equal(frame.searchParams.has('lat'), false);
|
||||
assert.equal(frame.searchParams.has('lon'), false);
|
||||
assert.equal(frame.searchParams.get('heading'), '45');
|
||||
assert.equal(frame.searchParams.get('pitch'), '-12');
|
||||
assert.deepEqual([...media.searchParams.keys()], ['ts']);
|
||||
|
||||
Reference in new issue
Block a user