vacuum-wall/webui/api/proxy.py

"""Nginx proxy domain management API blueprint.

Exposed at /api/proxy/* and delegates to vacuum-walld.
"""

import logging

from flask import Blueprint, request

from daemon.client import BadRequest, NotFound, delete, get, patch, post
from webui.api.common import _error, _ok

logger = logging.getLogger(__name__)
bp = Blueprint("proxy", __name__)


@bp.route("/ssl-apply", methods=["POST"])
def ssl_apply_bp():
    try:
        post("/nginx/ssl-apply")
        logger.info("SSL snippet written via API")
        return _ok(None)
    except RuntimeError as exc:
        logger.error("Failed to write SSL snippet: %s", exc)
        return _error(str(exc), 500)


@bp.route("/config", methods=["GET"])
def get_config_bp():
    try:
        return _ok(get("/nginx/config"))
    except RuntimeError as exc:
        logger.error("Failed to read proxy config: %s", exc)
        return _error(str(exc), 500)


@bp.route("/config", methods=["POST"])
def post_config():
    body = request.get_json(silent=True) or {}
    if not isinstance(body, dict):
        return _error("Request body must be a JSON object", 400)
    try:
        post("/nginx/config", body)
        logger.info("Proxy config saved: %s", sorted(body.keys()))
        return _ok(None)
    except BadRequest as exc:
        logger.info("Proxy config save rejected: %s", exc)
        return _error(str(exc), 400)
    except RuntimeError as exc:
        logger.error("Failed to save proxy config: %s", exc)
        return _error(str(exc), 500)


@bp.route("/config", methods=["PATCH"])
def patch_config():
    body = request.get_json(silent=True) or {}
    if not isinstance(body, dict):
        return _error("Request body must be a JSON object", 400)
    try:
        patch("/nginx/config", body)
        logger.info("Proxy config patched: %s", sorted(body.keys()))
        return _ok(None)
    except BadRequest as exc:
        logger.info("Proxy config patch rejected: %s", exc)
        return _error(str(exc), 400)
    except RuntimeError as exc:
        logger.error("Failed to patch proxy config: %s", exc)
        return _error(str(exc), 500)


@bp.route("/domains", methods=["GET"])
def list_domains():
    try:
        return _ok(get("/nginx/domains"))
    except RuntimeError as exc:
        logger.error("Failed to list proxy domains: %s", exc)
        return _error(str(exc), 500)


@bp.route("/domains", methods=["POST"])
def add_domain_bp():
    body = request.get_json(silent=True) or {}
    domain = body.get("domain", "").strip()
    backend_host = body.get("backend_host", "").strip()
    backend_port = body.get("backend_port")
    backend_proto = body.get("backend_proto", "http").strip() or "http"
    cert = body.get("cert")
    extra_headers = body.get("extra_headers")
    if not domain:
        return _error("'domain' is required", 400)
    if not backend_host:
        return _error("'backend_host' is required", 400)
    if backend_port is None:
        return _error("'backend_port' is required", 400)
    try:
        post(
            "/nginx/domains/add",
            {
                "domain": domain,
                "backend_host": backend_host,
                "backend_port": int(backend_port),
                "backend_proto": backend_proto,
                "cert": cert,
                "extra_headers": extra_headers,
            },
        )
        logger.info("Proxy domain added via API: %s", domain)
        return _ok({"domain": domain})
    except BadRequest as exc:
        logger.info("Add proxy domain '%s' rejected: %s", domain, exc)
        return _error(str(exc), 400)
    except RuntimeError as exc:
        logger.error("Failed to add proxy domain '%s': %s", domain, exc)
        return _error(str(exc), 500)


@bp.route("/domains/<domain>", methods=["PUT"])
def update_domain_bp(domain):
    body = request.get_json(silent=True) or {}
    if not body:
        return _error("Request body must be a JSON object with fields to update", 400)
    try:
        post("/nginx/domains/update", {"domain": domain, **body})
        logger.info("Proxy domain '%s' updated via API", domain)
        return _ok({"domain": domain})
    except BadRequest as exc:
        logger.info("Update domain '%s' rejected: %s", domain, exc)
        return _error(str(exc), 400)
    except NotFound as exc:
        logger.info("Domain '%s' not found: %s", domain, exc)
        return _error(str(exc), 404)
    except RuntimeError as exc:
        logger.error("Failed to update domain '%s': %s", domain, exc)
        return _error(str(exc), 500)


@bp.route("/domains/<domain>", methods=["DELETE"])
def remove_domain_bp(domain):
    try:
        delete("/nginx/domains/remove", {"domain": domain})
        logger.info("Proxy domain removed via API: %s", domain)
        return _ok({"domain": domain})
    except NotFound as exc:
        logger.info("Domain '%s' not found: %s", domain, exc)
        return _error(str(exc), 404)
    except RuntimeError as exc:
        logger.error("Failed to remove domain '%s': %s", domain, exc)
        return _error(str(exc), 500)


@bp.route("/apply", methods=["POST"])
def apply_bp():
    try:
        post("/nginx/apply")
        logger.info("nginx config applied via API")
        return _ok(None)
    except RuntimeError as exc:
        logger.error("Failed to apply nginx config: %s", exc)
        return _error(str(exc), 500)


@bp.route("/test", methods=["POST"])
def test_bp():
    try:
        result = post("/nginx/test")
        if result.get("valid"):
            return _ok({"valid": True, "output": result.get("output", "")})
        return _error(result.get("output", "unknown error"), 400)
    except RuntimeError as exc:
        logger.error("nginx config test failed: %s", exc)
        return _error(str(exc), 500)


@bp.route("/management", methods=["POST"])
def management_bp():
    body = request.get_json(silent=True) or {}
    domain = body.get("domain", "").strip()
    if not domain:
        return _error("'domain' is required", 400)
    flask_host = body.get("flask_host", "127.0.0.1").strip() or "127.0.0.1"
    flask_port = body.get("flask_port", 9090)
    auth_user = body.get("auth_user")
    auth_pass = body.get("auth_pass")
    try:
        post(
            "/nginx/management",
            {
                "domain": domain,
                "flask_host": flask_host,
                "flask_port": int(flask_port),
                "auth_user": auth_user,
                "auth_pass": auth_pass,
            },
        )
        logger.info("Management proxy configured via API: %s", domain)
        return _ok(None)
    except BadRequest as exc:
        logger.info("Management proxy config rejected: %s", exc)
        return _error(str(exc), 400)
    except RuntimeError as exc:
        logger.error("Failed to set management proxy: %s", exc)
        return _error(str(exc), 500)