161 lines
5.1 KiB
Python
161 lines
5.1 KiB
Python
import os
|
|
import logging
|
|
from contextlib import asynccontextmanager
|
|
from fastapi import FastAPI, Request
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
from fastapi.responses import HTMLResponse
|
|
from fastapi.templating import Jinja2Templates
|
|
|
|
from app.database import Base, engine
|
|
from app import routers
|
|
from app.background_poller import poller
|
|
|
|
# Configure logging
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
|
|
handlers=[
|
|
logging.StreamHandler(),
|
|
logging.FileHandler("data/slmm.log"),
|
|
],
|
|
)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Ensure database tables exist for the addon
|
|
Base.metadata.create_all(bind=engine)
|
|
logger.info("Database tables initialized")
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI):
|
|
"""Manage application lifecycle - startup and shutdown events."""
|
|
from app.services import _connection_pool
|
|
|
|
# Startup
|
|
logger.info("Starting TCP connection pool cleanup task...")
|
|
_connection_pool.start_cleanup()
|
|
logger.info("Starting background poller...")
|
|
await poller.start()
|
|
logger.info("Background poller started")
|
|
|
|
yield # Application runs
|
|
|
|
# Shutdown
|
|
logger.info("Stopping background poller...")
|
|
await poller.stop()
|
|
logger.info("Background poller stopped")
|
|
logger.info("Closing TCP connection pool...")
|
|
await _connection_pool.close_all()
|
|
logger.info("TCP connection pool closed")
|
|
|
|
|
|
app = FastAPI(
|
|
title="SLMM NL43 Addon",
|
|
description="Standalone module for NL43 configuration and status APIs with background polling",
|
|
version="0.2.0",
|
|
lifespan=lifespan,
|
|
)
|
|
|
|
# CORS configuration - use environment variable for allowed origins
|
|
# Default to "*" for development, but should be restricted in production
|
|
allowed_origins = os.getenv("CORS_ORIGINS", "*").split(",")
|
|
logger.info(f"CORS allowed origins: {allowed_origins}")
|
|
|
|
app.add_middleware(
|
|
CORSMiddleware,
|
|
allow_origins=allowed_origins,
|
|
allow_credentials=True,
|
|
allow_methods=["*"],
|
|
allow_headers=["*"],
|
|
)
|
|
|
|
templates = Jinja2Templates(directory="templates")
|
|
|
|
app.include_router(routers.router)
|
|
|
|
|
|
@app.get("/", response_class=HTMLResponse)
|
|
def index(request: Request):
|
|
return templates.TemplateResponse("index.html", {"request": request})
|
|
|
|
|
|
@app.get("/roster", response_class=HTMLResponse)
|
|
def roster(request: Request):
|
|
return templates.TemplateResponse("roster.html", {"request": request})
|
|
|
|
|
|
@app.get("/health")
|
|
async def health():
|
|
"""Basic health check endpoint."""
|
|
return {"status": "ok", "service": "slmm-nl43-addon"}
|
|
|
|
|
|
@app.get("/health/devices")
|
|
async def health_devices():
|
|
"""Enhanced health check that tests device connectivity.
|
|
|
|
Uses the connection pool to avoid unnecessary TCP handshakes — if a
|
|
cached connection exists and is alive, the device is reachable.
|
|
"""
|
|
from sqlalchemy.orm import Session
|
|
from app.database import SessionLocal
|
|
from app.services import _connection_pool
|
|
from app.models import NL43Config
|
|
|
|
db: Session = SessionLocal()
|
|
device_status = []
|
|
|
|
try:
|
|
configs = db.query(NL43Config).filter_by(tcp_enabled=True).all()
|
|
|
|
for cfg in configs:
|
|
device_key = f"{cfg.host}:{cfg.tcp_port}"
|
|
status = {
|
|
"unit_id": cfg.unit_id,
|
|
"host": cfg.host,
|
|
"port": cfg.tcp_port,
|
|
"reachable": False,
|
|
"error": None,
|
|
}
|
|
|
|
try:
|
|
# Check if pool already has a live connection (zero-cost check)
|
|
pool_stats = _connection_pool.get_stats()
|
|
conn_info = pool_stats["connections"].get(device_key)
|
|
if conn_info and conn_info["alive"]:
|
|
status["reachable"] = True
|
|
status["source"] = "pool"
|
|
else:
|
|
# No cached connection — do a lightweight acquire/release
|
|
# This opens a connection if needed but keeps it in the pool
|
|
import asyncio
|
|
reader, writer, from_cache = await _connection_pool.acquire(
|
|
device_key, cfg.host, cfg.tcp_port, timeout=2.0
|
|
)
|
|
await _connection_pool.release(device_key, reader, writer, cfg.host, cfg.tcp_port)
|
|
status["reachable"] = True
|
|
status["source"] = "cached" if from_cache else "new"
|
|
except Exception as e:
|
|
status["error"] = str(type(e).__name__)
|
|
logger.warning(f"Device {cfg.unit_id} health check failed: {e}")
|
|
|
|
device_status.append(status)
|
|
|
|
finally:
|
|
db.close()
|
|
|
|
all_reachable = all(d["reachable"] for d in device_status) if device_status else True
|
|
|
|
return {
|
|
"status": "ok" if all_reachable else "degraded",
|
|
"devices": device_status,
|
|
"total_devices": len(device_status),
|
|
"reachable_devices": sum(1 for d in device_status if d["reachable"]),
|
|
}
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import uvicorn
|
|
|
|
uvicorn.run("app.main:app", host="0.0.0.0", port=int(os.getenv("PORT", "8100")), reload=True)
|