Files
vardkey/app.py
T
2026-10-01 22:03:07 +00:00

182 lines
6.1 KiB
Python

"""Minimal HTTP server for the Helsesjekk dashboard."""
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import os
from pathlib import Path
import re
import sqlite3
from urllib.parse import urlsplit
from database import (
get_health_check,
initialize_database,
list_health_checks,
list_keys,
save_health_check,
seed_fixed_keys,
)
from validation import ValidationError, validate_health_check
ROOT = Path(__file__).resolve().parent
STATIC_FILES = {
"/": ("index.html", "text/html; charset=utf-8"),
"/health-check": ("health-check.html", "text/html; charset=utf-8"),
"/history": ("history.html", "text/html; charset=utf-8"),
"/styles.css": ("styles.css", "text/css; charset=utf-8"),
"/app.js": ("app.js", "text/javascript; charset=utf-8"),
"/health-check.js": ("health-check.js", "text/javascript; charset=utf-8"),
"/history.js": ("history.js", "text/javascript; charset=utf-8"),
}
HEALTH_CHECK_PATH = re.compile(r"^/api/health-checks/([1-9][0-9]*)$")
MAX_REQUEST_BYTES = 262144
def get_database_path():
"""Return the configured SQLite database path."""
return os.environ.get("DATABASE_PATH", "data/helsesjekk.sqlite3")
class AppHandler(BaseHTTPRequestHandler):
def do_GET(self):
"""Serve the pages, key profiles, saved checks, and the health endpoint."""
path = urlsplit(self.path).path
if path == "/health":
self._send_json(200, {"status": "ok"})
return
if path == "/api/keys":
self._send_keys()
return
if path == "/api/health-checks":
self._send_health_check_list()
return
detail = HEALTH_CHECK_PATH.match(path)
if detail:
self._send_health_check(int(detail.group(1)))
return
asset = STATIC_FILES.get(path)
if asset is None:
self.send_error(404, "Not Found")
return
filename, content_type = asset
try:
body = (ROOT / "static" / filename).read_bytes()
except OSError:
self.send_error(500, "Application page unavailable")
return
self.send_response(200)
self.send_header("Content-Type", content_type)
self.send_header("Cache-Control", "no-store")
self._send_security_headers()
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_POST(self):
"""Store one validated annual health check."""
path = urlsplit(self.path).path
if path != "/api/health-checks":
self.send_error(404, "Not Found")
return
try:
payload = self._read_json_body()
except ValueError as error:
self._send_json(400, {"error": str(error)})
return
database_path = get_database_path()
try:
key_ids = {key["id"] for key in list_keys(database_path)}
data = validate_health_check(payload, key_ids)
health_check_id = save_health_check(data, database_path)
except ValidationError as error:
self._send_json(400, {"error": str(error)})
return
except (OSError, sqlite3.Error, ValueError):
self._send_json(500, {"error": "The health check could not be saved"})
return
self._send_json(201, {"id": health_check_id})
def _send_keys(self):
try:
self._send_json(200, list_keys(get_database_path()))
except (OSError, sqlite3.Error, ValueError):
self._send_json(500, {"error": "Key profiles are unavailable"})
def _send_health_check_list(self):
try:
self._send_json(200, list_health_checks(get_database_path()))
except (OSError, sqlite3.Error, ValueError):
self._send_json(500, {"error": "Saved health checks are unavailable"})
def _send_health_check(self, health_check_id):
try:
record = get_health_check(health_check_id, get_database_path())
except (OSError, sqlite3.Error, ValueError):
self._send_json(500, {"error": "Saved health checks are unavailable"})
return
if record is None:
self._send_json(404, {"error": "Health check not found"})
return
self._send_json(200, record)
def _read_json_body(self):
try:
length = int(self.headers.get("Content-Length", "0"))
except ValueError as error:
raise ValueError("Content-Length is not valid") from error
if length <= 0:
raise ValueError("a request body is required")
if length > MAX_REQUEST_BYTES:
raise ValueError("the request body is too large")
raw = self.rfile.read(length)
try:
return json.loads(raw.decode("utf-8"))
except (UnicodeDecodeError, json.JSONDecodeError) as error:
raise ValueError("the request body must be valid JSON") from error
def _send_json(self, status, payload):
body = json.dumps(payload).encode("utf-8")
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self._send_security_headers()
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def _send_security_headers(self):
self.send_header("X-Content-Type-Options", "nosniff")
self.send_header("Content-Security-Policy", "default-src 'self'; style-src 'self'; script-src 'self'; frame-ancestors 'none'")
self.send_header("Referrer-Policy", "no-referrer")
def main():
database_path = get_database_path()
initialize_database(database_path)
seed_fixed_keys(database_path)
port = int(os.environ.get("PORT", "8080"))
if not 1 <= port <= 65535:
raise ValueError("PORT must be between 1 and 65535")
server = ThreadingHTTPServer(("0.0.0.0", port), AppHandler)
print(f"Helsesjekk listening on port {port}", flush=True)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
finally:
server.server_close()
if __name__ == "__main__":
main()