Build KarlDNS self-hosted DynDNS service

router_dyndns/routers/api.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import sqlite3
+
+from fastapi import APIRouter, HTTPException, Request, Response, status
+from starlette.concurrency import run_in_threadpool
+
+from ..ddns_dns import DnsProviderError
+from ..ddns_service import BadIpError, normalize_domain
+from ..dependencies import ServiceDep, StoreDep
+from ..schemas import (
+    CustomHostnameRequest,
+    DomainChallengeRequest,
+    DomainChallengeResponse,
+    ErrorResponse,
+    HostnameCredentials,
+    MagicHostnameRequest,
+    ManagedRecord,
+    RouterUpdateResponse,
+    VerifyDomainRequest,
+    VerifyDomainResponse,
+    _credentials_response,
+    _managed_record,
+)
+
+router = APIRouter(prefix="/api/v1")
+
+
+@router.post(
+    "/hostnames/magic",
+    response_model=HostnameCredentials,
+    status_code=status.HTTP_201_CREATED,
+    summary="Generate a provider-owned DynDNS hostname",
+    tags=["hostnames"],
+    responses={500: {"model": ErrorResponse}},
+)
+async def create_magic_hostname(payload: MagicHostnameRequest, service: ServiceDep) -> HostnameCredentials:
+    account = await run_in_threadpool(service.create_managed_account, payload.username)
+    return _credentials_response(service, account)
+
+
+@router.get(
+    "/management/{management_slug}",
+    response_model=ManagedRecord,
+    summary="Read a hostname by magic management link",
+    description="Uses the secret bearer management slug. Dashboard passwords protect only the web dashboard and are not required for this JSON API route.",
+    tags=["management"],
+    responses={404: {"model": ErrorResponse}},
+)
+async def read_managed_hostname(management_slug: str, store: StoreDep, service: ServiceDep) -> ManagedRecord:
+    account = await run_in_threadpool(store.get_account_by_management_slug, management_slug)
+    if not account or account["disabled"]:
+        raise HTTPException(status_code=404, detail="not found")
+    return _managed_record(service, account)
+
+
+@router.delete(
+    "/management/{management_slug}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Delete a hostname by magic management link",
+    description="Uses the secret bearer management slug. Dashboard passwords protect only the web dashboard and are not required for this JSON API route.",
+    tags=["management"],
+    responses={404: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
+)
+async def delete_managed_hostname(management_slug: str, store: StoreDep, service: ServiceDep) -> Response:
+    account = await run_in_threadpool(store.get_account_by_management_slug, management_slug)
+    if not account or account["disabled"]:
+        raise HTTPException(status_code=404, detail="not found")
+    hostname = str(account["hostname"])
+    try:
+        await run_in_threadpool(service.delete_account, hostname, "api")
+    except DnsProviderError as exc:
+        raise HTTPException(status_code=500, detail="DNS delete failed; hostname was not deleted") from exc
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.post(
+    "/domains/challenges",
+    response_model=DomainChallengeResponse,
+    status_code=status.HTTP_201_CREATED,
+    summary="Create a DNS TXT domain verification challenge",
+    tags=["domains"],
+    responses={400: {"model": ErrorResponse}},
+)
+async def create_domain_challenge(payload: DomainChallengeRequest, service: ServiceDep) -> DomainChallengeResponse:
+    domain = normalize_domain(payload.domain)
+    try:
+        challenge = await run_in_threadpool(service.create_domain_challenge, domain)
+    except sqlite3.IntegrityError as exc:
+        raise HTTPException(status_code=409, detail="domain is already verified") from exc
+    return DomainChallengeResponse(
+        domain=domain,
+        txt_name=service.verification_name(domain),
+        txt_value=challenge["token"],
+        claim_secret=challenge["claim_secret"],
+    )
+
+
+@router.post(
+    "/domains/verify",
+    response_model=VerifyDomainResponse,
+    summary="Verify a domain TXT challenge",
+    tags=["domains"],
+    responses={404: {"model": ErrorResponse}},
+)
+async def verify_domain(payload: VerifyDomainRequest, service: ServiceDep) -> VerifyDomainResponse:
+    domain = normalize_domain(payload.domain)
+    found, _challenge = await run_in_threadpool(service.verify_domain, domain, payload.claim_secret)
+    if not found:
+        return VerifyDomainResponse(
+            domain=domain,
+            verified=False,
+            message="TXT record not found yet",
+            claim_secret=payload.claim_secret,
+        )
+    return VerifyDomainResponse(
+        domain=domain,
+        verified=True,
+        message="domain verified",
+        claim_secret=payload.claim_secret,
+    )
+
+
+@router.post(
+    "/hostnames/custom",
+    response_model=HostnameCredentials,
+    status_code=status.HTTP_201_CREATED,
+    summary="Generate credentials for a verified custom hostname",
+    tags=["hostnames"],
+    responses={400: {"model": ErrorResponse}, 403: {"model": ErrorResponse}, 409: {"model": ErrorResponse}},
+)
+async def create_custom_hostname(payload: CustomHostnameRequest, service: ServiceDep) -> HostnameCredentials:
+    account = await run_in_threadpool(
+        service.create_custom_account,
+        payload.hostname,
+        payload.claim_secret,
+        payload.username,
+    )
+    return _credentials_response(service, account)
+
+
+@router.get(
+    "/updates/{update_slug}",
+    response_model=RouterUpdateResponse,
+    summary="Router-compatible update endpoint",
+    tags=["updates"],
+    responses={404: {"model": ErrorResponse}, 500: {"model": ErrorResponse}},
+)
+async def update_hostname(
+    update_slug: str,
+    request: Request,
+    store: StoreDep,
+    service: ServiceDep,
+    myip: str | None = None,
+    ipaddr: str | None = None,
+    myipv6: str | None = None,
+    ip6addr: str | None = None,
+) -> RouterUpdateResponse:
+    account = await run_in_threadpool(store.get_account_by_slug, update_slug)
+    if not account or account["disabled"]:
+        raise HTTPException(status_code=404, detail="not found")
+
+    hostname = str(account["hostname"])
+    try:
+        outcome = await run_in_threadpool(
+            service.apply_update,
+            request,
+            hostname,
+            myip,
+            ipaddr,
+            myipv6,
+            ip6addr,
+        )
+    except BadIpError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    except DnsProviderError as exc:
+        raise HTTPException(status_code=500, detail="DNS publish failed") from exc
+    result = outcome.result
+    return RouterUpdateResponse(status="good" if result.changed else "nochg", hostname=hostname, ip=result.ipv4 or result.ipv6 or "")