v0.9.5: The Voltron Update — modular architecture, stable IDs, parallelized boot

- Parallelized startup (60s → 15s) via ThreadPoolExecutor - Adaptive polling engine with ETag caching (no more bbox interrupts) - useCallback optimization for interpolation functions - Sliding LAYERS/INTEL edge panels replace bulky Record Panel - Modular fetcher architecture (flights, geo, infrastructure, financial, earth_observation) - Stable entity IDs for GDELT & News popups (PR #63, credit @csysp) - Admin auth (X-Admin-Key), rate limiting (slowapi), auto-updater - Docker Swarm secrets support, env_check.py validation - 85+ vitest tests, CI pipeline, geoJSON builder extraction - Server-side viewport bbox filtering reduces payloads 80%+ Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> Former-commit-id: f2883150b5bc78ebc139d89cc966a76f7d7c0408
2026-06-30 09:45:53 +02:00 · 2026-03-14 14:01:54 -06:00
parent 60c90661d4
commit 90c2e90e2c
63 changed files with 6015 additions and 2756 deletions
@@ -0,0 +1,92 @@
+import { useEffect, useState, useRef } from "react";
+import { API_BASE } from "@/lib/api";
+
+export type BackendStatus = 'connecting' | 'connected' | 'disconnected';
+
+/**
+ * Polls the backend for fast and slow data tiers.
+ *
+ * Matches the proven GitHub polling pattern:
+ *   - Empty useEffect dependency array (no restarts on viewport change)
+ *   - No viewport bbox filtering (full data every poll)
+ *   - Adaptive startup polling (3s retry → 15s/120s steady state)
+ *   - ETag conditional requests for bandwidth savings
+ *   - AbortController for clean unmount
+ */
+export function useDataPolling() {
+  const dataRef = useRef<any>({});
+  const [dataVersion, setDataVersion] = useState(0);
+  const data = dataRef.current;
+
+  const [backendStatus, setBackendStatus] = useState<BackendStatus>('connecting');
+
+  const fastEtag = useRef<string | null>(null);
+  const slowEtag = useRef<string | null>(null);
+
+  useEffect(() => {
+    let hasData = false;
+    let fastTimerId: ReturnType<typeof setTimeout> | null = null;
+    let slowTimerId: ReturnType<typeof setTimeout> | null = null;
+
+    const fetchFastData = async () => {
+      try {
+        const headers: Record<string, string> = {};
+        if (fastEtag.current) headers['If-None-Match'] = fastEtag.current;
+        const res = await fetch(`${API_BASE}/api/live-data/fast`, { headers });
+        if (res.status === 304) { setBackendStatus('connected'); scheduleNext('fast'); return; }
+        if (res.ok) {
+          setBackendStatus('connected');
+          fastEtag.current = res.headers.get('etag') || null;
+          const json = await res.json();
+          dataRef.current = { ...dataRef.current, ...json };
+          setDataVersion(v => v + 1);
+          const flights = json.commercial_flights?.length || 0;
+          if (flights > 100) hasData = true;
+        }
+      } catch (e) {
+        console.error("Failed fetching fast live data", e);
+        setBackendStatus('disconnected');
+      }
+      scheduleNext('fast');
+    };
+
+    const fetchSlowData = async () => {
+      try {
+        const headers: Record<string, string> = {};
+        if (slowEtag.current) headers['If-None-Match'] = slowEtag.current;
+        const res = await fetch(`${API_BASE}/api/live-data/slow`, { headers });
+        if (res.status === 304) { scheduleNext('slow'); return; }
+        if (res.ok) {
+          slowEtag.current = res.headers.get('etag') || null;
+          const json = await res.json();
+          dataRef.current = { ...dataRef.current, ...json };
+          setDataVersion(v => v + 1);
+        }
+      } catch (e) {
+        console.error("Failed fetching slow live data", e);
+      }
+      scheduleNext('slow');
+    };
+
+    // Adaptive polling: retry every 3s during startup, back off to normal cadence once data arrives
+    const scheduleNext = (tier: 'fast' | 'slow') => {
+      if (tier === 'fast') {
+        const delay = hasData ? 15000 : 3000; // 3s startup retry → 15s steady state
+        fastTimerId = setTimeout(fetchFastData, delay);
+      } else {
+        const delay = hasData ? 120000 : 5000; // 5s startup retry → 120s steady state
+        slowTimerId = setTimeout(fetchSlowData, delay);
+      }
+    };
+
+    fetchFastData();
+    fetchSlowData();
+
+    return () => {
+      if (fastTimerId) clearTimeout(fastTimerId);
+      if (slowTimerId) clearTimeout(slowTimerId);
+    };
+  }, []);
+
+  return { data, dataVersion, backendStatus };
+}
@@ -0,0 +1,46 @@
+import { useCallback, useState, useEffect } from "react";
+import { API_BASE } from "@/lib/api";
+import type { RegionDossier, SelectedEntity } from "@/types/dashboard";
+
+export function useRegionDossier(
+  selectedEntity: SelectedEntity | null,
+  setSelectedEntity: (entity: SelectedEntity | null) => void
+) {
+  const [regionDossier, setRegionDossier] = useState<RegionDossier | null>(null);
+  const [regionDossierLoading, setRegionDossierLoading] = useState(false);
+
+  const handleMapRightClick = useCallback(async (coords: { lat: number; lng: number }) => {
+    setSelectedEntity({ type: 'region_dossier', id: `${coords.lat.toFixed(4)}_${coords.lng.toFixed(4)}`, extra: coords });
+    setRegionDossierLoading(true);
+    setRegionDossier(null);
+    try {
+      const [dossierRes, sentinelRes] = await Promise.allSettled([
+        fetch(`${API_BASE}/api/region-dossier?lat=${coords.lat}&lng=${coords.lng}`),
+        fetch(`${API_BASE}/api/sentinel2/search?lat=${coords.lat}&lng=${coords.lng}`),
+      ]);
+      let dossierData: Record<string, unknown> = {};
+      if (dossierRes.status === 'fulfilled' && dossierRes.value.ok) {
+        dossierData = await dossierRes.value.json();
+      }
+      let sentinelData = null;
+      if (sentinelRes.status === 'fulfilled' && sentinelRes.value.ok) {
+        sentinelData = await sentinelRes.value.json();
+      }
+      setRegionDossier({ lat: coords.lat, lng: coords.lng, ...dossierData, sentinel2: sentinelData });
+    } catch (e) {
+      console.error("Failed to fetch region dossier", e);
+    } finally {
+      setRegionDossierLoading(false);
+    }
+  }, [setSelectedEntity]);
+
+  // Clear dossier when selecting a different entity type
+  useEffect(() => {
+    if (selectedEntity?.type !== 'region_dossier') {
+      setRegionDossier(null);
+      setRegionDossierLoading(false);
+    }
+  }, [selectedEntity]);
+
+  return { regionDossier, regionDossierLoading, handleMapRightClick };
+}
@@ -0,0 +1,66 @@
+import { useCallback, useState, useRef } from "react";
+import { GEOCODE_THROTTLE_MS, GEOCODE_DISTANCE_THRESHOLD, GEOCODE_CACHE_SIZE } from "@/lib/constants";
+
+export function useReverseGeocode() {
+  const [mouseCoords, setMouseCoords] = useState<{ lat: number; lng: number } | null>(null);
+  const [locationLabel, setLocationLabel] = useState('');
+  const geocodeCache = useRef<Map<string, string>>(new Map());
+  const geocodeTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const lastGeocodedPos = useRef<{ lat: number; lng: number } | null>(null);
+  const geocodeAbort = useRef<AbortController | null>(null);
+
+  const handleMouseCoords = useCallback((coords: { lat: number; lng: number }) => {
+    setMouseCoords(coords);
+
+    if (geocodeTimer.current) clearTimeout(geocodeTimer.current);
+    geocodeTimer.current = setTimeout(async () => {
+      if (lastGeocodedPos.current) {
+        const dLat = Math.abs(coords.lat - lastGeocodedPos.current.lat);
+        const dLng = Math.abs(coords.lng - lastGeocodedPos.current.lng);
+        if (dLat < GEOCODE_DISTANCE_THRESHOLD && dLng < GEOCODE_DISTANCE_THRESHOLD) return;
+      }
+
+      const gridKey = `${(coords.lat).toFixed(2)},${(coords.lng).toFixed(2)}`;
+      const cached = geocodeCache.current.get(gridKey);
+      if (cached) {
+        setLocationLabel(cached);
+        lastGeocodedPos.current = coords;
+        return;
+      }
+
+      if (geocodeAbort.current) geocodeAbort.current.abort();
+      geocodeAbort.current = new AbortController();
+
+      try {
+        const res = await fetch(
+          `https://nominatim.openstreetmap.org/reverse?lat=${coords.lat}&lon=${coords.lng}&format=json&zoom=10&addressdetails=1`,
+          { headers: { 'Accept-Language': 'en' }, signal: geocodeAbort.current.signal }
+        );
+        if (res.ok) {
+          const data = await res.json();
+          const addr = data.address || {};
+          const city = addr.city || addr.town || addr.village || addr.county || '';
+          const state = addr.state || addr.region || '';
+          const country = addr.country || '';
+          const parts = [city, state, country].filter(Boolean);
+          const label = parts.join(', ') || data.display_name?.split(',').slice(0, 3).join(',') || 'Unknown';
+
+          if (geocodeCache.current.size > GEOCODE_CACHE_SIZE) {
+            const iter = geocodeCache.current.keys();
+            for (let i = 0; i < 100; i++) {
+              const key = iter.next().value;
+              if (key !== undefined) geocodeCache.current.delete(key);
+            }
+          }
+          geocodeCache.current.set(gridKey, label);
+          setLocationLabel(label);
+          lastGeocodedPos.current = coords;
+        }
+      } catch (e: any) {
+        if (e.name !== 'AbortError') { /* Silently fail - keep last label */ }
+      }
+    }, GEOCODE_THROTTLE_MS);
+  }, []);
+
+  return { mouseCoords, locationLabel, handleMouseCoords };
+}