Update app.py

app.py

@@ -1,13 +1,35 @@
-import os, json, time, hashlib
-from fastapi import FastAPI, Request, HTTPException
+import os
+import json
+import time
+import hashlib
+import threading
+from typing import Any, Dict, Optional
+
 import requests
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse
 
-WAKEUP_URL = os.getenv("WAKEUP_URL", "http://163.245.192.149:8080/wakeup/")
+# ----------------------------
+# Config
+# ----------------------------
+WAKEUP_URL = os.getenv("WAKEUP_URL", "http://163.245.192.149:8080/wakeup").strip()
 TIMEOUT = int(os.getenv("RELAY_TIMEOUT", "30"))
 
-app = FastAPI()
+# Flood guard: keep this at 1 until you're 100% sure you're safe
+MAX_INFLIGHT = int(os.getenv("MAX_INFLIGHT", "1"))
+
+# Dedupe cache TTL (seconds). Keep reasonable so it doesn't grow forever.
+SEEN_TTL_SECONDS = int(os.getenv("SEEN_TTL_SECONDS", "86400"))  # 24h default
+
+# How many chars of downstream response to return to caller
+FORWARD_BODY_LIMIT = int(os.getenv("FORWARD_BODY_LIMIT", "2000"))
+
+app = FastAPI(title="Inserio Relay", version="1.0.0")
 
-def norm(v):
+# ----------------------------
+# Helpers
+# ----------------------------
+def norm(v: Any) -> Any:
     if v is None:
         return ""
     if isinstance(v, str):
@@ -15,31 +37,93 @@ def norm(v):
         return "" if s.lower() in ("null", "none") else s
     return v
 
-def compute_fingerprint(payload: dict) -> str:
+def normalize_url(url: str) -> str:
+    """
+    Avoid trailing slash issues. Uvicorn/FastAPI often 307 redirect when trailing
+    slash mismatches the route. We'll send to the canonical version.
+    """
+    return url.rstrip("/")
+
+def compute_fingerprint(payload: Dict[str, Any]) -> str:
     """
     MVP fingerprint: stable hash from fields that should represent the same upload.
-    Upgrade later to sha256(file-bytes) when you have a download URL.
+    NOTE: This is NOT file-bytes fingerprint. That must be done downstream (163 server)
+    after downloading the attachment bytes from QuickBase.
     """
     parts = {
         "rid": norm(payload.get("rid")),
         "file_type": norm(payload.get("file_type")),
         "case_vendor_rid": norm(payload.get("case_vendor_rid")),
+        "case_rid": norm(payload.get("case_rid")),
         "date_modified": norm(payload.get("date_modified")),
     }
     raw = json.dumps(parts, sort_keys=True, separators=(",", ":")).encode("utf-8")
     return hashlib.sha256(raw).hexdigest()
 
-# ultra-light “db” for HF: in-memory set (fine for relay testing)
-SEEN = set()
+# ----------------------------
+# In-memory dedupe store with TTL
+# fp -> last_seen_epoch
+# ----------------------------
+SEEN: Dict[str, float] = {}
+SEEN_LOCK = threading.Lock()
+
+def seen_prune(now: float) -> None:
+    cutoff = now - SEEN_TTL_SECONDS
+    dead = [fp for fp, ts in SEEN.items() if ts < cutoff]
+    for fp in dead:
+        SEEN.pop(fp, None)
+
+def seen_check_and_set(fp: str) -> bool:
+    """
+    Returns True if already seen (duplicate), else records and returns False.
+    """
+    now = time.time()
+    with SEEN_LOCK:
+        seen_prune(now)
+        if fp in SEEN:
+            SEEN[fp] = now
+            return True
+        SEEN[fp] = now
+        return False
+
+# ----------------------------
+# Flood guard semaphore
+# ----------------------------
+INFLIGHT = threading.BoundedSemaphore(value=max(1, MAX_INFLIGHT))
+
+# ----------------------------
+# Routes
+# ----------------------------
+@app.get("/")
+def root():
+    return {
+        "ok": True,
+        "service": "inserio-relay",
+        "post": ["/webhook", "/wakeup"],
+        "forward_to": normalize_url(WAKEUP_URL),
+        "max_inflight": MAX_INFLIGHT,
+        "seen_ttl_seconds": SEEN_TTL_SECONDS,
+    }
+
+@app.get("/health")
+def health():
+    return {"ok": True}
 
 @app.post("/webhook")
 async def webhook(req: Request):
-    payload = await req.json()
+    # Validate JSON
+    try:
+        payload = await req.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="invalid_json")
+
+    if not isinstance(payload, dict):
+        raise HTTPException(status_code=400, detail="payload_must_be_object")
 
     # 1) processing state default
     state = norm(payload.get("sa_processing_state"))
     if not state:
-        payload["sa_processing_state"] = "new"  # null -> new  [oai_citation:3‡API Integration Setup Guide_otter.ai.txt](sediment://file_0000000079e8722fb44223541f5b71cb)
+        payload["sa_processing_state"] = "new"
 
     # 2) fingerprint + dedupe
     fp = norm(payload.get("sa_fingerprint"))
@@ -47,20 +131,36 @@ async def webhook(req: Request):
         fp = compute_fingerprint(payload)
         payload["sa_fingerprint"] = fp
 
-    if fp in SEEN:
+    if seen_check_and_set(fp):
+        # Do not forward duplicates (safe default)
         payload["sa_processing_state"] = "duplicate"
         return {"ok": True, "duplicate": True, "fingerprint": fp}
 
-    SEEN.add(fp)
+    # 3) forward/relay with flood guard
+    if not INFLIGHT.acquire(blocking=False):
+        # You are getting flooded; do NOT forward.
+        # This is the safety brake Mark warned about.
+        raise HTTPException(status_code=429, detail="too_many_inflight_requests")
 
-    # 3) forward/relay
     try:
-        r = requests.post(WAKEUP_URL, json=payload, timeout=TIMEOUT)
+        forward_url = normalize_url(WAKEUP_URL)
+
+        r = requests.post(forward_url, json=payload, timeout=TIMEOUT)
+
         return {
             "ok": True,
-            "forward_status": r.status_code,
-            "forward_body": r.text[:2000],
+            "duplicate": False,
             "fingerprint": fp,
+            "forward_url": forward_url,
+            "forward_status": r.status_code,
+            "forward_body": (r.text or "")[:FORWARD_BODY_LIMIT],
         }
     except requests.RequestException as e:
-        raise HTTPException(status_code=502, detail=f"relay_failed: {e}")
+        raise HTTPException(status_code=502, detail=f"relay_failed: {e}")
+    finally:
+        INFLIGHT.release()
+
+# Alias route because people keep trying /wakeup on HF
+@app.post("/wakeup")
+async def wakeup_alias(req: Request):
+    return await webhook(req)