122 lines
5.0 KiB
Python
122 lines
5.0 KiB
Python
from contextlib import asynccontextmanager
|
|
from typing import AsyncIterator
|
|
from uuid import UUID
|
|
|
|
import httpx
|
|
from fastapi import FastAPI, HTTPException, Request, Response, status
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
|
|
from .checker import EndpointChecker, SecurityCheckError
|
|
from .config import Settings, get_settings
|
|
from .logging import configure_logging
|
|
from .models import CheckResult, CurrentStatus, Monitor, MonitorCreate, MonitorState, MonitorUpdate, utc_now
|
|
from .store import MonitorStore
|
|
|
|
|
|
def create_app(settings: Settings | None = None, checker: EndpointChecker | None = None) -> FastAPI:
|
|
config = settings or get_settings()
|
|
store = MonitorStore()
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
|
|
configure_logging(config.log_level)
|
|
if checker is not None:
|
|
app.state.checker = checker
|
|
app.state.http_client = None
|
|
else:
|
|
timeout = httpx.Timeout(config.read_timeout_seconds, connect=config.connect_timeout_seconds,
|
|
pool=config.pool_timeout_seconds)
|
|
client = httpx.AsyncClient(timeout=timeout, headers={"User-Agent": config.user_agent})
|
|
app.state.http_client = client
|
|
app.state.checker = EndpointChecker(client, config)
|
|
app.state.ready = True
|
|
yield
|
|
app.state.ready = False
|
|
if app.state.http_client is not None:
|
|
await app.state.http_client.aclose()
|
|
|
|
app = FastAPI(title=config.app_name, version="1.0.0", lifespan=lifespan)
|
|
app.state.store = store
|
|
app.state.ready = False
|
|
|
|
@app.exception_handler(HTTPException)
|
|
async def http_error(_: Request, exc: HTTPException) -> JSONResponse:
|
|
detail = exc.detail if isinstance(exc.detail, str) else "request failed"
|
|
return JSONResponse(status_code=exc.status_code,
|
|
content={"error": {"code": f"http_{exc.status_code}", "message": detail}})
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_error(_: Request, exc: RequestValidationError) -> JSONResponse:
|
|
return JSONResponse(status_code=422, content={"error": {
|
|
"code": "validation_error", "message": "request validation failed", "details": exc.errors()
|
|
}})
|
|
|
|
def missing() -> HTTPException:
|
|
return HTTPException(status_code=404, detail="monitor not found")
|
|
|
|
@app.post("/monitors", response_model=Monitor, status_code=status.HTTP_201_CREATED)
|
|
async def create_monitor(body: MonitorCreate) -> Monitor:
|
|
return await store.create(body)
|
|
|
|
@app.get("/monitors", response_model=list[Monitor])
|
|
async def list_monitors() -> list[Monitor]:
|
|
return await store.list()
|
|
|
|
@app.get("/monitors/{monitor_id}", response_model=Monitor)
|
|
async def get_monitor(monitor_id: UUID) -> Monitor:
|
|
item = await store.get(monitor_id)
|
|
if item is None:
|
|
raise missing()
|
|
return item
|
|
|
|
@app.patch("/monitors/{monitor_id}", response_model=Monitor)
|
|
async def update_monitor(monitor_id: UUID, body: MonitorUpdate) -> Monitor:
|
|
item = await store.update(monitor_id, body)
|
|
if item is None:
|
|
raise missing()
|
|
return item
|
|
|
|
@app.delete("/monitors/{monitor_id}", status_code=status.HTTP_204_NO_CONTENT)
|
|
async def delete_monitor(monitor_id: UUID) -> Response:
|
|
if not await store.delete(monitor_id):
|
|
raise missing()
|
|
return Response(status_code=204)
|
|
|
|
@app.get("/monitors/{monitor_id}/status", response_model=CurrentStatus)
|
|
async def current_status(monitor_id: UUID) -> CurrentStatus:
|
|
item = await store.get(monitor_id)
|
|
if item is None:
|
|
raise missing()
|
|
return item.status
|
|
|
|
@app.post("/monitors/{monitor_id}/check", response_model=CheckResult)
|
|
async def run_check(monitor_id: UUID, request: Request) -> CheckResult:
|
|
item = await store.get(monitor_id)
|
|
if item is None:
|
|
raise missing()
|
|
try:
|
|
outcome = await request.app.state.checker.check(monitor_id, str(item.url))
|
|
except SecurityCheckError as exc:
|
|
blocked = CurrentStatus(state=MonitorState.down, checked_at=utc_now(), error="security_policy")
|
|
await store.set_status(monitor_id, blocked)
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
if await store.set_status(monitor_id, outcome.status) is None:
|
|
raise missing()
|
|
return CheckResult(monitor_id=monitor_id, url=outcome.final_url, status=outcome.status)
|
|
|
|
@app.get("/healthz")
|
|
async def health() -> dict[str, str]:
|
|
return {"status": "ok"}
|
|
|
|
@app.get("/readyz")
|
|
async def ready(request: Request) -> dict[str, str]:
|
|
if not request.app.state.ready or not hasattr(request.app.state, "checker"):
|
|
raise HTTPException(status_code=503, detail="service not ready")
|
|
return {"status": "ready", "storage": "process-local-memory"}
|
|
|
|
return app
|
|
|
|
|
|
app = create_app()
|