diff --git a/.env.example b/.env.example index bec981341..4dacceaa5 100644 --- a/.env.example +++ b/.env.example @@ -219,6 +219,8 @@ AISSTREAM_API_KEY= # CCTV_CALGARY_ENABLED=1 # set 0 to disable the Open Calgary (Alberta) cameras # CCTV_CALGARY_MAX_SOURCES=220 # cap cameras loaded from the Open Calgary catalog # CCTV_CALGARY_ROWS_URL= # override the Open Calgary catalog URL +# CCTV_KINGCOUNTY_ENABLED=1 # set 0 to disable the King County (Washington) road cameras +# CCTV_KINGCOUNTY_MAX_SOURCES=125 # cap cameras loaded from the King County catalog # CCTV_WSDOT_ENABLED=1 # set 0 to disable the WSDOT (Washington State) highway cameras # CCTV_WSDOT_MAX_SOURCES=250 # cap cameras loaded from the WSDOT catalog, nearest Seattle/Spokane first; min 8, max 1200 # CCTV_VEGVESEN_ENABLED=1 # set 0 to disable the Statens vegvesen (Norway) road cameras @@ -228,6 +230,9 @@ AISSTREAM_API_KEY= # CCTV_NYC_ENABLED= # off by default; set 1 only if you hold a NYC DOT data-sharing agreement (tmcdot@dot.nyc.gov) for the camera feed # CCTV_NYC_MAX_SOURCES=250 # cap cameras loaded from the NYC TMC catalog (nearest borough cores first) # CCTV_NYC_CAMERAS_URL= # override the NYC TMC catalog URL +# CCTV_TORONTO_ENABLED=1 # set 0 to disable the City of Toronto RESCU cameras +# CCTV_TORONTO_MAX_SOURCES=336 # cap cameras loaded from Toronto RESCU (clamped to 8–500) +# CCTV_TORONTO_LIST_URL= # override the Toronto RESCU camera list URL # CCTV_MAX_SOURCES=4000 # catalog-wide ceiling, shared round-robin across packs # CCTV_PREFER_AUSTIN=1 # prioritize Austin cameras in the registry # CCTV_FORCE_AUSTIN= # force live default sources when a source-pack JSON is configured diff --git a/CHANGELOG.md b/CHANGELOG.md index 13d5633d6..0e1d54537 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,29 @@ cap (8–1,200) and `CCTV_WSDOT_ENABLED=0` turns the pack off (bassem chagra, #644). +- Add King County road cameras (Washington State) as a keyless CCTV source + pack: one public King County DOT ArcGIS layer, fetched with an explicit field + list so its staff-name columns are never requested, and frames pinned to the + county's own image host and upgraded to HTTPS. WSDOT-owned rows are skipped, + and city-owned cameras the county hosts credit their owner. The layer + publishes no facing, so headings use the shared id-hash fallback at low + confidence. It does publish each camera's hardware, which is served on + `/api/cctv/sources` as `model` and `manufacturer`. `CCTV_KINGCOUNTY_MAX_SOURCES` + sets the cap and `CCTV_KINGCOUNTY_ENABLED=0` turns the pack off + (bassem chagra, #645). + +- Add City of Toronto RESCU traffic cameras as a keyless CCTV source pack: the + ~336 municipal cameras the Ontario 511 pack does not carry — downtown + arterials plus the Gardiner, DVP, Allen and Lake Shore. The list is the + City's own open data feed; frames are built from the documented + `loc####.jpg` convention and a digits-only camera number, so the frame proxy + is pinned to the portal origin by construction. The dataset publishes no + camera facing — its `D1`-`D4` fields describe static 2016 comparison images, + not the live pan-tilt-zoom frame — so headings use the shared id-hash + fallback at low confidence and are corrected with the calibration gizmo. + Carries the required Open Government Licence – Toronto attribution. Disable + with `CCTV_TORONTO_ENABLED=0`. + - Stop one retired bikeshare feed from reporting the whole layer as failed. City feeds are fetched independently, but failure was recorded in a single flag that only a successful *activation* cleared — and an already-loaded city diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md index 4ce25a4e0..cb1fe72b0 100644 --- a/DATA_SOURCES.md +++ b/DATA_SOURCES.md @@ -59,9 +59,11 @@ How to read this: | **Fintraffic / Digitraffic (weathercams)** | CCTV camera catalog + frames, Finland | [CC BY 4.0](https://www.digitraffic.fi/en/terms-of-service/) — attribution REQUIRED | "Fintraffic / digitraffic.fi, license CC BY 4.0" | | **DriveBC** (Government of British Columbia) | CCTV camera catalog + frames, British Columbia highways | [Open Government Licence – British Columbia](https://www2.gov.bc.ca/gov/content/data/open-data/open-government-licence-bc) — attribution REQUIRED | "DriveBC. Contains information licensed under the Open Government Licence – British Columbia" | | **Open Calgary** (`data.calgary.ca`) | CCTV camera catalog + frames, Calgary | [Open Government Licence – City of Calgary](https://data.calgary.ca/stories/s/Open-Calgary-Terms-of-Use/u45n-7awa) — attribution REQUIRED | "Contains information licensed under the Open Government Licence – City of Calgary" | +| **King County Road Services** (`services.arcgis.com`, King County GIS) | CCTV camera catalog + frames, unincorporated King County WA road network | [KCGIS Center terms](https://kingcounty.gov/en/dept/kcit/data-information-services/gis-center/about/terms-conditions-copyrights) — attribution required; public ArcGIS layer | "King County Road Services" (partner-city cameras name their owner) | | **WSDOT** (`data.wsdot.wa.gov`) | CCTV camera catalog + frames, Washington State highways | [WSDOT travel information disclaimer](https://wsdot.wa.gov/about/policies/travel-information-disclaimer) — public "low volume" feed; catalog cached, frames on WSDOT's own image host only | "Washington State Department of Transportation (Travel Center)" (courtesy) | | **Statens vegvesen** (catalog `ogckart-sn1.atlas.vegvesen.no`, frames `kamera.atlas.vegvesen.no`, HLS `kamera.vegvesen.no`) | CCTV camera catalog + frames + live HLS video, Norway road cameras | [NLOD 2.0](https://data.norge.no/nlod/en/2.0) — attribution REQUIRED | "Contains data under the Norwegian licence for Open Government data (NLOD) distributed by Statens vegvesen" | | **NYC DOT Traffic Management Center** (`webcams.nyctmc.org`) | CCTV camera catalog + frames, New York City five boroughs | NYC DOT requires developers to sign a [data-sharing agreement](https://www.nyc.gov/html/dot/html/about/datafeeds.shtml) for the camera feed. **Off by default**; enable only under your own agreement | "NYC DOT Traffic Management Center" + NYC DOT's required application disclaimer (in the Data attribution popover) | +| **City of Toronto Open Data** (`opendata.toronto.ca`) | CCTV camera catalog + frames, Toronto city streets | [Open Government Licence – Toronto](https://www.toronto.ca/city-government/data-research-maps/open-data/open-data-licence/) — attribution REQUIRED | "Contains information licensed under the Open Government Licence – Toronto" | | **GBFS (Lyft / BCycle / Social Bicycles / PBSC)** | Bikeshare availability | Per-feed (attribution-only) | Credit the operator (e.g. Austin BCycle) + its `license_url` | | **Bike Share Toronto** (`toronto.publicbikesystem.net`) | Bikeshare station availability, Toronto | Operator GBFS feed. No licence is published: the City's open-data package declares none and the feed has no `license_url`. Attribution is given to the operator. | "Bike Share Toronto (Toronto Parking Authority)" | | **Oslo / Bergen / Trondheim Bysykkel** (Urban Sharing, `gbfs.urbansharing.com`) | Bikeshare availability, Oslo, Bergen and Trondheim city bikes. Keyless GBFS; the proxy sends the `Client-Identifier` header the operators ask for | [NLOD 2.0](https://data.norge.no/nlod/en/2.0) — attribution REQUIRED ([Oslo](https://oslobysykkel.no/en/open-data/realtime), [Bergen](https://bergenbysykkel.no/en/apne-data/sanntid), [Trondheim](https://trondheimbysykkel.no/en/open-data/realtime)) | "Contains data under the Norwegian licence for Open Government data (NLOD) made available by Oslo Bysykkel, Bergen Bysykkel and Trondheim Bysykkel" | @@ -143,9 +145,11 @@ The optional Local ADS-B layer and the broadcast-FM receiver use radio you recei - **Warendorf webcam.** The Stadt Warendorf Marktplatz webcam, registered from the curated `config/cctv_sources.warendorf.json` (the Kreis Warendorf registration-office cameras from the contributing PR are indoor waiting rooms and were left out); only the municipal image host is proxied, frames are fetched at request time and never stored or redistributed. Disable with `CCTV_WARENDORF_ENABLED=0`. - **Live Traffic NSW cameras.** The camera list is the keyless public `data.livetraffic.com/cameras/traffic-cam.json` feed (Transport for NSW open data, CC BY 4.0); frames are stills on `webcams.transport.nsw.gov.au`, and only that host is registered. That image host answers non-browser clients with an HTML placeholder, so the proxy identifies as a browser for that one host and as itself everywhere else. Frames are fetched at request time and never stored or redistributed. Disable with `CCTV_NSW_ENABLED=0`. - **Open Calgary traffic cameras.** Keyless. The camera list is the public Socrata dataset `k7p9-kppz` on `data.calgary.ca`; frames are stills on the city's own `trafficcam.calgary.ca` host, and only that host is registered. Most rows publish an `http://` frame URL and the host redirects those to HTTPS, so URLs are upgraded and pinned to that origin before registration. Frames are fetched at request time and never stored or redistributed. The dataset publishes no camera facing: the `quadrant` field and the quadrant suffix on each camera name are Calgary's address grid, not a bearing, so headings use the shared id-hash fallback at low confidence and are corrected with the in-app calibration gizmo. The licence requires the attribution statement above. Disable with `CCTV_CALGARY_ENABLED=0`. +- **King County road cameras.** Keyless. The camera list is one public ArcGIS FeatureServer GeoJSON query (King County DOT Road Services, "King County and WSDOT Traffic Cameras"). The `outFields` list is explicit on purpose: the layer also carries asset-administration columns — including staff names — that are never fetched. Only live, active cameras with frames on the county's own `info.kingcounty.gov` image handler are registered (the feed writes `http://`; the handler serves HTTPS, so URLs are upgraded and pinned before registration). WSDOT-owned rows in the layer are skipped because their frames are WSDOT-hosted, outside the pinned image origin; partner-city cameras hosted on the county image handler (e.g. Newcastle) name their owner as the per-camera credit. The layer publishes no facing, so headings use the shared id-hash fallback at low confidence. Uniquely, the county publishes each camera's hardware `Manufacturer`/`Model` (Cohu 3950/3965, Bosch AUTODOME, Axis PTZ domes); both are carried on the source (and served by `/api/cctv/sources`) as `model` and `manufacturer` for identified-hardware consumers (vendor-generic strings such as `PTZ` name no model and are omitted). Frames are fetched at request time and never stored or redistributed. Disable with `CCTV_KINGCOUNTY_ENABLED=0`. - **WSDOT highway cameras.** Keyless. The camera list is the Esri JSON layer `data.wsdot.wa.gov/travelcenter/Cameras.json` — the same layer WSDOT's own Travel Center map consumes (~1,700 point features, EPSG:3857 geometry converted to WGS84 on load; the body carries Windows-1252 bytes and is decoded as such). Only frames on WSDOT's own `images.wsdot.wa.gov` host are registered — the catalog also lists ~70 partner cameras (Oregon DOT, City of Seattle, lodges, airports) whose own terms apply, and those are skipped rather than proxied. WSDOT's layer metadata marks the feed for "low volume" use (see WSDOT's [travel information disclaimer](https://wsdot.wa.gov/about/policies/travel-information-disclaimer)). The catalog is fetched once per CCTV catalog refresh (every 15 minutes), and a camera's frame is fetched only when that camera is viewed; frames are never stored or redistributed. The live feed's `CompassDirection` is a single cardinal (N/E/S/W), `B` (both directions — most rows), `O`, or null. A single cardinal gives a high-confidence heading (the diagonals NE/SE/SW/NW are mapped too should they appear); `B`, `O`, null, and any other code carry no single facing and use the shared id-hash fallback at low confidence. By default the 250 cameras nearest Seattle and Spokane load; `CCTV_WSDOT_MAX_SOURCES` changes the cap (8–1,200) and `CCTV_WSDOT_ENABLED=0` turns the pack off. A keyed WSDOT Traveler Information API serves the same population for higher-volume use and is deliberately not required here. - **Statens vegvesen road cameras.** Keyless. The camera list is one GeoJSON request to the OGC API Features view of the official DATEX 3.1 CCTV site table (`ogckart-sn1.atlas.vegvesen.no/ogc/features/v1/collections/datex_3_1:CctvSimple/items`), so no DATEX account is needed; frames are stills on `kamera.atlas.vegvesen.no/api/images/`, and only that exact path per camera is registered. Cameras the feed reports as faulty are dropped. About 135 working cameras also publish live HLS (`kamera.vegvesen.no/public//manifest.m3u8`, MPEG-TS); those play as live video through the bounded in-memory HLS relay, with the still as the snapshot fallback, and only that exact manifest path per camera is registered. `CCTV_VEGVESEN_VIDEO=0` keeps every camera on stills. `orientationDescription` names the place a camera faces, not a bearing, so it goes into the label and headings use the id-hash fallback at low confidence. By default every live camera loads (~850); `CCTV_VEGVESEN_MAX_SOURCES` (8–1000) lowers the cap, keeping the cameras nearest Oslo, Bergen, Stavanger, Trondheim, Kristiansand, Bodø and Tromsø and `CCTV_VEGVESEN_ENABLED=0` turns the pack off. Frames are fetched at request time and never stored or redistributed. The NLOD attribution is registered in the Data attribution popover. - **NYC DOT Traffic Management Center cameras.** Off by default. NYC DOT's [developer data feeds page](https://www.nyc.gov/html/dot/html/about/datafeeds.shtml) asks developers who want the camera feed to contact `tmcdot@dot.nyc.gov` and sign a data-sharing agreement. This project does not hold one that covers downstream installations, so the pack loads only when an operator who holds their own agreement sets `CCTV_NYC_ENABLED=1`; with the flag unset, empty or any other value, the server makes no request to NYC DOT. The endpoint needs no key. The camera list is the public `webcams.nyctmc.org/api/cameras` catalog (~980 cameras across the five boroughs); frames are stills at `webcams.nyctmc.org/api/cameras//image`, synthesized from a validated UUID rather than taken from the payload, and only that host is registered. Cameras the feed reports as offline are dropped. The catalog publishes no camera facing, so headings use the shared id-hash fallback at low confidence and are corrected with the in-app calibration gizmo. Once enabled, the 250 cameras nearest the borough cores load; `CCTV_NYC_MAX_SOURCES` (8–400) changes the cap. Frames are fetched at request time and never stored or redistributed. NYC DOT asks every application that uses its data to carry its disclaimer; it is registered verbatim in the Data attribution popover. +- **City of Toronto RESCU cameras.** Keyless. The camera list is the City's public `tmcearthcameras.json` on `opendata.toronto.ca` (dataset "Traffic Cameras", Transportation Services), served as JSONP and unwrapped with an anchored pattern. This is the municipal network the Ontario 511 pack does not carry: downtown arterials plus the Gardiner, DVP, Allen and Lake Shore. The list publishes no frame URL, so frame URLs are BUILT from the documented `CameraImages/loc####.jpg` convention and a strictly-digits camera number, pinning the frame proxy to the portal origin by construction; the list fetch refuses redirects and bounds the body it buffers. Frames are fetched at request time and never stored or redistributed. The dataset publishes no camera facing: the `D1`-`D4` fields are the directions of the *comparison* images (static reference stills captured in 2016 under a different path), not a bearing for the live pan-tilt-zoom frame, so headings use the shared id-hash fallback at low confidence and are corrected with the in-app calibration gizmo. A camera that is temporarily out of service still answers 200 with a byte-identical "Image Unavailable" placeholder rather than an error (about 6% of the network at any moment), so such a camera reads as healthy; the frame it shows is the agency's, not a synthesized one. The licence requires the attribution statement above. Disable with `CCTV_TORONTO_ENABLED=0`. - **Camera frame content.** Public camera frames can contain people, vehicles and license plates, and the camera layer does nothing with them beyond putting them on the map. A successful upstream response is relayed as the provider served it: nothing in the camera pipeline blurs, redacts, enhances or restores it, and nothing there runs face, plate or object detection or otherwise recognises or classifies what is in the picture. (The ALPR layer described below maps where plate-reader cameras are, from locations contributors tagged in OpenStreetMap; it reads nothing from any camera frame.) When an upstream has no frame for a camera, what you see instead is a Google Street View still or the app's own placeholder card; the panel's source badge names which of them you are looking at, and a refresh that fails after a frame has arrived leaves the last good picture on screen rather than replacing it. The browser resamples each frame for display: onto a fixed 1920x1080 surface for the camera's projection plane in the scene, and onto a 192x108 canvas for the small ambient card. That scaling is the only change made to the picture, and the only pixels the camera layer reads back are a 64x36 downscale hashed to tell whether the picture has changed. Live streams are piped through; the still path reads the image into memory to pass it on — TxDOT wraps its JPEG in a JSON envelope, which is decoded there — and no frame is written to disk (the disk cache, `.gev-cache/`, holds feed JSON for other layers and never camera imagery). Outside that pipeline, the voice assistant is the one feature that sends imagery anywhere: when it answers a question about what is in view it may attach a downscaled screenshot of the rendered scene — including any camera plane on screen — to the request it sends to the voice model. Frames are fetched only from server-registered camera URLs — a client cannot hand the proxy a URL (see [SECURITY.md](SECURITY.md)). What the app does stays inside the line README draws: no named-person search, no face recognition, no tracking individuals. - **Transit (GTFS-Realtime).** The proxy requests only registered operator feeds, validates redirects, bounds responses, and uses conditional requests, short snapshot caching and failure backoff. All seven registered regions are live-enabled; each can be disabled independently. Vehicles use delayed playback between reports, with report age and waiting states shown separately. Session-local selected trails are available for every feed. MBTA additionally retains up to 15 minutes of recently observed positions in the running proxy, so available history can survive a browser reload; server restart clears it. History reads never fetch upstream, and other feeds have no proxy retention. Nothing is archived to disk or collected in the background. Operator text credits are included as a courtesy and do not imply endorsement. Heights are aligned to work with Google 3D tiles; subway markers are shown at street level because these feeds do not supply depth. - **Radio Browser.** `/api/radio/stations` discovers official API mirrors, makes bounded and coalesced healthy/geolocated HTTPS-station queries, caches the normalized public-domain directory for 45 minutes, and may serve the last good catalog for up to seven days during an outage. Refreshes must meet minimum accepted-query and station coverage before replacing a warm catalog; schema-valid responses whose rows all fail the product's health policy do not count as successful queries. A usable partial cold catalog is explicitly `DEGRADED`, and malformed or empty successful payloads are rejected atomically. Every directory and click-count request rejects redirects, validates all resolved addresses as globally routable (including reserved/documentation IPv4 and special/non-global IPv6 exclusions), and pins the TLS connection to a validated address. Only MP3/AAC non-HLS directory rows with public HTTPS stream targets are returned; favicons are intentionally omitted. Pressing play connects one browser audio element directly to the selected broadcaster and calls the directory's click counter through known-ID-only `POST /api/radio/click/:uuid`. GEV never proxies, caches, records, bundles, or redistributes audio. Radio Browser supplies station-level tags, not dependable current-song or upcoming-program metadata, so Radio filtering never claims either. Direct playback exposes the listener's IP address to the broadcaster, whose own stream terms apply. diff --git a/README.md b/README.md index 296dea494..1722914a8 100644 --- a/README.md +++ b/README.md @@ -377,7 +377,7 @@ Twenty layers and map sources. **Eighteen have a keyless path.** Some offer addi | 🌍 **Earthquakes** | Global seismic activity, last 24h | USGS | 🟢 | | ◍ **Air quality** | Live AQHI on the published 1–10+ health-risk scale, with a Weather-panel card showing the band legend and the highest readings in view. **Canada only** — ECCC is the first registered provider | ECCC MSC GeoMet | 🟢 | | 🚗 **Traffic** | Simulated vehicles on OSM roads. With TomTom, live flow speeds drive the simulation and congestion colors below ~8 km; individual vehicle positions are not live observations | TomTom + OSM | 🟢 simulation · 🟡 live flow speeds | -| 📹 **CCTV Mesh** | ~4,000 public cameras projected _into_ the 3D space — Austin · Texas (TxDOT) · California (Caltrans) · London (TfL) · Ontario (511) · Finland (Fintraffic) · British Columbia (DriveBC) · Estonia (Tallinn, Tarktee) · Delaware (DelDOT live video) · New South Wales (Live Traffic NSW) · Calgary · Norway (Statens vegvesen) · Washington (WSDOT), plus opt-in New York City (NYC DOT TMC, needs your own NYC DOT agreement). Positions are published; poses are estimated priors **you calibrate by dragging a gizmo on the camera itself** | City APIs | 🟢 | +| 📹 **CCTV Mesh** | ~4,000 public cameras (shared cap) projected _into_ the 3D space — Austin · Texas (TxDOT) · California (Caltrans) · London (TfL) · Ontario (511) · Finland (Fintraffic) · British Columbia (DriveBC) · Estonia (Tallinn, Tarktee) · Delaware (DelDOT live video) · New South Wales (Live Traffic NSW) · Calgary · Norway (Statens vegvesen) · Toronto · King County (WA) · Washington (WSDOT), plus opt-in New York City (NYC DOT TMC, needs your own NYC DOT agreement). Positions are published; poses are estimated priors **you calibrate by dragging a gizmo on the camera itself** | City APIs | 🟢 | | 📷 **Mapped ALPR Cameras** | License-plate-reader camera locations tagged by OpenStreetMap contributors, loaded one city-sized view at a time, with **SHOW NEAREST**. Locations and tags only: no plate data, no video | OpenStreetMap (incl. DeFlock mapping) | 🟢 | | 📷 **Street Level** | Street-level photos behind one panel, one chip per provider: coverage on the streets, image cones, an embedded viewer and **FOLLOW**. Mapillary, Google Street View, KartaView and Panoramax | Mapillary · Google · KartaView · Panoramax | 🟢 KartaView, Panoramax · 🟡 Mapillary token · 🔴 Google Maps key | | 📻 **Radio** | Geolocated world radio with an **analog tuner** — drag the needle across up to 750 stations and the globe flies to each broadcaster | Radio Browser / broadcasters | 🟢 | diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index ebc081cd7..d0563debc 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -977,7 +977,25 @@ id-hash fallback at low confidence. Once enabled, the 250 cameras nearest the five borough cores load. `CCTV_NYC_MAX_SOURCES` sets the pack cap (8–400). The catalog-wide ceiling stays at 4,000 and is shared -round-robin, so adding this pack does not silently drop another region. +round-robin: no region is dropped outright, but when the packs together exceed +the ceiling, adding a pack trims cameras from the largest packs. + +## City of Toronto RESCU CCTV source pack + +The CCTV catalog adds the City of Toronto RESCU traffic cameras — downtown +arterials plus the Gardiner, DVP, Allen and Lake Shore, which the Ontario 511 +pack does not cover. The server reads the keyless camera list the City +publishes on its open data portal (`tmcearthcameras.json`, served as JSONP). +The list has no URL field: frame URLs are built from each validated, digits-only +camera number on the fixed origin +`https://opendata.toronto.ca/transportation/tmc/rescucameraimages/CameraImages/`. +The feed has no compass data, so headings are low-confidence priors. Some +cameras return a 200 "Image Unavailable" placeholder frame instead of an error. + +By default all ~336 cameras load, nearest downtown first. +`CCTV_TORONTO_MAX_SOURCES` sets the pack cap (8–500) and +`CCTV_TORONTO_ENABLED=0` turns the pack off. The pack shares the 4,000 +catalog-wide ceiling round-robin with the other packs. ## DriveBC CCTV source pack @@ -3192,7 +3210,7 @@ its criteria cannot be silently ignored. | Satellites | CelesTrak | `src/data/satellites.js` | `/api/celestrak` | 120s | | Space Missions (30d) | Launch Library 2 + CelesTrak | `src/data/rocketLaunches.js` | `/api/launches` + `/api/celestrak/active` | 5 min | | Traffic | Selectable TomTom / OpenStreetMap / Hybrid roads; optional TomTom flow (BYOK) | `src/data/traffic.js` | browser-direct OpenFreeMap tiles; `/api/tomtom` for flow | viewport-driven; capped tile cache | -| CCTV | Austin + Caltrans (CA) + TfL London + Ontario 511 + Fintraffic (FI) + DriveBC (BC) + TxDOT (TX) + Estonia (Tallinn, Tarktee) + Live Traffic NSW + Open Calgary Open Data + Statens vegvesen (NO, stills + live HLS) + WSDOT (WA) Open Data + NYC DOT TMC (opt-in) + Street View fallback | `src/data/cctv.js` | `/api/cctv` | 10s (active) | +| CCTV | Austin + Caltrans (CA) + TfL London + Ontario 511 + Fintraffic (FI) + DriveBC (BC) + TxDOT (TX) + Estonia (Tallinn, Tarktee) + Live Traffic NSW + Open Calgary Open Data + Statens vegvesen (NO, stills + live HLS) + King County (WA) Open Data + WSDOT (WA) Open Data + NYC DOT TMC (opt-in) + City of Toronto RESCU + Street View fallback | `src/data/cctv.js` | `/api/cctv` | 10s (active) | | Radio | Radio Browser (public-domain station directory) | `src/data/radio.js` | `/api/radio/stations`, `/api/radio/click/:uuid` | 45 min directory refresh | | Transit 🚌 | Operator GTFS-Realtime VehiclePositions (7 keyless regions, `src/data/transitFeeds.js`) | `src/layers/transit/` via `src/app/layers/transit.js` | `/api/transit` | 15s (poll + delayed playback) | | Bikeshare 🚲 | GBFS (Lyft + BCycle + Social Bicycles + PBSC incl. Bike Share Toronto + Urban Sharing, Entur, JCDecaux NO) | `src/data/bikeshare.js` | `/api/gbfs` | 60s | diff --git a/server/providers/cctv.js b/server/providers/cctv.js index 9cf3b0c47..291fcbeef 100644 --- a/server/providers/cctv.js +++ b/server/providers/cctv.js @@ -164,6 +164,8 @@ export function cctvProxy({ sourceRoot = process.cwd() } = {}) { sourceKind: source.sourceKind || (source.url ? 'configured' : 'fallback'), poseSource: source.poseSource, + model: source.model || '', + manufacturer: source.manufacturer || '', license: source.license, credit: source.credit || '', code: source.code || '', diff --git a/server/providers/cctv/catalog.js b/server/providers/cctv/catalog.js index 5963beac0..d9640006f 100644 --- a/server/providers/cctv/catalog.js +++ b/server/providers/cctv/catalog.js @@ -18,9 +18,11 @@ import { loadNswSourcesFromOpenData, loadCalgarySourcesFromOpenData, loadDelDOTSourcesFromOpenData, + loadKingCountySourcesFromOpenData, loadWsdotSourcesFromOpenData, loadVegvesenSourcesFromOpenData, loadNycSourcesFromOpenData, + loadTorontoSourcesFromOpenData, } from './sources.js'; /** Env kill switch: unset or anything but "0" means enabled. */ @@ -98,6 +100,11 @@ const LIVE_PACKS = [ enabled: () => envEnabled('CCTV_DELDOT_ENABLED'), load: loadDelDOTSourcesFromOpenData, }, + { + name: 'kingcounty', + enabled: () => envEnabled('CCTV_KINGCOUNTY_ENABLED'), + load: loadKingCountySourcesFromOpenData, + }, { name: 'wsdot', enabled: () => envEnabled('CCTV_WSDOT_ENABLED'), @@ -115,6 +122,11 @@ const LIVE_PACKS = [ enabled: () => envOptIn('CCTV_NYC_ENABLED'), load: loadNycSourcesFromOpenData, }, + { + name: 'toronto', + enabled: () => envEnabled('CCTV_TORONTO_ENABLED'), + load: loadTorontoSourcesFromOpenData, + }, ]; /** * Load CCTV sources from a local JSON file (CCTV_SOURCES_FILE env or default). diff --git a/server/providers/cctv/constants.js b/server/providers/cctv/constants.js index 883fb0b47..cb01909aa 100644 --- a/server/providers/cctv/constants.js +++ b/server/providers/cctv/constants.js @@ -306,6 +306,61 @@ export const DELDOT_ANCHORS = [ { lat: 38.6906, lon: -75.3877 }, // Georgetown (Sussex) ]; +/** King County, WA road cameras: keyless public ArcGIS FeatureServer layer + * ("King County and WSDOT Traffic Cameras", King County DOT Road Services). + * GeoJSON with WGS84 point geometry. `outFields` is an explicit list on + * purpose: the layer also carries asset-administration columns (including + * staff names in `ModifiedBy`) that must never be fetched. Uniquely among the + * packs, the county publishes each camera's hardware `Manufacturer`/`Model` + * (Cohu 3950/3965, Bosch AUTODOME, Axis Q6135-LE, …), carried through as the + * source's `model`. */ +export const KING_COUNTY_CAMERAS_URL = + 'https://services.arcgis.com/Ej0PsM5Aw677QF1W/arcgis/rest/services/TRAFFICCAMERA_POINT_2029/FeatureServer/0/query?where=1%3D1&outFields=AssetID,Location,ImageURL,Live,Model,Manufacturer,Owner,CurrentStatus&f=geojson'; +/** Frames come only from the county's own image handler host. */ +export const KING_COUNTY_IMAGE_ORIGIN = 'https://info.kingcounty.gov/'; +/** The whole catalog is ~125 rows (~59 live county cameras); no thinning by + * default. */ +export const DEFAULT_KING_COUNTY_MAX_SOURCES = 125; +/** Prioritization anchor: Renton, roughly central to the county road network. */ +export const KING_COUNTY_ANCHORS = [{ lat: 47.4829, lon: -122.2171 }]; +/** Hard ceiling on the King County catalog body. The whole layer is ~125 rows + * and well under 100 KB; this only exists so an upstream that streams an + * unbounded body cannot be buffered without limit. */ +export const KING_COUNTY_MAX_CATALOG_BYTES = 1024 * 1024; +/** + * City of Toronto RESCU traffic cameras: the municipal network the province's + * 511 pack does not cover — downtown arterials plus the Gardiner, DVP, Allen + * and Lake Shore. One keyless list for the whole city (~336 cameras), from the + * City's open data portal. It is fetched on every catalog refresh, but the + * upstream file is not updated often and may lag the live camera network. + * + * The list is served as JSONP (`jsonTMCEarthCamerasCallback({...})`); the + * portal publishes the same data as .xml and .csv beside it. + */ +export const TORONTO_RESCU_LIST_URL = + 'https://opendata.toronto.ca/transportation/tmc/rescucameraimages/Data/tmcearthcameras.json'; +/** + * The only origin Toronto camera frames may come from. The list carries no URL + * field: frame URLs are BUILT from this origin and a strictly-digits camera + * number (`loc####.jpg`, the convention the dataset documents), so no upstream + * field can steer the frame proxy off-host. + */ +export const TORONTO_RESCU_IMAGE_ORIGIN = + 'https://opendata.toronto.ca/transportation/tmc/rescucameraimages/CameraImages/'; +/** The whole city fits under this; the cap exists to stay tunable, not to trim. */ +export const DEFAULT_TORONTO_MAX_SOURCES = 336; +/** Yonge / Queen: the prioritization anchor. */ +export const TORONTO_DOWNTOWN = { lat: 43.6532, lon: -79.3832 }; +/** The city climbs from 76 m at the lake to 209 m at Steeles, so no single + * number fits: this is the mean across the 336 camera sites. The ground-height + * sidecar has no Toronto entries yet, so this prior seeds placement; a camera + * that gains a sidecar entry uses it instead, and the client's ground snap + * corrects the prior wherever 3D tiles are loaded. */ +export const TORONTO_GROUND_ELEVATION_M = 116; +/** Hard ceiling on the RESCU list body. The whole city is ~336 rows and under + * 60 KB; this only exists so an upstream that streams an unbounded body cannot + * be buffered without limit. */ +export const TORONTO_MAX_CATALOG_BYTES = 4 * 1024 * 1024; /** WSDOT Travel Center cameras (Washington State): keyless Esri JSON on the * official open-data host — ~1,700 point features in EPSG:3857 (Web Mercator), * ETag/Last-Modified served. WSDOT's metadata marks the feed "low volume" use; diff --git a/server/providers/cctv/normalize.js b/server/providers/cctv/normalize.js index 99b685f44..e399070c9 100644 --- a/server/providers/cctv/normalize.js +++ b/server/providers/cctv/normalize.js @@ -562,5 +562,30 @@ export function normalizeSourceItem(item) { // badge can distinguish them from raw automated priors (e.g. Austin Open // Data, which never sets this field). Passed through as-is to the client. poseSource: item.poseSource === 'curated' ? 'curated' : undefined, + // Optional hardware-model passthrough (additive, like poseSource): packs + // whose catalog publishes the camera's hardware model — King County's + // layer carries Manufacturer/Model per camera — pass it through so + // identified-hardware consumers can use it. Absent everywhere else. + model: + typeof item.model === 'string' && item.model.trim() + ? item.model.trim() + : undefined, + // Bare model strings collide across vendors (e.g. "3950"), so the + // publishing pack's manufacturer rides along for disambiguation. + manufacturer: + typeof item.manufacturer === 'string' && item.manufacturer.trim() + ? item.manufacturer.trim() + : undefined, }; } + +/** City of Toronto bounding box (Steeles to the lake, Etobicoke to Scarborough). */ +export function isLikelyTorontoCoordinate(lat, lon) { + return ( + isPlausibleLatLon(lat, lon) && + lat >= 43.55 && + lat <= 43.9 && + lon >= -79.7 && + lon <= -79.1 + ); +} diff --git a/server/providers/cctv/sources.js b/server/providers/cctv/sources.js index 56673014e..155442600 100644 --- a/server/providers/cctv/sources.js +++ b/server/providers/cctv/sources.js @@ -55,10 +55,21 @@ import { DEFAULT_CALGARY_MAX_SOURCES, CALGARY_DOWNTOWN, CALGARY_MAX_CATALOG_BYTES, + TORONTO_RESCU_LIST_URL, + TORONTO_RESCU_IMAGE_ORIGIN, + DEFAULT_TORONTO_MAX_SOURCES, + TORONTO_DOWNTOWN, + TORONTO_GROUND_ELEVATION_M, + TORONTO_MAX_CATALOG_BYTES, CCTV_SOURCE_FETCH_TIMEOUT_MS, DELDOT_CCTV_URL, DEFAULT_DELDOT_MAX_SOURCES, DELDOT_ANCHORS, + KING_COUNTY_CAMERAS_URL, + KING_COUNTY_IMAGE_ORIGIN, + DEFAULT_KING_COUNTY_MAX_SOURCES, + KING_COUNTY_ANCHORS, + KING_COUNTY_MAX_CATALOG_BYTES, WSDOT_CAMERAS_URL, WSDOT_IMAGE_ORIGIN, DEFAULT_WSDOT_MAX_SOURCES, @@ -96,6 +107,7 @@ import { isLikelyCalgaryCoordinate, isLikelyNycCoordinate, isLikelyNorwayCoordinate, + isLikelyTorontoCoordinate, cameraDisplayCode, rowArrayToObject, prioritizeSources, @@ -104,6 +116,7 @@ import { directionToHeading } from '../../../src/data/directionText.js'; import { readResponseBytesCapped, readResponseJsonCapped, + readResponseTextCapped, } from '../common/http.js'; /** * Fetch and parse Austin traffic camera records from the city Open Data portal. @@ -1725,6 +1738,165 @@ export async function loadDelDOTSourcesFromOpenData() { } } +/** Rough King County, WA bounding box. */ +function isLikelyKingCountyCoordinate(lat, lon) { + return ( + Number.isFinite(lat) && + Number.isFinite(lon) && + lat >= 47.0 && + lat <= 48.0 && + lon >= -123.1 && + lon <= -121.0 + ); +} + +/** + * A King County `Model` value, whitespace-collapsed, or '' when it is a + * vendor-generic string ("PTZ", "PTZ IP", "BOSCH/PTZ") that names no model. + */ +function kingCountyModel(raw) { + const model = String(raw || '') + .replace(/\s+/g, ' ') + .trim(); + return /^(?:[a-z]+\/)?ptz(?: ip)?$/i.test(model) ? '' : model; +} + +/** + * Fetch King County road cameras (Washington State). Keyless: one public + * ArcGIS FeatureServer GeoJSON query (King County DOT Road Services), with an + * explicit `outFields` list so the layer's asset-administration columns are + * never fetched. Only cameras that are live and active (`Live`, + * `CurrentStatus`) with a positive integer id, finite in-county coordinates, + * and a frame on the county's own image handler are kept. WSDOT-owned rows in + * the layer are skipped because their frames are WSDOT-hosted, outside the + * pinned image origin, while partner-city cameras hosted on the county image + * handler (e.g. Newcastle) name their owner as the per-camera credit, + * DriveBC-style. The layer publishes no facing, so every heading is the id + * hash at low confidence. + * + * Uniquely among the packs, the county publishes each camera's hardware + * `Manufacturer`/`Model`; the model string (whitespace-collapsed — the feed + * carries stray newlines) rides along as the source's `model` for + * identified-hardware consumers. Vendor-generic strings ("PTZ", "PTZ IP", + * "BOSCH/PTZ") name no model and are treated as absent. + * + * @returns {Promise>} Normalized camera source objects. + */ +export async function loadKingCountySourcesFromOpenData() { + try { + const resp = await fetch(KING_COUNTY_CAMERAS_URL, { + headers: { Accept: 'application/json' }, + redirect: 'manual', + signal: AbortSignal.timeout(CCTV_SOURCE_FETCH_TIMEOUT_MS), + }); + // A response this loader will not read still owns its transport until the + // body is released, so every rejection path cancels before returning. + const discard = async () => { + try { + await resp.body?.cancel(); + } catch { + /* no-op */ + } + return []; + }; + if (resp.status >= 300 && resp.status < 400) { + console.warn( + '[CCTV] King County catalog redirected; redirects are not followed', + ); + return discard(); + } + if (!resp.ok) { + console.warn('[CCTV] King County camera download failed:', resp.status); + return discard(); + } + const payload = await readResponseJsonCapped( + resp, + KING_COUNTY_MAX_CATALOG_BYTES, + ); + const rows = Array.isArray(payload?.features) ? payload.features : []; + + const cameras = []; + const seen = new Set(); + for (const row of rows) { + const attrs = row?.properties; + const rawId = attrs?.AssetID; + if (!Number.isSafeInteger(rawId) || rawId <= 0) continue; + if (attrs.Live !== 1) continue; + if (String(attrs.CurrentStatus || '').trim() !== 'Active') continue; + const owner = String(attrs.Owner || '').trim(); + // WSDOT-owned rows serve WSDOT-hosted frames, outside the pinned + // county image origin, so they are skipped. + if (owner === 'WSDOT') continue; + // The handler is served over HTTPS; the feed still writes http://. + const imageUrl = String(attrs.ImageURL || '') + .trim() + .replace(/^http:\/\/info\.kingcounty\.gov\//, KING_COUNTY_IMAGE_ORIGIN); + if (!imageUrl.startsWith(KING_COUNTY_IMAGE_ORIGIN)) continue; + const [lon, lat] = Array.isArray(row?.geometry?.coordinates) + ? row.geometry.coordinates + : []; + if (!isLikelyKingCountyCoordinate(lat, lon)) continue; + + const cameraId = `kingcounty-${rawId}`; + if (seen.has(cameraId)) continue; + seen.add(cameraId); + const model = kingCountyModel(attrs.Model); + const manufacturer = String(attrs.Manufacturer || '') + .replace(/\s+/g, ' ') + .trim(); + const camera = { + id: cameraId, + name: + String(attrs.Location || '').trim() || `King County camera ${rawId}`, + city: 'King County', + cityId: 'king-county', + provider: 'King County Road Services', + lat, + lon, + headingDeg: fallbackHeadingFromId(cameraId), + headingConfidence: 'low', + // The low-confidence pose personality shared by the other packs. + pitchDeg: -18, + fovDeg: 44, + rangeM: 145, + mountHeightM: 8, + feedType: 'image', + url: imageUrl, + snapshotUrl: imageUrl, + sourceKind: 'kingcounty-open-data', + license: 'King County GIS open data (KCGIS Center terms of use)', + credit: owner && owner !== 'King County' ? owner : '', + }; + if (model) camera.model = model; + if (model && manufacturer) camera.manufacturer = manufacturer; + cameras.push(camera); + } + + const maxRaw = Number( + process.env.CCTV_KINGCOUNTY_MAX_SOURCES || + DEFAULT_KING_COUNTY_MAX_SOURCES, + ); + const maxCount = Number.isFinite(maxRaw) + ? Math.max(8, Math.min(1200, Math.floor(maxRaw))) + : DEFAULT_KING_COUNTY_MAX_SOURCES; + const prioritized = prioritizeSources( + cameras, + maxCount, + KING_COUNTY_ANCHORS, + ); + console.log( + `[CCTV] Loaded King County camera sources: ${cameras.length} published (using nearest ${prioritized.length})`, + ); + return prioritized; + } catch (error) { + console.warn( + '[CCTV] King County camera download error:', + error?.message || error, + ); + return []; + } +} + /** WSDOT `CompassDirection` codes as headings in degrees. The live feed sends * single cardinals (N/E/S/W), `B` (both directions — most rows), `O`, and * null; the diagonals are mapped in case they appear. `B`, `O`, null, and any @@ -2178,3 +2350,172 @@ export async function loadNycSourcesFromOpenData() { return []; } } + +/** + * The JSONP envelope the City of Toronto wraps its camera list in. Anchored at + * both ends, so only that exact callback is unwrapped — a payload that merely + * contains the name somewhere is not treated as the list. + */ +const RESCU_JSONP = /^jsonTMCEarthCamerasCallback\(([\s\S]*)\)\s*;?$/; + +/** + * Unwrap the RESCU camera list. The portal serves the list as JSONP; should it + * ever drop the wrapper, the bare JSON document still parses. Anything else — + * a foreign callback, a truncated body, an error page — yields no cameras + * rather than a thrown loader. + * + * @param {string} text - Raw response body. + * @returns {Array} The `Data` rows, or [] when the body is unusable. + */ +export function parseRescuCameraList(text) { + const body = String(text ?? '').trim(); + if (!body) return []; + const unwrapped = RESCU_JSONP.exec(body)?.[1] ?? body; + try { + const parsed = JSON.parse(unwrapped); + const rows = parsed?.Data ?? parsed?.data; + return Array.isArray(rows) ? rows : []; + } catch { + return []; + } +} + +/** + * Convert one RESCU list row into a camera source. + * + * The row carries no URL: the frame URL is built from the documented + * `loc####.jpg` convention and a camera number validated as plain digits, so + * the frame proxy is pinned to the city origin by construction and no upstream + * field — present or planted — can steer it. + * + * No compass heading exists in this dataset. `D1`-`D4` are the directions of + * the *comparison* images (static reference stills captured in 2016, served + * from a different path); the live frame is one pan-tilt-zoom camera pointing + * wherever the operator left it. Treating those letters as a facing would put + * a confident, wrong bearing on every camera in the city, so every row takes + * the id-hash fallback and the low-confidence pose, as headingless Austin, + * TfL, Fintraffic and Calgary cameras do. + * + * @param {object} row - One entry from the RESCU `Data` array. + * @returns {object|null} Normalized camera source, or null when unusable. + */ +export function torontoCameraToSource(row) { + if (!row || typeof row !== 'object') return null; + const number = String(row.Number ?? row.number ?? '').trim(); + // Plain digits only: a number is about to become a URL path segment. + if (!/^\d{1,6}$/.test(number)) return null; + + const lat = toFiniteNumber(row.Latitude ?? row.latitude); + const lon = toFiniteNumber(row.Longitude ?? row.longitude); + if (!isLikelyTorontoCoordinate(lat, lon)) return null; + + const cameraId = `toronto-${number}`; + // The feed's own label, verbatim. It is upper-case ("MCCOWAN RD", "ST + // HELEN'S AVE"); title-casing it would mangle more names than it fixed. + const name = + String(row.Name ?? row.name ?? '') + .replace(/\s+/g, ' ') + .trim() || `Toronto Camera ${number}`; + + return { + id: cameraId, + name, + city: 'Toronto', + cityId: 'toronto', + provider: 'City of Toronto', + lat, + lon, + headingDeg: fallbackHeadingFromId(cameraId), + headingConfidence: 'low', + pitchDeg: -18, + fovDeg: 44, + rangeM: 145, + mountHeightM: 8, + groundElevationM: TORONTO_GROUND_ELEVATION_M, + feedType: 'image', + url: `${TORONTO_RESCU_IMAGE_ORIGIN}loc${number}.jpg`, + snapshotUrl: `${TORONTO_RESCU_IMAGE_ORIGIN}loc${number}.jpg`, + sourceKind: 'toronto-rescu-open-data', + license: + 'Contains information licensed under the Open Government Licence – Toronto', + // Unselected-label code: the intersection, so a camera at rest reads as a + // place rather than as its id. + code: cameraDisplayCode(name.toUpperCase()), + }; +} + +/** + * Fetch City of Toronto RESCU traffic cameras from the City's open data + * portal, keyless. One JSONP list for the whole city; frames are stills on the + * same portal origin. + * + * The list fetch refuses redirects (`redirect: 'manual'`) so the list host + * cannot be steered, and caps the body it will buffer. + * + * Attribution: Open Government Licence – Toronto, registered in + * src/data/dataCredits.js. + * + * @returns {Promise>} Normalized camera source objects. + */ +export async function loadTorontoSourcesFromOpenData() { + try { + const endpoint = + process.env.CCTV_TORONTO_LIST_URL || TORONTO_RESCU_LIST_URL; + const resp = await fetch(endpoint, { + headers: { Accept: 'application/json, text/javascript' }, + redirect: 'manual', + signal: AbortSignal.timeout(CCTV_SOURCE_FETCH_TIMEOUT_MS), + }); + // A response this loader will not read still owns its transport until the + // body is released, so every rejection path cancels before returning. + const discard = async () => { + try { + await resp.body?.cancel(); + } catch { + /* no-op */ + } + return []; + }; + if (resp.status >= 300 && resp.status < 400) { + console.warn( + '[CCTV] Toronto camera list redirected; redirects are not followed', + ); + return discard(); + } + if (!resp.ok) { + console.warn('[CCTV] Toronto camera download failed:', resp.status); + return discard(); + } + const text = await readResponseTextCapped(resp, TORONTO_MAX_CATALOG_BYTES); + const rows = parseRescuCameraList(text); + if (!rows.length) return []; + + const cameras = []; + const seen = new Set(); + for (const record of rows) { + const camera = torontoCameraToSource(record); + if (!camera || seen.has(camera.id)) continue; + seen.add(camera.id); + cameras.push(camera); + } + const maxRaw = Number( + process.env.CCTV_TORONTO_MAX_SOURCES || DEFAULT_TORONTO_MAX_SOURCES, + ); + const maxCount = Number.isFinite(maxRaw) + ? Math.max(8, Math.min(500, Math.floor(maxRaw))) + : DEFAULT_TORONTO_MAX_SOURCES; + const prioritized = prioritizeSources(cameras, maxCount, [ + TORONTO_DOWNTOWN, + ]); + console.log( + `[CCTV] Loaded Toronto camera sources: ${cameras.length} (using nearest ${prioritized.length})`, + ); + return prioritized; + } catch (error) { + console.warn( + '[CCTV] Toronto camera download error:', + error?.message || error, + ); + return []; + } +} diff --git a/src/data/cctvKingCountySource.test.mjs b/src/data/cctvKingCountySource.test.mjs new file mode 100644 index 000000000..5da0ae708 --- /dev/null +++ b/src/data/cctvKingCountySource.test.mjs @@ -0,0 +1,367 @@ +import { test } from 'node:test'; +import assert from 'node:assert/strict'; +import { mkdtempSync, rmSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import path from 'node:path'; +import { + DEFAULT_KING_COUNTY_MAX_SOURCES, + KING_COUNTY_CAMERAS_URL, + KING_COUNTY_MAX_CATALOG_BYTES, +} from '../../server/providers/cctv/constants.js'; +import { loadKingCountySourcesFromOpenData } from '../../server/providers/cctv/sources.js'; +import { normalizeSourceItem } from '../../server/providers/cctv/normalize.js'; +import { cctvProxy } from '../../server/providers/cctv.js'; +import { createCatalog } from '../layers/cctv/catalog.js'; + +/** Set (or, for `undefined`, delete) environment variables for one test. */ +function withEnv(t, env) { + for (const [name, value] of Object.entries(env)) { + const previous = process.env[name]; + t.after(() => { + if (previous === undefined) delete process.env[name]; + else process.env[name] = previous; + }); + if (value === undefined) delete process.env[name]; + else process.env[name] = value; + } +} + +/** Silence the loaders' progress and failure logging. */ +function quiet(t) { + t.mock.method(console, 'log', () => {}); + t.mock.method(console, 'warn', () => {}); +} + +/** A FeatureServer GeoJSON feature carrying the fields the loader reads. */ +function kingCountyFeature(id, lat, lon, overrides = {}) { + const { properties = {}, geometry } = overrides; + return { + type: 'Feature', + geometry: + geometry === undefined + ? { type: 'Point', coordinates: [lon, lat] } + : geometry, + properties: { + AssetID: id, + Location: `Road ${id} at Test Ave`, + ImageURL: `http://info.kingcounty.gov/transportation/kcdot/Roads/TrafficCameras/ImageHandler/Handler.ashx?id=cam${id}.jpg`, + Live: 1, + Model: '3950', + Manufacturer: 'Cohu', + Owner: 'King County', + CurrentStatus: 'Active', + ...properties, + }, + }; +} + +test('King County loader keeps live county cameras and upgrades frame URLs to HTTPS', async (t) => { + quiet(t); + withEnv(t, { CCTV_KINGCOUNTY_MAX_SOURCES: undefined }); + const requested = []; + t.mock.method(globalThis, 'fetch', async (url) => { + requested.push(String(url)); + return Response.json({ + type: 'FeatureCollection', + features: [ + kingCountyFeature(56, 47.70059, -122.02443, { + properties: { + Location: 'NE Novelty Hill Road at Trilogy Parkway NE', + // The live layer carries stray whitespace in model strings. + Model: 'Q6135-LE\n', + Manufacturer: 'Axis', + }, + }), + // City-owned camera the county hosts: kept, owner becomes the credit. + kingCountyFeature(90, 47.674, -122.119, { + properties: { Owner: 'City of Newcastle', Model: null }, + }), + // WSDOT-owned row: its frames are WSDOT-hosted, so it is skipped. + kingCountyFeature(70, 47.6, -122.3, { properties: { Owner: 'WSDOT' } }), + // Off-host frame, not live, retired, bad id, bad geometry, out of county. + kingCountyFeature(71, 47.6, -122.3, { + properties: { ImageURL: 'https://example.com/cam71.jpg' }, + }), + kingCountyFeature(72, 47.6, -122.3, { properties: { Live: 0 } }), + kingCountyFeature(73, 47.6, -122.3, { + properties: { CurrentStatus: 'Retired' }, + }), + kingCountyFeature('74', 47.6, -122.3), + kingCountyFeature(75, 47.6, -122.3, { geometry: null }), + kingCountyFeature(76, 34.05, -118.24), + ], + }); + }); + + const cameras = await loadKingCountySourcesFromOpenData(); + + assert.deepEqual(requested, [KING_COUNTY_CAMERAS_URL]); + assert.deepEqual(cameras.map((camera) => camera.id).sort(), [ + 'kingcounty-56', + 'kingcounty-90', + ]); + + const novelty = cameras.find((camera) => camera.id === 'kingcounty-56'); + assert.equal(novelty.name, 'NE Novelty Hill Road at Trilogy Parkway NE'); + assert.equal(novelty.provider, 'King County Road Services'); + assert.equal( + novelty.url, + 'https://info.kingcounty.gov/transportation/kcdot/Roads/TrafficCameras/ImageHandler/Handler.ashx?id=cam56.jpg', + ); + assert.equal(novelty.snapshotUrl, novelty.url); + assert.equal(novelty.feedType, 'image'); + // Published hardware model rides along, whitespace-collapsed. + assert.equal(novelty.model, 'Q6135-LE'); + assert.equal(novelty.manufacturer, 'Axis'); + assert.equal(novelty.credit, ''); + // No facing in the layer: id-hash fallback at low confidence. + assert.equal(novelty.headingConfidence, 'low'); + assert.equal(novelty.fovDeg, 44); + assert.ok(novelty.headingDeg >= 0 && novelty.headingDeg < 360); + + const newcastle = cameras.find((camera) => camera.id === 'kingcounty-90'); + assert.equal(newcastle.credit, 'City of Newcastle'); + assert.equal(newcastle.model, undefined); + // A manufacturer without a model identifies nothing, so it is dropped too. + assert.equal(newcastle.manufacturer, undefined); +}); + +test('normalizeSourceItem passes a hardware model through and omits it otherwise', () => { + const withModel = normalizeSourceItem({ + id: 'kingcounty-56', + lat: 47.7, + lon: -122.0, + model: ' Q6135-LE ', + manufacturer: ' Axis ', + }); + assert.equal(withModel.model, 'Q6135-LE'); + assert.equal(withModel.manufacturer, 'Axis'); + + const withoutModel = normalizeSourceItem({ + id: 'austin-1', + lat: 30.3, + lon: -97.7, + }); + assert.equal(withoutModel.model, undefined); + assert.equal(withoutModel.manufacturer, undefined); + assert.equal(normalizeSourceItem({ id: 'x', model: ' ' }).model, undefined); +}); + +/** Drive the real `/api/cctv/sources` middleware and return its parsed body. */ +async function requestSources(plugin) { + let handler; + plugin.configureServer({ + middlewares: { + use(_route, fn) { + handler = fn; + }, + }, + }); + const res = { + writeHead(status, headers) { + Object.assign(this, { status, headers }); + }, + end(body) { + this.body = body; + }, + }; + await handler({ url: '/sources', method: 'GET' }, res); + assert.equal(res.status, 200); + return JSON.parse(res.body); +} + +/** The browser catalog with the pose math stubbed out: only field + * passthrough is under test here. */ +function browserCatalog() { + const model = { + safeNumber: (value, fallback = NaN) => + Number.isFinite(Number(value)) ? Number(value) : fallback, + normalizeHeading: (deg) => ((deg % 360) + 360) % 360, + clamp: (value, lo, hi) => Math.min(hi, Math.max(lo, value)), + headingFromId: () => 0, + normalizeFeedType: (type) => type, + ensureCameraPose: () => {}, + }; + return createCatalog({ + state: {}, + services: { locations: { CITY_POIS: {} } }, + parts: { model }, + source: {}, + }); +} + +test('King County model and manufacturer survive the /api/cctv/sources boundary into the browser catalog', async (t) => { + quiet(t); + const root = mkdtempSync(path.join(tmpdir(), 'gev-kingcounty-')); + t.after(() => rmSync(root, { recursive: true, force: true })); + // No file/env catalog, so the live packs load; every pack but King County + // sees an upstream failure and contributes nothing. + withEnv(t, { + CCTV_SOURCES_FILE: undefined, + CCTV_SOURCES_JSON: undefined, + CCTV_FORCE_AUSTIN: undefined, + CCTV_PREFER_AUSTIN: undefined, + CCTV_KINGCOUNTY_ENABLED: undefined, + CCTV_KINGCOUNTY_MAX_SOURCES: undefined, + CCTV_MAX_SOURCES: undefined, + }); + t.mock.method(globalThis, 'fetch', async (url) => { + if (String(url) !== KING_COUNTY_CAMERAS_URL) + return new Response('', { status: 503 }); + return Response.json({ + type: 'FeatureCollection', + features: [ + kingCountyFeature(56, 47.70059, -122.02443, { + properties: { Model: 'Q6135-LE\n', Manufacturer: 'Axis' }, + }), + kingCountyFeature(90, 47.674, -122.119, { + properties: { Model: null, Manufacturer: 'Cohu' }, + }), + ], + }); + }); + + const body = await requestSources(cctvProxy({ sourceRoot: root })); + const served = new Map(body.sources.map((source) => [source.id, source])); + assert.deepEqual([...served.keys()].sort(), [ + 'kingcounty-56', + 'kingcounty-90', + ]); + assert.equal(served.get('kingcounty-56').model, 'Q6135-LE'); + assert.equal(served.get('kingcounty-56').manufacturer, 'Axis'); + // Absent hardware is an explicit empty string on the wire, like + // headingConfidence, so consumers never have to probe for the key. + assert.equal(served.get('kingcounty-90').model, ''); + assert.equal(served.get('kingcounty-90').manufacturer, ''); + + const cameras = browserCatalog().buildCatalogFromSources(body.sources); + const byId = new Map(cameras.map((camera) => [camera.id, camera])); + assert.equal(byId.get('kingcounty-56').model, 'Q6135-LE'); + assert.equal(byId.get('kingcounty-56').manufacturer, 'Axis'); + assert.equal(byId.get('kingcounty-90').model, ''); + assert.equal(byId.get('kingcounty-90').manufacturer, ''); +}); + +test('King County loader honors the max-sources cap', async (t) => { + quiet(t); + withEnv(t, { CCTV_KINGCOUNTY_MAX_SOURCES: '8' }); + const features = []; + for (let i = 0; i < 24; i += 1) { + features.push( + kingCountyFeature(100 + i, 47.2 + i * 0.02, -122.4 + i * 0.02), + ); + } + t.mock.method(globalThis, 'fetch', async () => + Response.json({ type: 'FeatureCollection', features }), + ); + + const cameras = await loadKingCountySourcesFromOpenData(); + assert.equal(cameras.length, 8); +}); + +test('King County loader defaults its cap and survives upstream failure', async (t) => { + quiet(t); + withEnv(t, { CCTV_KINGCOUNTY_MAX_SOURCES: undefined }); + assert.equal(DEFAULT_KING_COUNTY_MAX_SOURCES, 125); + + t.mock.method( + globalThis, + 'fetch', + async () => new Response('', { status: 503 }), + ); + assert.deepEqual(await loadKingCountySourcesFromOpenData(), []); + + t.mock.method(globalThis, 'fetch', async () => { + throw new Error('network down'); + }); + assert.deepEqual(await loadKingCountySourcesFromOpenData(), []); +}); + +test('King County loader does not follow a redirected catalog', async (t) => { + quiet(t); + let init; + t.mock.method(globalThis, 'fetch', async (_url, options) => { + init = options; + return new Response( + JSON.stringify({ + type: 'FeatureCollection', + features: [kingCountyFeature(56, 47.70059, -122.02443)], + }), + { status: 302, headers: { Location: 'https://example.com/cams' } }, + ); + }); + + assert.deepEqual(await loadKingCountySourcesFromOpenData(), []); + assert.equal(init.redirect, 'manual'); +}); + +test('King County loader rejects an oversized catalog', async (t) => { + quiet(t); + const features = [kingCountyFeature(56, 47.70059, -122.02443)]; + const body = JSON.stringify({ + type: 'FeatureCollection', + features, + padding: 'x'.repeat(KING_COUNTY_MAX_CATALOG_BYTES), + }); + t.mock.method(globalThis, 'fetch', async () => new Response(body)); + + assert.deepEqual(await loadKingCountySourcesFromOpenData(), []); +}); + +test('King County loader drops duplicate ids before the per-pack cap', async (t) => { + quiet(t); + withEnv(t, { CCTV_KINGCOUNTY_MAX_SOURCES: '8' }); + // Repeats of the camera nearest the anchor would fill an 8-camera cap + // before the second, farther camera if duplicates reached prioritization. + const features = []; + for (let i = 0; i < 10; i += 1) { + features.push(kingCountyFeature(56, 47.4829, -122.2171)); + } + features.push(kingCountyFeature(57, 47.70059, -122.02443)); + t.mock.method(globalThis, 'fetch', async () => + Response.json({ type: 'FeatureCollection', features }), + ); + + const cameras = await loadKingCountySourcesFromOpenData(); + assert.deepEqual(cameras.map((camera) => camera.id).sort(), [ + 'kingcounty-56', + 'kingcounty-57', + ]); +}); + +test('King County loader omits vendor-generic model strings', async (t) => { + quiet(t); + withEnv(t, { CCTV_KINGCOUNTY_MAX_SOURCES: undefined }); + t.mock.method(globalThis, 'fetch', async () => + Response.json({ + type: 'FeatureCollection', + features: [ + kingCountyFeature(61, 47.5, -122.2, { + properties: { Model: 'PTZ', Manufacturer: 'Bosch' }, + }), + kingCountyFeature(62, 47.51, -122.2, { + properties: { Model: 'PTZ IP', Manufacturer: 'Cohu' }, + }), + kingCountyFeature(63, 47.52, -122.2, { + properties: { Model: 'BOSCH/PTZ', Manufacturer: 'Bosch' }, + }), + kingCountyFeature(64, 47.53, -122.2, { + properties: { Model: 'AUTODOME IP 5000', Manufacturer: 'Bosch' }, + }), + ], + }), + ); + + const byId = new Map( + (await loadKingCountySourcesFromOpenData()).map((camera) => [ + camera.id, + camera, + ]), + ); + for (const id of ['kingcounty-61', 'kingcounty-62', 'kingcounty-63']) { + assert.equal(byId.get(id).model, undefined, id); + assert.equal(byId.get(id).manufacturer, undefined, id); + } + assert.equal(byId.get('kingcounty-64').model, 'AUTODOME IP 5000'); + assert.equal(byId.get('kingcounty-64').manufacturer, 'Bosch'); +}); diff --git a/src/data/cctvToronto.test.mjs b/src/data/cctvToronto.test.mjs new file mode 100644 index 000000000..c2e3c0e1d --- /dev/null +++ b/src/data/cctvToronto.test.mjs @@ -0,0 +1,423 @@ +import { test } from 'node:test'; +import assert from 'node:assert/strict'; + +import { + parseRescuCameraList, + torontoCameraToSource, + loadTorontoSourcesFromOpenData, +} from '../../server/providers/cctv/sources.js'; +import { + TORONTO_RESCU_LIST_URL, + TORONTO_RESCU_IMAGE_ORIGIN, + TORONTO_MAX_CATALOG_BYTES, + DEFAULT_CCTV_MAX_SOURCES, +} from '../../server/providers/cctv/constants.js'; +import { CAMERA_CODE_MAX_CHARS } from '../../server/providers/cctv/normalize.js'; +import { allocateSourceCap } from '../../server/providers/cctv/cap.js'; +import { createCctvCatalog } from '../../server/providers/cctv/catalog.js'; + +/** + * A response whose body is a live stream, plus a flag that flips when the + * stream is cancelled. A rejection path that returns without cancelling holds + * the transport open, so the flag is what the refusal tests actually assert. + */ +const streamingResponse = (init = {}) => { + const state = { cancelled: false }; + const body = new ReadableStream({ + start(controller) { + controller.enqueue(new TextEncoder().encode('j')); + }, + cancel() { + state.cancelled = true; + }, + }); + return { response: new Response(body, init), state }; +}; + +/** One RESCU row, shaped like the live `tmcearthcameras.json` payload. */ +const row = (overrides = {}) => ({ + Number: '8048', + Name: 'BATHURST ST & BLOOR ST W', + Latitude: '43.665249', + Longitude: '-79.41114', + D1: 'n', + D2: 'e', + D3: 's', + D4: 'w', + Group: 'Arterial', + ...overrides, +}); + +/** The city wraps the list in a JSONP callback; this is that envelope. */ +const jsonp = (rows) => + `jsonTMCEarthCamerasCallback(${JSON.stringify({ Data: rows })});`; + +test('a RESCU row maps to a source on the constructed frame URL', () => { + const source = torontoCameraToSource(row()); + assert.equal(source.id, 'toronto-8048'); + assert.equal(source.name, 'BATHURST ST & BLOOR ST W'); + assert.equal(source.city, 'Toronto'); + assert.equal(source.cityId, 'toronto'); + assert.equal(source.provider, 'City of Toronto'); + assert.equal(source.lat, 43.665249); + assert.equal(source.lon, -79.41114); + assert.equal(source.feedType, 'image'); + assert.equal(source.sourceKind, 'toronto-rescu-open-data'); + assert.equal( + source.license, + 'Contains information licensed under the Open Government Licence – Toronto', + ); + assert.equal( + source.url, + `${TORONTO_RESCU_IMAGE_ORIGIN}loc8048.jpg`, + 'the documented loc####.jpg convention', + ); + assert.equal(source.url, source.snapshotUrl); + assert.ok(source.url.startsWith(TORONTO_RESCU_IMAGE_ORIGIN)); +}); + +test('the frame URL is built from the camera number, never read from the payload', () => { + // The list carries no URL field at all, so an added one must stay inert: the + // frame proxy is pinned to the city origin by construction. + const planted = torontoCameraToSource( + row({ + url: 'https://evil.example/x.jpg', + snapshotUrl: 'https://evil.example/x.jpg', + Url: 'https://evil.example/x.jpg', + }), + ); + assert.equal(planted.url, `${TORONTO_RESCU_IMAGE_ORIGIN}loc8048.jpg`); + assert.equal(planted.snapshotUrl, planted.url); + + // A number that is not plain digits cannot reach the URL builder: path + // traversal and absolute URLs are refused outright rather than escaped. + for (const Number_ of [ + '../../etc/passwd', + '8048/../../x', + 'https://evil.example/1', + '80 48', + '8048.jpg', + '-8048', + '', + ' ', + null, + ]) { + assert.equal( + torontoCameraToSource(row({ Number: Number_ })), + null, + `refused: ${String(Number_)}`, + ); + } +}); + +test('the comparison directions never become a camera heading', () => { + // D1-D4 are the city's *comparison image* directions (static 2016 reference + // stills served from ComparisonImages/), not a facing for the live frame: + // these cameras pan. The letters read like a compass and map trivially onto + // one (n -> 0, w -> 270), so the temptation to wire them up is real — and a + // heading derived from them would be confidently wrong for every camera in + // the city. Nobody may "fix" this. + const base = torontoCameraToSource(row()); + for (const dirs of [ + { D1: 'n', D2: 'e', D3: 's', D4: 'w' }, + { D1: '', D2: 'e', D3: '', D4: 'w' }, + { D1: '', D2: '', D3: '', D4: '' }, + { D1: 's', D2: '', D3: '', D4: '' }, + ]) { + const source = torontoCameraToSource(row(dirs)); + assert.equal(source.headingConfidence, 'low'); + assert.ok(Number.isFinite(source.headingDeg)); + // Same id, same fallback heading, whatever the directions say. + assert.equal(source.headingDeg, base.headingDeg); + } +}); + +test('the two cameras at one intersection are kept apart', () => { + // 8047 and 8048 are both "BATHURST ST & BLOOR ST W", five metres apart. They + // are distinct units, so both survive, and the id-hash fallback fans their + // gizmos apart instead of stacking them on one bearing. + const a = torontoCameraToSource( + row({ Number: '8047', Latitude: '43.665223', Longitude: '-79.411083' }), + ); + const b = torontoCameraToSource(row()); + assert.equal(a.id, 'toronto-8047'); + assert.equal(b.id, 'toronto-8048'); + assert.notEqual(a.url, b.url); + assert.notEqual(a.headingDeg, b.headingDeg); +}); + +test('rows outside Toronto and unusable geometry are dropped', () => { + // Calgary: a plausible lat/lon, but not a Toronto camera. + assert.equal( + torontoCameraToSource(row({ Latitude: '51.0453', Longitude: '-114.1413' })), + null, + ); + // Null island, and the empty strings that would become it. + assert.equal( + torontoCameraToSource(row({ Latitude: '0', Longitude: '0' })), + null, + ); + assert.equal( + torontoCameraToSource(row({ Latitude: '', Longitude: '' })), + null, + ); + assert.equal( + torontoCameraToSource(row({ Latitude: 'north', Longitude: 'west' })), + null, + ); + assert.equal(torontoCameraToSource({}), null); + assert.equal(torontoCameraToSource(null), null); +}); + +test('a nameless row still gets a label', () => { + const source = torontoCameraToSource(row({ Name: ' ' })); + assert.equal(source.name, 'Toronto Camera 8048'); +}); + +test('the JSONP envelope is unwrapped, and only that envelope', () => { + assert.deepEqual(parseRescuCameraList(jsonp([row()])), [row()]); + // Whitespace and a missing trailing semicolon are both tolerated. + assert.equal( + parseRescuCameraList(`\n ${jsonp([row()]).replace(/;$/, '')} \n`).length, + 1, + ); + // Should the city ever drop the wrapper, the bare document still parses. + assert.equal( + parseRescuCameraList(JSON.stringify({ Data: [row()] })).length, + 1, + ); + + // Anything else yields no cameras rather than a thrown loader. + for (const text of [ + 'otherCallback({"Data":[]})', + 'jsonTMCEarthCamerasCallback(', + 'jsonTMCEarthCamerasCallback({"Data":', + '{"Data":"not-an-array"}', + '{"nope":[]}', + '503', + '', + null, + ]) { + assert.deepEqual(parseRescuCameraList(text), [], `rejected: ${text}`); + } +}); + +test('the loader reads the keyless list and collapses duplicate numbers', async (t) => { + t.mock.method(console, 'log', () => {}); + const requested = []; + t.mock.method(globalThis, 'fetch', async (url) => { + requested.push(String(url)); + return new Response( + jsonp([ + row(), + // Same camera number twice: one camera, not two. + row({ Name: 'BATHURST ST & BLOOR ST W (duplicate)' }), + row({ + Number: '8001', + Name: 'YORK ST & BREMNER BLVD / RAPTORS WAY', + Latitude: '43.643120', + Longitude: '-79.381386', + }), + row({ Number: '../evil' }), + ]), + ); + }); + const cameras = await loadTorontoSourcesFromOpenData(); + assert.deepEqual(requested, [TORONTO_RESCU_LIST_URL]); + assert.deepEqual( + cameras.map((camera) => camera.id), + // Nearest downtown first: York & Bremner is at the core, Bathurst & Bloor + // is three kilometres out. + ['toronto-8001', 'toronto-8048'], + ); + assert.equal(cameras[1].name, 'BATHURST ST & BLOOR ST W'); +}); + +test('an upstream failure yields an empty pack and releases the response', async (t) => { + t.mock.method(console, 'warn', () => {}); + // A 503 can still arrive with a streaming body; returning without cancelling + // it would hold the connection until the socket times out. + const failed = streamingResponse({ status: 503 }); + t.mock.method(globalThis, 'fetch', async () => failed.response); + assert.deepEqual(await loadTorontoSourcesFromOpenData(), []); + assert.equal(failed.state.cancelled, true, 'the failed body is cancelled'); + + t.mock.restoreAll(); + t.mock.method(console, 'warn', () => {}); + t.mock.method(globalThis, 'fetch', async () => { + throw new Error('network down'); + }); + assert.deepEqual(await loadTorontoSourcesFromOpenData(), []); +}); + +test('the list fetch refuses redirects and oversized bodies', async (t) => { + t.mock.method(console, 'warn', () => {}); + // A redirect is never followed: the list host cannot be steered. Its body is + // a live stream, so the test also proves the refusal releases the transport. + const seen = []; + const redirected = streamingResponse({ + status: 302, + headers: { location: 'https://evil.example/cameras.json' }, + }); + t.mock.method(globalThis, 'fetch', async (url, init) => { + seen.push([String(url), init.redirect]); + return redirected.response; + }); + assert.deepEqual(await loadTorontoSourcesFromOpenData(), []); + assert.deepEqual(seen, [[TORONTO_RESCU_LIST_URL, 'manual']]); + assert.equal( + redirected.state.cancelled, + true, + 'the redirect body is cancelled', + ); + + // A body over the cap is refused rather than buffered. + t.mock.restoreAll(); + t.mock.method(console, 'warn', () => {}); + t.mock.method(globalThis, 'fetch', async () => { + return new Response(jsonp([row()]), { + headers: { + 'content-length': String(TORONTO_MAX_CATALOG_BYTES + 1), + }, + }); + }); + assert.deepEqual(await loadTorontoSourcesFromOpenData(), []); + + // So is a body that only declares its size once it is already too long. + t.mock.restoreAll(); + t.mock.method(console, 'warn', () => {}); + t.mock.method(globalThis, 'fetch', async () => { + const oversized = 'x'.repeat(TORONTO_MAX_CATALOG_BYTES + 1024); + return new Response( + new ReadableStream({ + start(controller) { + controller.enqueue(new TextEncoder().encode(oversized)); + controller.close(); + }, + }), + ); + }); + assert.deepEqual(await loadTorontoSourcesFromOpenData(), []); +}); + +test('the unselected label is the intersection, trimmed to the code width', () => { + assert.equal(torontoCameraToSource(row()).code, 'BATHURST ST & BLOOR ST W'); + const long = torontoCameraToSource( + row({ + Name: 'BAYVIEW AVE & POTTERY RD / PRIVATE ACCESS @ 620m SOUTH OF - 550 BAYVIEW AVE (EVERGREEN)', + }), + ); + assert.ok(long.code.length <= CAMERA_CODE_MAX_CHARS); + assert.ok(long.code.endsWith('…')); + assert.ok(long.code.startsWith('BAYVIEW AVE & POTTERY')); +}); + +test('a reduced catalog cap thins every pack instead of dropping Toronto', () => { + // Toronto merges last in LIVE_PACKS, so a positional slice would delete it + // outright. The round-robin allocation must give it its share. + const lane = (name, count) => ({ + name, + sources: Array.from({ length: count }, (_, i) => ({ id: `${name}-${i}` })), + }); + const { sources, packs } = allocateSourceCap( + [lane('austin', 250), lane('calgary', 215), lane('toronto', 336)], + 30, + ); + assert.equal(sources.length, 30); + assert.deepEqual( + packs.map((p) => [p.name, p.kept]), + [ + ['austin', 10], + ['calgary', 10], + ['toronto', 10], + ], + ); + // Toronto contributes its own highest-priority cameras, in its own order. + assert.deepEqual( + sources.filter((s) => s.id.startsWith('toronto-')).map((s) => s.id), + Array.from({ length: 10 }, (_, i) => `toronto-${i}`), + ); +}); + +/** + * Serve the RESCU list to the Toronto endpoint and an empty payload to every + * other pack, so one catalog refresh exercises the registration without + * reaching the network. Returns the URLs that were requested. + */ +const runCatalogWithMockedUpstreams = async (t) => { + const requested = []; + t.mock.method(console, 'log', () => {}); + t.mock.method(console, 'warn', () => {}); + t.mock.method(globalThis, 'fetch', async (url) => { + const href = String(url); + requested.push(href); + if (href === TORONTO_RESCU_LIST_URL) { + return new Response( + jsonp([ + row({ + Number: '8001', + Name: 'YORK ST & BREMNER BLVD / RAPTORS WAY', + Latitude: '43.643120', + Longitude: '-79.381386', + }), + row(), + ]), + ); + } + return Response.json([]); + }); + const sources = await createCctvCatalog({ sourceRoot: '/nonexistent' })(); + return { requested, sources }; +}; + +test('the pack is registered, so its cameras reach the served catalog', async (t) => { + const saved = { ...process.env }; + try { + delete process.env.CCTV_SOURCES_FILE; + delete process.env.CCTV_SOURCES_JSON; + delete process.env.CCTV_TORONTO_ENABLED; + const { requested, sources } = await runCatalogWithMockedUpstreams(t); + assert.ok( + requested.includes(TORONTO_RESCU_LIST_URL), + 'the registered lane reaches its upstream', + ); + assert.deepEqual( + sources.filter((s) => s.cityId === 'toronto').map((s) => s.id), + ['toronto-8001', 'toronto-8048'], + 'Toronto cameras reach the served catalog through the registered lane', + ); + } finally { + for (const key of Object.keys(process.env)) { + if (!(key in saved)) delete process.env[key]; + } + Object.assign(process.env, saved); + } +}); + +test('CCTV_TORONTO_ENABLED=0 keeps the lane from being loaded at all', async (t) => { + const saved = { ...process.env }; + try { + delete process.env.CCTV_SOURCES_FILE; + delete process.env.CCTV_SOURCES_JSON; + process.env.CCTV_TORONTO_ENABLED = '0'; + const { requested, sources } = await runCatalogWithMockedUpstreams(t); + assert.equal( + requested.includes(TORONTO_RESCU_LIST_URL), + false, + 'the disabled lane never reaches its upstream', + ); + assert.deepEqual( + sources.filter((s) => s.cityId === 'toronto'), + [], + ); + } finally { + for (const key of Object.keys(process.env)) { + if (!(key in saved)) delete process.env[key]; + } + Object.assign(process.env, saved); + } +}); + +test('the shipped catalog ceiling is not raised to make room for this pack', () => { + assert.equal(DEFAULT_CCTV_MAX_SOURCES, 4000); +}); diff --git a/src/data/dataCredits.js b/src/data/dataCredits.js index d1cd2b549..35096315b 100644 --- a/src/data/dataCredits.js +++ b/src/data/dataCredits.js @@ -254,6 +254,15 @@ export const DATA_CREDITS = [ 'Traffic cameras (Calgary): contains information licensed under the ' + 'Open Government Licence – City of Calgary', }, + { + key: 'kingcounty-cctv', + html: + 'CCTV cameras & frames (King County, WA): King County Road Services — ' + + 'kingcounty.gov, ' + + 'per the ' + + 'KCGIS Center terms. ' + + 'Partner-city cameras hosted on the county image handler (e.g. Newcastle) name their owner in the CCTV panel.', + }, { key: 'vegvesen-cctv', html: @@ -268,6 +277,12 @@ export const DATA_CREDITS = [ 'NYC DOT Traffic Management Center. ' + NYC_DOT_DISCLAIMER, }, + { + key: 'toronto-cctv', + html: + 'Traffic cameras (Toronto): contains information licensed under the ' + + 'Open Government Licence – Toronto', + }, { key: 'gbfs', html: diff --git a/src/layers/cctv/catalog.js b/src/layers/cctv/catalog.js index 1a6ebe7c6..76d530b11 100644 --- a/src/layers/cctv/catalog.js +++ b/src/layers/cctv/catalog.js @@ -204,6 +204,8 @@ export function createCatalog({ state: layerState, services, parts, source }) { ? source.groundHeights : null, poseSource, + model: String(source.model || ''), + manufacturer: String(source.manufacturer || ''), }; parts.model.ensureCameraPose(camera); catalog.push(camera);