V 1.4.0 Komplette Absicherung mit Hilfe von Claude
This commit is contained in:
@@ -3,177 +3,305 @@
|
||||
import os
|
||||
import json
|
||||
import logging
|
||||
import secrets
|
||||
from contextlib import asynccontextmanager
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
from dotenv import load_dotenv
|
||||
from fastapi import FastAPI, HTTPException, Request
|
||||
from pydantic import BaseModel
|
||||
import psycopg2
|
||||
from psycopg2.extras import RealDictCursor
|
||||
from fastapi import FastAPI, HTTPException, Request, Header, Depends, status
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse
|
||||
from pydantic import BaseModel, ConfigDict, field_validator
|
||||
import psycopg
|
||||
from psycopg_pool import ConnectionPool
|
||||
from slowapi import Limiter
|
||||
from slowapi.errors import RateLimitExceeded
|
||||
from slowapi.util import get_remote_address
|
||||
import uvicorn
|
||||
|
||||
# Logging konfigurieren
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Konfiguration
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
env_path = Path(__file__).parent.parent / ".env"
|
||||
load_dotenv(dotenv_path=env_path)
|
||||
|
||||
COLLECTOR_PORT = int(os.getenv("COLLECTOR_PORT", 8001))
|
||||
|
||||
DB_HOST = os.getenv("DB_HOST", "localhost")
|
||||
DB_PORT = int(os.getenv("DB_PORT", 5432))
|
||||
DB_NAME = os.getenv("DB_NAME", "wetterstation")
|
||||
DB_USER = os.getenv("DB_USER")
|
||||
DB_PASSWORD = os.getenv("DB_PASSWORD")
|
||||
|
||||
# Sicherheit
|
||||
COLLECTOR_API_KEY = os.getenv("COLLECTOR_API_KEY")
|
||||
ENVIRONMENT = os.getenv("ENVIRONMENT", "production").lower()
|
||||
IS_DEV = ENVIRONMENT in ("dev", "development", "local")
|
||||
|
||||
# Limits
|
||||
MAX_BODY_BYTES = int(os.getenv("COLLECTOR_MAX_BODY_BYTES", 16 * 1024)) # 16 KiB
|
||||
RATE_LIMIT = os.getenv("COLLECTOR_RATE_LIMIT", "30/minute")
|
||||
|
||||
# Logging — keine Rohdaten auf INFO mehr
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format='%(asctime)s - %(levelname)s - %(message)s'
|
||||
level=logging.DEBUG if IS_DEV else logging.INFO,
|
||||
format="%(asctime)s - %(levelname)s - %(message)s",
|
||||
)
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Umgebungsvariablen laden - eine Ebene höher
|
||||
env_path = Path(__file__).parent.parent / '.env'
|
||||
load_dotenv(dotenv_path=env_path)
|
||||
|
||||
# Konfiguration
|
||||
COLLECTOR_PORT = int(os.getenv('COLLECTOR_PORT', 8001))
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Connection Pool
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
DB_HOST = os.getenv('DB_HOST', 'localhost')
|
||||
DB_PORT = int(os.getenv('DB_PORT', 5432))
|
||||
DB_NAME = os.getenv('DB_NAME', 'wetterstation')
|
||||
DB_USER = os.getenv('DB_USER')
|
||||
DB_PASSWORD = os.getenv('DB_PASSWORD')
|
||||
|
||||
# FastAPI App
|
||||
app = FastAPI(title="Weather Data Collector API")
|
||||
def _build_conninfo() -> str:
|
||||
return (
|
||||
f"host={DB_HOST} port={DB_PORT} dbname={DB_NAME} "
|
||||
f"user={DB_USER} password={DB_PASSWORD}"
|
||||
)
|
||||
|
||||
|
||||
# Pydantic Models
|
||||
pool: Optional[ConnectionPool] = None
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Rate-Limiter
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
def _limit_key(request: Request) -> str:
|
||||
"""Rate-Limit-Key: bei API-Key danach, sonst nach IP.
|
||||
|
||||
Hinter Traefik nutzt slowapi standardmaessig die Peer-IP, was der
|
||||
Proxy-IP entspricht. Wenn ein API-Key da ist, bevorzugen wir den.
|
||||
"""
|
||||
api_key = request.headers.get("x-api-key")
|
||||
if api_key:
|
||||
# nur Praefix einsetzen, damit der volle Key nicht in Logs landet
|
||||
return f"key:{api_key[:8]}"
|
||||
fwd = request.headers.get("x-forwarded-for")
|
||||
if fwd:
|
||||
return f"ip:{fwd.split(',')[0].strip()}"
|
||||
return f"ip:{get_remote_address(request)}"
|
||||
|
||||
|
||||
limiter = Limiter(key_func=_limit_key, default_limits=[])
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Auth-Dependency
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
async def require_api_key(x_api_key: Optional[str] = Header(default=None)) -> None:
|
||||
"""Prueft den API-Key timing-safe gegen die Konfiguration."""
|
||||
if not COLLECTOR_API_KEY:
|
||||
# Fail-closed: wenn kein Key konfiguriert ist, ist die API gesperrt.
|
||||
logger.error(
|
||||
"COLLECTOR_API_KEY ist nicht gesetzt - alle Schreibzugriffe blockiert."
|
||||
)
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
detail="Service not configured",
|
||||
)
|
||||
if not x_api_key or not secrets.compare_digest(x_api_key, COLLECTOR_API_KEY):
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="Invalid or missing API key",
|
||||
)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Pydantic Models mit Plausibilitaetspruefung
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
class WeatherDataInput(BaseModel):
|
||||
# Zeitstempel: ISO-String (time), datetime-String oder Unix-Timestamp
|
||||
time: str | None = None
|
||||
datetime: str | None = None
|
||||
dateTime: int | None = None
|
||||
# extra-Felder verwerfen statt akzeptieren -> kein Pollution
|
||||
model_config = ConfigDict(extra="ignore")
|
||||
|
||||
# Außentemperatur (Celsius): tempOut, temperature oder outTemp (Fahrenheit)
|
||||
tempOut: float | None = None # Celsius (neues Format)
|
||||
temperature: float | None = None
|
||||
outTemp: float | None = None # Fahrenheit (altes Format)
|
||||
# Zeitstempel
|
||||
time: Optional[str] = None
|
||||
datetime: Optional[str] = None
|
||||
dateTime: Optional[int] = None
|
||||
|
||||
# Aussentemperatur
|
||||
tempOut: Optional[float] = None # Celsius (neu)
|
||||
temperature: Optional[float] = None # Celsius
|
||||
outTemp: Optional[float] = None # Fahrenheit (alt)
|
||||
|
||||
# Innentemperatur
|
||||
tempIn: float | None = None # Celsius
|
||||
tempIn: Optional[float] = None # Celsius
|
||||
|
||||
# Außenfeuchte
|
||||
humOut: int | None = None
|
||||
humidity: int | None = None
|
||||
outHumidity: float | None = None
|
||||
# Aussenfeuchte
|
||||
humOut: Optional[int] = None
|
||||
humidity: Optional[int] = None
|
||||
outHumidity: Optional[float] = None
|
||||
|
||||
# Innenfeuchte
|
||||
humIn: int | None = None
|
||||
humIn: Optional[int] = None
|
||||
|
||||
# Luftdruck
|
||||
pressure: float | None = None
|
||||
barometer: float | None = None # inHg
|
||||
barTrend: int | None = None # hPa/Stunde
|
||||
pressure: Optional[float] = None # hPa
|
||||
barometer: Optional[float] = None # inHg
|
||||
barTrend: Optional[int] = None
|
||||
|
||||
# Wind
|
||||
windAvg: float | None = None # m/s Durchschnitt (neues Format)
|
||||
windSpeed: float | None = None
|
||||
wind_speed: float | None = None
|
||||
windGust: float | None = None
|
||||
wind_gust: float | None = None
|
||||
windDir: float | None = None
|
||||
wind_dir: float | None = None
|
||||
windAvg: Optional[float] = None
|
||||
windSpeed: Optional[float] = None
|
||||
wind_speed: Optional[float] = None
|
||||
windGust: Optional[float] = None
|
||||
wind_gust: Optional[float] = None
|
||||
windDir: Optional[float] = None
|
||||
wind_dir: Optional[float] = None
|
||||
|
||||
# Niederschlag
|
||||
rain: float | None = None
|
||||
rainRate: float | None = None
|
||||
rain_rate: float | None = None
|
||||
rain: Optional[float] = None
|
||||
rainRate: Optional[float] = None
|
||||
rain_rate: Optional[float] = None
|
||||
|
||||
# Vorhersage
|
||||
forecast: int | None = None
|
||||
forecast: Optional[int] = None
|
||||
|
||||
model_config = {"extra": "allow"}
|
||||
# ---- Validatoren -----------------------------------------------------
|
||||
|
||||
@field_validator("tempOut", "temperature", "tempIn")
|
||||
@classmethod
|
||||
def _temp_celsius_range(cls, v: Optional[float]) -> Optional[float]:
|
||||
if v is not None and not (-90.0 <= v <= 70.0):
|
||||
raise ValueError("temperature out of plausible range (Celsius)")
|
||||
return v
|
||||
|
||||
@field_validator("outTemp")
|
||||
@classmethod
|
||||
def _temp_fahrenheit_range(cls, v: Optional[float]) -> Optional[float]:
|
||||
if v is not None and not (-130.0 <= v <= 160.0):
|
||||
raise ValueError("outTemp out of plausible range (Fahrenheit)")
|
||||
return v
|
||||
|
||||
@field_validator("humOut", "humidity", "humIn")
|
||||
@classmethod
|
||||
def _humidity_int_range(cls, v: Optional[int]) -> Optional[int]:
|
||||
if v is not None and not (0 <= v <= 100):
|
||||
raise ValueError("humidity out of range")
|
||||
return v
|
||||
|
||||
@field_validator("outHumidity")
|
||||
@classmethod
|
||||
def _humidity_float_range(cls, v: Optional[float]) -> Optional[float]:
|
||||
if v is not None and not (0.0 <= v <= 100.0):
|
||||
raise ValueError("outHumidity out of range")
|
||||
return v
|
||||
|
||||
@field_validator("pressure")
|
||||
@classmethod
|
||||
def _pressure_hpa_range(cls, v: Optional[float]) -> Optional[float]:
|
||||
if v is not None and not (800.0 <= v <= 1100.0):
|
||||
raise ValueError("pressure (hPa) out of plausible range")
|
||||
return v
|
||||
|
||||
@field_validator("barometer")
|
||||
@classmethod
|
||||
def _pressure_inhg_range(cls, v: Optional[float]) -> Optional[float]:
|
||||
if v is not None and not (23.0 <= v <= 32.5):
|
||||
raise ValueError("barometer (inHg) out of plausible range")
|
||||
return v
|
||||
|
||||
@field_validator("windAvg", "windSpeed", "wind_speed", "windGust", "wind_gust")
|
||||
@classmethod
|
||||
def _wind_speed_range(cls, v: Optional[float]) -> Optional[float]:
|
||||
if v is not None and not (0.0 <= v <= 120.0):
|
||||
raise ValueError("wind speed out of plausible range")
|
||||
return v
|
||||
|
||||
@field_validator("windDir", "wind_dir")
|
||||
@classmethod
|
||||
def _wind_dir_range(cls, v: Optional[float]) -> Optional[float]:
|
||||
if v is not None and not (0.0 <= v <= 360.0):
|
||||
raise ValueError("wind_dir out of range")
|
||||
return v
|
||||
|
||||
@field_validator("rain", "rainRate", "rain_rate")
|
||||
@classmethod
|
||||
def _rain_range(cls, v: Optional[float]) -> Optional[float]:
|
||||
if v is not None and not (0.0 <= v <= 1000.0):
|
||||
raise ValueError("rain value out of plausible range")
|
||||
return v
|
||||
|
||||
# ---- Konvertierungen -------------------------------------------------
|
||||
|
||||
def get_datetime_string(self) -> str:
|
||||
"""Zeitstempel als String zurückgeben"""
|
||||
if self.time:
|
||||
return self.time
|
||||
elif self.datetime:
|
||||
if self.datetime:
|
||||
return self.datetime
|
||||
elif self.dateTime:
|
||||
from datetime import datetime as dt
|
||||
return dt.fromtimestamp(self.dateTime).strftime('%Y-%m-%d %H:%M:%S')
|
||||
if self.dateTime is not None:
|
||||
# Plausibilitaet: 2000-01-01 .. 2100-01-01
|
||||
if not (946684800 <= self.dateTime <= 4102444800):
|
||||
raise ValueError("dateTime timestamp out of plausible range")
|
||||
return datetime.fromtimestamp(self.dateTime).strftime("%Y-%m-%d %H:%M:%S")
|
||||
raise ValueError("Kein Zeitstempel vorhanden (time, datetime oder dateTime)")
|
||||
|
||||
def get_temperature_celsius(self) -> float | None:
|
||||
"""Außentemperatur in Celsius"""
|
||||
def get_temperature_celsius(self) -> Optional[float]:
|
||||
if self.tempOut is not None:
|
||||
return self.tempOut
|
||||
elif self.temperature is not None:
|
||||
if self.temperature is not None:
|
||||
return self.temperature
|
||||
elif self.outTemp is not None:
|
||||
if self.outTemp is not None:
|
||||
return (self.outTemp - 32) * 5 / 9
|
||||
return None
|
||||
|
||||
def get_temp_in(self) -> float | None:
|
||||
"""Innentemperatur in Celsius"""
|
||||
def get_temp_in(self) -> Optional[float]:
|
||||
return self.tempIn
|
||||
|
||||
def get_humidity_int(self) -> int | None:
|
||||
"""Außenfeuchte"""
|
||||
def get_humidity_int(self) -> Optional[int]:
|
||||
if self.humOut is not None:
|
||||
return int(self.humOut)
|
||||
elif self.humidity is not None:
|
||||
if self.humidity is not None:
|
||||
return int(self.humidity)
|
||||
elif self.outHumidity is not None:
|
||||
if self.outHumidity is not None:
|
||||
return int(self.outHumidity)
|
||||
return None
|
||||
|
||||
def get_humidity_in(self) -> int | None:
|
||||
"""Innenfeuchte"""
|
||||
def get_humidity_in(self) -> Optional[int]:
|
||||
return int(self.humIn) if self.humIn is not None else None
|
||||
|
||||
def get_pressure_hpa(self) -> float | None:
|
||||
"""Luftdruck in hPa"""
|
||||
def get_pressure_hpa(self) -> Optional[float]:
|
||||
if self.pressure is not None:
|
||||
return self.pressure
|
||||
elif self.barometer is not None:
|
||||
if self.barometer is not None:
|
||||
return self.barometer * 33.8639
|
||||
return None
|
||||
|
||||
def get_wind_speed(self) -> float | None:
|
||||
"""Durchschnittliche Windgeschwindigkeit"""
|
||||
def get_wind_speed(self) -> Optional[float]:
|
||||
if self.windAvg is not None:
|
||||
return self.windAvg
|
||||
elif self.windSpeed is not None:
|
||||
if self.windSpeed is not None:
|
||||
return self.windSpeed
|
||||
return self.wind_speed
|
||||
|
||||
def get_wind_gust(self) -> float | None:
|
||||
"""Windböe"""
|
||||
def get_wind_gust(self) -> Optional[float]:
|
||||
return self.windGust if self.windGust is not None else self.wind_gust
|
||||
|
||||
def get_wind_dir(self) -> float | None:
|
||||
"""Windrichtung"""
|
||||
def get_wind_dir(self) -> Optional[float]:
|
||||
return self.windDir if self.windDir is not None else self.wind_dir
|
||||
|
||||
def get_rain_rate(self) -> float | None:
|
||||
"""Regenrate"""
|
||||
def get_rain_rate(self) -> Optional[float]:
|
||||
return self.rainRate if self.rainRate is not None else self.rain_rate
|
||||
|
||||
|
||||
# Datenbankverbindung
|
||||
def get_db_connection():
|
||||
"""Datenbankverbindung herstellen"""
|
||||
try:
|
||||
conn = psycopg2.connect(
|
||||
host=DB_HOST,
|
||||
port=DB_PORT,
|
||||
database=DB_NAME,
|
||||
user=DB_USER,
|
||||
password=DB_PASSWORD
|
||||
)
|
||||
return conn
|
||||
except Exception as e:
|
||||
logger.error(f"Datenbankverbindungsfehler: {e}")
|
||||
raise HTTPException(status_code=500, detail="Datenbankverbindung fehlgeschlagen")
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Datenbank-Setup
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
|
||||
def setup_database():
|
||||
"""Tabelle erstellen und fehlende Spalten ergänzen"""
|
||||
try:
|
||||
conn = get_db_connection()
|
||||
def setup_database() -> None:
|
||||
"""Tabelle, fehlende Spalten und Index anlegen (idempotent)."""
|
||||
assert pool is not None
|
||||
with pool.connection() as conn:
|
||||
with conn.cursor() as cursor:
|
||||
cursor.execute("""
|
||||
cursor.execute(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS weather_data (
|
||||
id SERIAL PRIMARY KEY,
|
||||
datetime TIMESTAMPTZ NOT NULL,
|
||||
@@ -188,177 +316,320 @@ def setup_database():
|
||||
received_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
UNIQUE(datetime)
|
||||
)
|
||||
""")
|
||||
# Neue Spalten ergänzen (idempotent)
|
||||
cursor.execute("ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS temp_in FLOAT")
|
||||
cursor.execute("ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS humidity_in INTEGER")
|
||||
cursor.execute("ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS forecast INTEGER")
|
||||
cursor.execute("ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS bar_trend INTEGER")
|
||||
conn.commit()
|
||||
logger.info("Tabelle weather_data bereit (inkl. neuer Spalten)")
|
||||
conn.close()
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Datenbanksetup: {e}")
|
||||
raise
|
||||
"""
|
||||
)
|
||||
cursor.execute(
|
||||
"ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS temp_in FLOAT"
|
||||
)
|
||||
cursor.execute(
|
||||
"ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS humidity_in INTEGER"
|
||||
)
|
||||
cursor.execute(
|
||||
"ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS forecast INTEGER"
|
||||
)
|
||||
cursor.execute(
|
||||
"ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS bar_trend INTEGER"
|
||||
)
|
||||
cursor.execute(
|
||||
"CREATE INDEX IF NOT EXISTS idx_weather_datetime_desc "
|
||||
"ON weather_data (datetime DESC)"
|
||||
)
|
||||
conn.commit()
|
||||
logger.info("Tabelle weather_data und Index bereit")
|
||||
|
||||
|
||||
# API Endpoints
|
||||
@app.on_event("startup")
|
||||
async def startup_event():
|
||||
"""Bei Start die Datenbank initialisieren"""
|
||||
logger.info("Collector API startet...")
|
||||
# --------------------------------------------------------------------------- #
|
||||
# FastAPI Lifespan
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI):
|
||||
global pool
|
||||
|
||||
# Pflicht-Variablen pruefen — fail fast
|
||||
missing = [v for v in ("DB_USER", "DB_PASSWORD") if not os.getenv(v)]
|
||||
if missing:
|
||||
raise RuntimeError(
|
||||
f"Fehlende Umgebungsvariablen: {', '.join(missing)}"
|
||||
)
|
||||
if not COLLECTOR_API_KEY:
|
||||
raise RuntimeError(
|
||||
"COLLECTOR_API_KEY ist nicht gesetzt. "
|
||||
"Mindestens 32 Zeichen empfohlen (z.B. via 'openssl rand -hex 32')."
|
||||
)
|
||||
if len(COLLECTOR_API_KEY) < 16:
|
||||
raise RuntimeError(
|
||||
"COLLECTOR_API_KEY ist zu kurz (Minimum 16 Zeichen)."
|
||||
)
|
||||
|
||||
pool = ConnectionPool(
|
||||
conninfo=_build_conninfo(),
|
||||
min_size=1,
|
||||
max_size=5,
|
||||
timeout=10,
|
||||
kwargs={"autocommit": False},
|
||||
)
|
||||
pool.wait()
|
||||
logger.info("Connection Pool initialisiert (min=1, max=5)")
|
||||
|
||||
setup_database()
|
||||
logger.info(f"API läuft auf Port {COLLECTOR_PORT}")
|
||||
logger.info("Collector laeuft auf Port %d (env=%s)", COLLECTOR_PORT, ENVIRONMENT)
|
||||
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
if pool is not None:
|
||||
pool.close()
|
||||
logger.info("Connection Pool geschlossen")
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# FastAPI App
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
app = FastAPI(
|
||||
title="Weather Data Collector API",
|
||||
docs_url="/docs" if IS_DEV else None,
|
||||
redoc_url=None,
|
||||
openapi_url="/openapi.json" if IS_DEV else None,
|
||||
lifespan=lifespan,
|
||||
)
|
||||
|
||||
# Rate-Limiter an die App binden
|
||||
app.state.limiter = limiter
|
||||
|
||||
|
||||
@app.exception_handler(RateLimitExceeded)
|
||||
async def _rate_limit_handler(request: Request, exc: RateLimitExceeded):
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_429_TOO_MANY_REQUESTS,
|
||||
content={"detail": "Too many requests"},
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def _validation_handler(request: Request, exc: RequestValidationError):
|
||||
# Details ins Log, generische Antwort an den Client.
|
||||
logger.warning("Validation error on %s: %s", request.url.path, exc.errors())
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||||
content={"detail": "Validation error"},
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def _unhandled_handler(request: Request, exc: Exception):
|
||||
# NIE Stacktraces oder str(exc) an den Client zurueckgeben.
|
||||
logger.exception("Unhandled error on %s", request.url.path)
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||||
content={"detail": "Internal server error"},
|
||||
)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Body-Size-Middleware
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
@app.middleware("http")
|
||||
async def _limit_body_size(request: Request, call_next):
|
||||
if request.method in ("POST", "PUT", "PATCH"):
|
||||
cl = request.headers.get("content-length")
|
||||
if cl is not None:
|
||||
try:
|
||||
if int(cl) > MAX_BODY_BYTES:
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
|
||||
content={"detail": "Payload too large"},
|
||||
)
|
||||
except ValueError:
|
||||
return JSONResponse(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
content={"detail": "Invalid Content-Length"},
|
||||
)
|
||||
return await call_next(request)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Endpoints
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
@app.get("/")
|
||||
async def root():
|
||||
"""Root Endpoint - GET zeigt Info"""
|
||||
"""Info-Endpunkt (kein Auth noetig)."""
|
||||
return {
|
||||
"message": "Weather Data Collector API",
|
||||
"version": "1.0.0",
|
||||
"endpoint": "POST /weather or POST /"
|
||||
"service": "Weather Data Collector",
|
||||
"version": "2.0.0",
|
||||
"endpoint": "POST /weather (X-API-Key required)",
|
||||
}
|
||||
|
||||
|
||||
@app.post("/")
|
||||
async def root_post(request: Request):
|
||||
"""Root Endpoint - POST akzeptiert Wetterdaten (Alias für /weather)"""
|
||||
try:
|
||||
# Rohen Body lesen
|
||||
body = await request.body()
|
||||
body_str = body.decode('utf-8')
|
||||
logger.info(f"POST auf Root - Raw Body: {body_str}")
|
||||
|
||||
# Als JSON parsen
|
||||
data_dict = json.loads(body_str)
|
||||
logger.info(f"POST auf Root - Parsed JSON: {data_dict}")
|
||||
|
||||
# Zu Pydantic Model konvertieren
|
||||
data = WeatherDataInput(**data_dict)
|
||||
return await receive_weather_data(data)
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"JSON Parse Error: {e}")
|
||||
raise HTTPException(status_code=400, detail=f"Invalid JSON: {str(e)}")
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Root POST: {e}")
|
||||
raise HTTPException(status_code=422, detail=f"Validation error: {str(e)}")
|
||||
|
||||
|
||||
@app.post("/debug")
|
||||
async def debug_post(request: dict):
|
||||
"""Debug Endpoint - akzeptiert beliebige JSON und loggt sie"""
|
||||
logger.info(f"Debug: Empfangene Rohdaten: {request}")
|
||||
return {"status": "logged", "data": request}
|
||||
|
||||
|
||||
@app.get("/health")
|
||||
async def health_check():
|
||||
"""Health Check"""
|
||||
"""Health-Check ohne Auth, aber ohne sensitive Details."""
|
||||
try:
|
||||
conn = get_db_connection()
|
||||
with conn.cursor() as cursor:
|
||||
cursor.execute("SELECT 1")
|
||||
conn.close()
|
||||
return {"status": "healthy", "database": "connected"}
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=503, detail=f"Database error: {str(e)}")
|
||||
|
||||
|
||||
@app.post("/weather")
|
||||
async def receive_weather_data(data: WeatherDataInput):
|
||||
"""Wetterdaten empfangen und speichern"""
|
||||
logger.info(f"Empfangene Daten: {data.model_dump()}")
|
||||
try:
|
||||
conn = get_db_connection()
|
||||
try:
|
||||
# Konvertiere zu den richtigen Werten
|
||||
dt_string = data.get_datetime_string()
|
||||
temp_c = data.get_temperature_celsius()
|
||||
temp_in = data.get_temp_in()
|
||||
humidity = data.get_humidity_int()
|
||||
humidity_in = data.get_humidity_in()
|
||||
pressure = data.get_pressure_hpa()
|
||||
bar_trend = data.barTrend
|
||||
wind_speed = data.get_wind_speed()
|
||||
wind_gust = data.get_wind_gust()
|
||||
wind_dir = data.get_wind_dir()
|
||||
rain = data.rain
|
||||
rain_rate = data.get_rain_rate()
|
||||
forecast = data.forecast
|
||||
|
||||
logger.info(
|
||||
f"Konvertierte Daten - datetime: {dt_string}, "
|
||||
f"tempOut: {temp_c}°C, tempIn: {temp_in}°C, "
|
||||
f"humOut: {humidity}%, humIn: {humidity_in}%, "
|
||||
f"pressure: {pressure} hPa, barTrend: {bar_trend}"
|
||||
)
|
||||
|
||||
assert pool is not None
|
||||
with pool.connection() as conn:
|
||||
with conn.cursor() as cursor:
|
||||
cursor.execute("""
|
||||
INSERT INTO weather_data
|
||||
cursor.execute("SELECT 1")
|
||||
return {"status": "healthy"}
|
||||
except Exception:
|
||||
logger.exception("Health-Check fehlgeschlagen")
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
detail="Service unavailable",
|
||||
)
|
||||
|
||||
|
||||
def _store_weather(data: WeatherDataInput) -> dict:
|
||||
"""Schreibt einen Datenpunkt; setzt voraus, dass `data` validiert ist."""
|
||||
assert pool is not None
|
||||
|
||||
dt_string = data.get_datetime_string()
|
||||
values = (
|
||||
dt_string,
|
||||
data.get_temperature_celsius(),
|
||||
data.get_temp_in(),
|
||||
data.get_humidity_int(),
|
||||
data.get_humidity_in(),
|
||||
data.get_pressure_hpa(),
|
||||
data.barTrend,
|
||||
data.get_wind_speed(),
|
||||
data.get_wind_gust(),
|
||||
data.get_wind_dir(),
|
||||
data.rain,
|
||||
data.get_rain_rate(),
|
||||
data.forecast,
|
||||
)
|
||||
|
||||
with pool.connection() as conn:
|
||||
with conn.cursor() as cursor:
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO weather_data
|
||||
(datetime, temperature, temp_in, humidity, humidity_in,
|
||||
pressure, bar_trend, wind_speed, wind_gust, wind_dir,
|
||||
rain, rain_rate, forecast)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
ON CONFLICT (datetime) DO UPDATE SET
|
||||
temperature = EXCLUDED.temperature,
|
||||
temp_in = EXCLUDED.temp_in,
|
||||
humidity = EXCLUDED.humidity,
|
||||
humidity_in = EXCLUDED.humidity_in,
|
||||
pressure = EXCLUDED.pressure,
|
||||
bar_trend = EXCLUDED.bar_trend,
|
||||
wind_speed = EXCLUDED.wind_speed,
|
||||
wind_gust = EXCLUDED.wind_gust,
|
||||
wind_dir = EXCLUDED.wind_dir,
|
||||
rain = EXCLUDED.rain,
|
||||
rain_rate = EXCLUDED.rain_rate,
|
||||
forecast = EXCLUDED.forecast
|
||||
""", (
|
||||
dt_string,
|
||||
temp_c,
|
||||
temp_in,
|
||||
humidity,
|
||||
humidity_in,
|
||||
pressure,
|
||||
bar_trend,
|
||||
wind_speed,
|
||||
wind_gust,
|
||||
wind_dir,
|
||||
rain,
|
||||
rain_rate,
|
||||
forecast
|
||||
))
|
||||
conn.commit()
|
||||
logger.info(f"Daten gespeichert für {dt_string} (UTC)")
|
||||
|
||||
return {
|
||||
"status": "success",
|
||||
"message": f"Weather data for {dt_string} saved successfully"
|
||||
}
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Speichern: {e}")
|
||||
raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
ON CONFLICT (datetime) DO UPDATE SET
|
||||
temperature = EXCLUDED.temperature,
|
||||
temp_in = EXCLUDED.temp_in,
|
||||
humidity = EXCLUDED.humidity,
|
||||
humidity_in = EXCLUDED.humidity_in,
|
||||
pressure = EXCLUDED.pressure,
|
||||
bar_trend = EXCLUDED.bar_trend,
|
||||
wind_speed = EXCLUDED.wind_speed,
|
||||
wind_gust = EXCLUDED.wind_gust,
|
||||
wind_dir = EXCLUDED.wind_dir,
|
||||
rain = EXCLUDED.rain,
|
||||
rain_rate = EXCLUDED.rain_rate,
|
||||
forecast = EXCLUDED.forecast
|
||||
""",
|
||||
values,
|
||||
)
|
||||
conn.commit()
|
||||
|
||||
logger.info("Datenpunkt gespeichert fuer %s", dt_string)
|
||||
return {"status": "success", "datetime": dt_string}
|
||||
|
||||
|
||||
def main():
|
||||
"""Hauptfunktion"""
|
||||
# Prüfen ob alle nötigen Umgebungsvariablen gesetzt sind
|
||||
required_vars = ['DB_USER', 'DB_PASSWORD']
|
||||
missing_vars = [var for var in required_vars if not os.getenv(var)]
|
||||
|
||||
if missing_vars:
|
||||
logger.error(f"Fehlende Umgebungsvariablen: {', '.join(missing_vars)}")
|
||||
logger.error("Bitte .env Datei mit den erforderlichen Werten erstellen")
|
||||
return
|
||||
|
||||
uvicorn.run(app, host="0.0.0.0", port=COLLECTOR_PORT)
|
||||
@app.post("/weather", dependencies=[Depends(require_api_key)])
|
||||
@limiter.limit(RATE_LIMIT)
|
||||
async def receive_weather_data(request: Request, data: WeatherDataInput):
|
||||
"""Wetterdaten empfangen und speichern (Auth + Rate-Limit)."""
|
||||
try:
|
||||
return _store_weather(data)
|
||||
except ValueError as e:
|
||||
# Konvertierungs-Fehler (z.B. fehlender Zeitstempel)
|
||||
logger.warning("Bad request on /weather: %s", e)
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail="Invalid input",
|
||||
)
|
||||
except psycopg.Error:
|
||||
logger.exception("DB-Fehler beim Speichern")
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
detail="Storage unavailable",
|
||||
)
|
||||
|
||||
|
||||
@app.post("/", dependencies=[Depends(require_api_key)])
|
||||
@limiter.limit(RATE_LIMIT)
|
||||
async def root_post(request: Request):
|
||||
"""Alias fuer POST /weather (Auth + Rate-Limit)."""
|
||||
body = await request.body()
|
||||
if len(body) > MAX_BODY_BYTES:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
|
||||
detail="Payload too large",
|
||||
)
|
||||
try:
|
||||
data_dict = json.loads(body.decode("utf-8"))
|
||||
except (UnicodeDecodeError, json.JSONDecodeError):
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail="Invalid JSON",
|
||||
)
|
||||
|
||||
try:
|
||||
data = WeatherDataInput(**data_dict)
|
||||
except Exception:
|
||||
# Pydantic-Fehler enthalten ggf. Werte aus dem Body — nicht durchreichen.
|
||||
logger.warning("Validation failed on POST /")
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
|
||||
detail="Validation error",
|
||||
)
|
||||
|
||||
try:
|
||||
return _store_weather(data)
|
||||
except ValueError:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail="Invalid input",
|
||||
)
|
||||
except psycopg.Error:
|
||||
logger.exception("DB-Fehler beim Speichern")
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
detail="Storage unavailable",
|
||||
)
|
||||
|
||||
|
||||
# Debug-Endpunkt nur in DEV-Modus + nur mit API-Key
|
||||
if IS_DEV:
|
||||
@app.post("/debug", dependencies=[Depends(require_api_key)])
|
||||
async def debug_post(request: Request):
|
||||
body = await request.body()
|
||||
if len(body) > MAX_BODY_BYTES:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
|
||||
detail="Payload too large",
|
||||
)
|
||||
try:
|
||||
payload = json.loads(body.decode("utf-8"))
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="Invalid JSON")
|
||||
logger.debug("Debug payload: %s", payload)
|
||||
return {"status": "logged"}
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Entry-Point
|
||||
# --------------------------------------------------------------------------- #
|
||||
|
||||
def main() -> None:
|
||||
uvicorn.run(
|
||||
app,
|
||||
host="0.0.0.0",
|
||||
port=COLLECTOR_PORT,
|
||||
# In Produktion liegt Traefik davor und terminiert TLS.
|
||||
# X-Forwarded-* nur dann auswerten, wenn man dem Proxy vertraut.
|
||||
proxy_headers=True,
|
||||
forwarded_allow_ips="*",
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
main()
|
||||
364
collector/main.py_old
Normal file
364
collector/main.py_old
Normal file
@@ -0,0 +1,364 @@
|
||||
# HTTP API that receives weather data via POST and stores in PostgreSQL
|
||||
|
||||
import os
|
||||
import json
|
||||
import logging
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from dotenv import load_dotenv
|
||||
from fastapi import FastAPI, HTTPException, Request
|
||||
from pydantic import BaseModel
|
||||
import psycopg2
|
||||
from psycopg2.extras import RealDictCursor
|
||||
import uvicorn
|
||||
|
||||
# Logging konfigurieren
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format='%(asctime)s - %(levelname)s - %(message)s'
|
||||
)
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Umgebungsvariablen laden - eine Ebene höher
|
||||
env_path = Path(__file__).parent.parent / '.env'
|
||||
load_dotenv(dotenv_path=env_path)
|
||||
|
||||
# Konfiguration
|
||||
COLLECTOR_PORT = int(os.getenv('COLLECTOR_PORT', 8001))
|
||||
|
||||
DB_HOST = os.getenv('DB_HOST', 'localhost')
|
||||
DB_PORT = int(os.getenv('DB_PORT', 5432))
|
||||
DB_NAME = os.getenv('DB_NAME', 'wetterstation')
|
||||
DB_USER = os.getenv('DB_USER')
|
||||
DB_PASSWORD = os.getenv('DB_PASSWORD')
|
||||
|
||||
# FastAPI App
|
||||
app = FastAPI(title="Weather Data Collector API")
|
||||
|
||||
|
||||
# Pydantic Models
|
||||
class WeatherDataInput(BaseModel):
|
||||
# Zeitstempel: ISO-String (time), datetime-String oder Unix-Timestamp
|
||||
time: str | None = None
|
||||
datetime: str | None = None
|
||||
dateTime: int | None = None
|
||||
|
||||
# Außentemperatur (Celsius): tempOut, temperature oder outTemp (Fahrenheit)
|
||||
tempOut: float | None = None # Celsius (neues Format)
|
||||
temperature: float | None = None
|
||||
outTemp: float | None = None # Fahrenheit (altes Format)
|
||||
|
||||
# Innentemperatur
|
||||
tempIn: float | None = None # Celsius
|
||||
|
||||
# Außenfeuchte
|
||||
humOut: int | None = None
|
||||
humidity: int | None = None
|
||||
outHumidity: float | None = None
|
||||
|
||||
# Innenfeuchte
|
||||
humIn: int | None = None
|
||||
|
||||
# Luftdruck
|
||||
pressure: float | None = None
|
||||
barometer: float | None = None # inHg
|
||||
barTrend: int | None = None # hPa/Stunde
|
||||
|
||||
# Wind
|
||||
windAvg: float | None = None # m/s Durchschnitt (neues Format)
|
||||
windSpeed: float | None = None
|
||||
wind_speed: float | None = None
|
||||
windGust: float | None = None
|
||||
wind_gust: float | None = None
|
||||
windDir: float | None = None
|
||||
wind_dir: float | None = None
|
||||
|
||||
# Niederschlag
|
||||
rain: float | None = None
|
||||
rainRate: float | None = None
|
||||
rain_rate: float | None = None
|
||||
|
||||
# Vorhersage
|
||||
forecast: int | None = None
|
||||
|
||||
model_config = {"extra": "allow"}
|
||||
|
||||
def get_datetime_string(self) -> str:
|
||||
"""Zeitstempel als String zurückgeben"""
|
||||
if self.time:
|
||||
return self.time
|
||||
elif self.datetime:
|
||||
return self.datetime
|
||||
elif self.dateTime:
|
||||
from datetime import datetime as dt
|
||||
return dt.fromtimestamp(self.dateTime).strftime('%Y-%m-%d %H:%M:%S')
|
||||
raise ValueError("Kein Zeitstempel vorhanden (time, datetime oder dateTime)")
|
||||
|
||||
def get_temperature_celsius(self) -> float | None:
|
||||
"""Außentemperatur in Celsius"""
|
||||
if self.tempOut is not None:
|
||||
return self.tempOut
|
||||
elif self.temperature is not None:
|
||||
return self.temperature
|
||||
elif self.outTemp is not None:
|
||||
return (self.outTemp - 32) * 5 / 9
|
||||
return None
|
||||
|
||||
def get_temp_in(self) -> float | None:
|
||||
"""Innentemperatur in Celsius"""
|
||||
return self.tempIn
|
||||
|
||||
def get_humidity_int(self) -> int | None:
|
||||
"""Außenfeuchte"""
|
||||
if self.humOut is not None:
|
||||
return int(self.humOut)
|
||||
elif self.humidity is not None:
|
||||
return int(self.humidity)
|
||||
elif self.outHumidity is not None:
|
||||
return int(self.outHumidity)
|
||||
return None
|
||||
|
||||
def get_humidity_in(self) -> int | None:
|
||||
"""Innenfeuchte"""
|
||||
return int(self.humIn) if self.humIn is not None else None
|
||||
|
||||
def get_pressure_hpa(self) -> float | None:
|
||||
"""Luftdruck in hPa"""
|
||||
if self.pressure is not None:
|
||||
return self.pressure
|
||||
elif self.barometer is not None:
|
||||
return self.barometer * 33.8639
|
||||
return None
|
||||
|
||||
def get_wind_speed(self) -> float | None:
|
||||
"""Durchschnittliche Windgeschwindigkeit"""
|
||||
if self.windAvg is not None:
|
||||
return self.windAvg
|
||||
elif self.windSpeed is not None:
|
||||
return self.windSpeed
|
||||
return self.wind_speed
|
||||
|
||||
def get_wind_gust(self) -> float | None:
|
||||
"""Windböe"""
|
||||
return self.windGust if self.windGust is not None else self.wind_gust
|
||||
|
||||
def get_wind_dir(self) -> float | None:
|
||||
"""Windrichtung"""
|
||||
return self.windDir if self.windDir is not None else self.wind_dir
|
||||
|
||||
def get_rain_rate(self) -> float | None:
|
||||
"""Regenrate"""
|
||||
return self.rainRate if self.rainRate is not None else self.rain_rate
|
||||
|
||||
|
||||
# Datenbankverbindung
|
||||
def get_db_connection():
|
||||
"""Datenbankverbindung herstellen"""
|
||||
try:
|
||||
conn = psycopg2.connect(
|
||||
host=DB_HOST,
|
||||
port=DB_PORT,
|
||||
database=DB_NAME,
|
||||
user=DB_USER,
|
||||
password=DB_PASSWORD
|
||||
)
|
||||
return conn
|
||||
except Exception as e:
|
||||
logger.error(f"Datenbankverbindungsfehler: {e}")
|
||||
raise HTTPException(status_code=500, detail="Datenbankverbindung fehlgeschlagen")
|
||||
|
||||
|
||||
def setup_database():
|
||||
"""Tabelle erstellen und fehlende Spalten ergänzen"""
|
||||
try:
|
||||
conn = get_db_connection()
|
||||
with conn.cursor() as cursor:
|
||||
cursor.execute("""
|
||||
CREATE TABLE IF NOT EXISTS weather_data (
|
||||
id SERIAL PRIMARY KEY,
|
||||
datetime TIMESTAMPTZ NOT NULL,
|
||||
temperature FLOAT,
|
||||
humidity INTEGER,
|
||||
pressure FLOAT,
|
||||
wind_speed FLOAT,
|
||||
wind_gust FLOAT,
|
||||
wind_dir FLOAT,
|
||||
rain FLOAT,
|
||||
rain_rate FLOAT,
|
||||
received_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
UNIQUE(datetime)
|
||||
)
|
||||
""")
|
||||
# Neue Spalten ergänzen (idempotent)
|
||||
cursor.execute("ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS temp_in FLOAT")
|
||||
cursor.execute("ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS humidity_in INTEGER")
|
||||
cursor.execute("ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS forecast INTEGER")
|
||||
cursor.execute("ALTER TABLE weather_data ADD COLUMN IF NOT EXISTS bar_trend INTEGER")
|
||||
conn.commit()
|
||||
logger.info("Tabelle weather_data bereit (inkl. neuer Spalten)")
|
||||
conn.close()
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Datenbanksetup: {e}")
|
||||
raise
|
||||
|
||||
|
||||
# API Endpoints
|
||||
@app.on_event("startup")
|
||||
async def startup_event():
|
||||
"""Bei Start die Datenbank initialisieren"""
|
||||
logger.info("Collector API startet...")
|
||||
setup_database()
|
||||
logger.info(f"API läuft auf Port {COLLECTOR_PORT}")
|
||||
|
||||
|
||||
@app.get("/")
|
||||
async def root():
|
||||
"""Root Endpoint - GET zeigt Info"""
|
||||
return {
|
||||
"message": "Weather Data Collector API",
|
||||
"version": "1.0.0",
|
||||
"endpoint": "POST /weather or POST /"
|
||||
}
|
||||
|
||||
|
||||
@app.post("/")
|
||||
async def root_post(request: Request):
|
||||
"""Root Endpoint - POST akzeptiert Wetterdaten (Alias für /weather)"""
|
||||
try:
|
||||
# Rohen Body lesen
|
||||
body = await request.body()
|
||||
body_str = body.decode('utf-8')
|
||||
logger.info(f"POST auf Root - Raw Body: {body_str}")
|
||||
|
||||
# Als JSON parsen
|
||||
data_dict = json.loads(body_str)
|
||||
logger.info(f"POST auf Root - Parsed JSON: {data_dict}")
|
||||
|
||||
# Zu Pydantic Model konvertieren
|
||||
data = WeatherDataInput(**data_dict)
|
||||
return await receive_weather_data(data)
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"JSON Parse Error: {e}")
|
||||
raise HTTPException(status_code=400, detail=f"Invalid JSON: {str(e)}")
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Root POST: {e}")
|
||||
raise HTTPException(status_code=422, detail=f"Validation error: {str(e)}")
|
||||
|
||||
|
||||
@app.post("/debug")
|
||||
async def debug_post(request: dict):
|
||||
"""Debug Endpoint - akzeptiert beliebige JSON und loggt sie"""
|
||||
logger.info(f"Debug: Empfangene Rohdaten: {request}")
|
||||
return {"status": "logged", "data": request}
|
||||
|
||||
|
||||
@app.get("/health")
|
||||
async def health_check():
|
||||
"""Health Check"""
|
||||
try:
|
||||
conn = get_db_connection()
|
||||
with conn.cursor() as cursor:
|
||||
cursor.execute("SELECT 1")
|
||||
conn.close()
|
||||
return {"status": "healthy", "database": "connected"}
|
||||
except Exception as e:
|
||||
raise HTTPException(status_code=503, detail=f"Database error: {str(e)}")
|
||||
|
||||
|
||||
@app.post("/weather")
|
||||
async def receive_weather_data(data: WeatherDataInput):
|
||||
"""Wetterdaten empfangen und speichern"""
|
||||
logger.info(f"Empfangene Daten: {data.model_dump()}")
|
||||
try:
|
||||
conn = get_db_connection()
|
||||
try:
|
||||
# Konvertiere zu den richtigen Werten
|
||||
dt_string = data.get_datetime_string()
|
||||
temp_c = data.get_temperature_celsius()
|
||||
temp_in = data.get_temp_in()
|
||||
humidity = data.get_humidity_int()
|
||||
humidity_in = data.get_humidity_in()
|
||||
pressure = data.get_pressure_hpa()
|
||||
bar_trend = data.barTrend
|
||||
wind_speed = data.get_wind_speed()
|
||||
wind_gust = data.get_wind_gust()
|
||||
wind_dir = data.get_wind_dir()
|
||||
rain = data.rain
|
||||
rain_rate = data.get_rain_rate()
|
||||
forecast = data.forecast
|
||||
|
||||
logger.info(
|
||||
f"Konvertierte Daten - datetime: {dt_string}, "
|
||||
f"tempOut: {temp_c}°C, tempIn: {temp_in}°C, "
|
||||
f"humOut: {humidity}%, humIn: {humidity_in}%, "
|
||||
f"pressure: {pressure} hPa, barTrend: {bar_trend}"
|
||||
)
|
||||
|
||||
with conn.cursor() as cursor:
|
||||
cursor.execute("""
|
||||
INSERT INTO weather_data
|
||||
(datetime, temperature, temp_in, humidity, humidity_in,
|
||||
pressure, bar_trend, wind_speed, wind_gust, wind_dir,
|
||||
rain, rain_rate, forecast)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
ON CONFLICT (datetime) DO UPDATE SET
|
||||
temperature = EXCLUDED.temperature,
|
||||
temp_in = EXCLUDED.temp_in,
|
||||
humidity = EXCLUDED.humidity,
|
||||
humidity_in = EXCLUDED.humidity_in,
|
||||
pressure = EXCLUDED.pressure,
|
||||
bar_trend = EXCLUDED.bar_trend,
|
||||
wind_speed = EXCLUDED.wind_speed,
|
||||
wind_gust = EXCLUDED.wind_gust,
|
||||
wind_dir = EXCLUDED.wind_dir,
|
||||
rain = EXCLUDED.rain,
|
||||
rain_rate = EXCLUDED.rain_rate,
|
||||
forecast = EXCLUDED.forecast
|
||||
""", (
|
||||
dt_string,
|
||||
temp_c,
|
||||
temp_in,
|
||||
humidity,
|
||||
humidity_in,
|
||||
pressure,
|
||||
bar_trend,
|
||||
wind_speed,
|
||||
wind_gust,
|
||||
wind_dir,
|
||||
rain,
|
||||
rain_rate,
|
||||
forecast
|
||||
))
|
||||
conn.commit()
|
||||
logger.info(f"Daten gespeichert für {dt_string} (UTC)")
|
||||
|
||||
return {
|
||||
"status": "success",
|
||||
"message": f"Weather data for {dt_string} saved successfully"
|
||||
}
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Speichern: {e}")
|
||||
raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
|
||||
|
||||
|
||||
def main():
|
||||
"""Hauptfunktion"""
|
||||
# Prüfen ob alle nötigen Umgebungsvariablen gesetzt sind
|
||||
required_vars = ['DB_USER', 'DB_PASSWORD']
|
||||
missing_vars = [var for var in required_vars if not os.getenv(var)]
|
||||
|
||||
if missing_vars:
|
||||
logger.error(f"Fehlende Umgebungsvariablen: {', '.join(missing_vars)}")
|
||||
logger.error("Bitte .env Datei mit den erforderlichen Werten erstellen")
|
||||
return
|
||||
|
||||
uvicorn.run(app, host="0.0.0.0", port=COLLECTOR_PORT)
|
||||
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
fastapi==0.115.5
|
||||
uvicorn==0.34.0
|
||||
psycopg2-binary==2.9.10
|
||||
python-dotenv==1.0.0
|
||||
uvicorn[standard]==0.34.0
|
||||
psycopg[binary]==3.2.3
|
||||
psycopg_pool==3.2.4
|
||||
python-dotenv==1.0.1
|
||||
slowapi==0.1.9
|
||||
|
||||
Reference in New Issue
Block a user