Archived
266 lines
8.7 KiB
Python
266 lines
8.7 KiB
Python
from collections.abc import Mapping, Sequence
|
|
|
|
from pydantic import BaseModel, Field
|
|
|
|
from .services.ddns import DdnsService
|
|
|
|
|
|
class ErrorResponse(BaseModel):
|
|
detail: str = Field(examples=["not found"])
|
|
|
|
|
|
class HostnameCreateResponse(BaseModel):
|
|
hostname: str
|
|
status: str = Field(description="Lifecycle state. Newly generated hostnames start as pending until registered.")
|
|
update_url: str = Field(description="Secret update URL for router DynDNS updates.")
|
|
dashboard_url: str = Field(description="Secret dashboard URL for reading, rotating, or deleting this hostname.")
|
|
registration_url: str = Field(
|
|
description="Secret URL used to register the pending hostname after secrets are saved."
|
|
)
|
|
|
|
|
|
class HostnameStatusResponse(BaseModel):
|
|
hostname: str
|
|
status: str
|
|
update_url: str = Field(description="Secret update URL for router DynDNS updates.")
|
|
dashboard_url: str = Field(description="Secret dashboard URL for reading, rotating, or deleting this hostname.")
|
|
ipv4: str | None = None
|
|
ipv6: str | None = None
|
|
updated_at: str | None = None
|
|
history: list["HostnameUpdateEvent"] = Field(default_factory=list)
|
|
|
|
|
|
class HostnameRotateUpdateResponse(BaseModel):
|
|
hostname: str
|
|
status: str
|
|
update_url: str = Field(description="Secret replacement update URL for router DynDNS updates.")
|
|
dashboard_url: str = Field(description="Secret dashboard URL for reading, rotating, or deleting this hostname.")
|
|
|
|
|
|
class HostnameUpdateEvent(BaseModel):
|
|
hostname: str
|
|
ipv4: str | None = None
|
|
ipv6: str | None = None
|
|
status: str
|
|
detail: str
|
|
created_at: str
|
|
count: int = 1
|
|
|
|
|
|
class AdminHostname(BaseModel):
|
|
hostname: str
|
|
status: str
|
|
ipv4: str | None = None
|
|
ipv6: str | None = None
|
|
updated_at: str | None = None
|
|
created_at: str | None = None
|
|
accepted_at: str | None = None
|
|
disabled: bool = False
|
|
|
|
|
|
class AdminRecord(BaseModel):
|
|
hostname: str
|
|
ipv4: str | None = None
|
|
ipv6: str | None = None
|
|
updated_at: str
|
|
|
|
|
|
class AdminUpdateEvent(BaseModel):
|
|
hostname: str
|
|
ipv4: str | None = None
|
|
ipv6: str | None = None
|
|
status: str
|
|
detail: str
|
|
source_ip: str
|
|
created_at: str
|
|
count: int = 1
|
|
|
|
|
|
class AdminCleanupRun(BaseModel):
|
|
created_at: str
|
|
unused_accounts_deleted: int
|
|
|
|
|
|
class AdminScheduledTask(BaseModel):
|
|
name: str
|
|
interval_seconds: int
|
|
next_run_at: str
|
|
lease_owner: str | None = None
|
|
lease_expires_at: str | None = None
|
|
last_started_at: str | None = None
|
|
last_finished_at: str | None = None
|
|
last_status: str
|
|
last_error: str
|
|
updated_at: str
|
|
|
|
|
|
class AdminMetrics(BaseModel):
|
|
values: dict[str, float]
|
|
average_update_latency_ms: float
|
|
|
|
|
|
class AdminTotals(BaseModel):
|
|
hostnames: int
|
|
records: int
|
|
update_events: int
|
|
cleanup_runs: int
|
|
|
|
|
|
class AdminDashboardResponse(BaseModel):
|
|
totals: AdminTotals
|
|
metrics: AdminMetrics
|
|
hostnames: list[AdminHostname]
|
|
update_events: list[AdminUpdateEvent]
|
|
cleanup_runs: list[AdminCleanupRun]
|
|
scheduled_tasks: list[AdminScheduledTask]
|
|
limit: int
|
|
|
|
|
|
class AdminHostnamesResponse(BaseModel):
|
|
items: list[AdminHostname]
|
|
limit: int
|
|
offset: int
|
|
total: int
|
|
|
|
|
|
class AdminRecordsResponse(BaseModel):
|
|
items: list[AdminRecord]
|
|
limit: int
|
|
offset: int
|
|
total: int
|
|
|
|
|
|
class AdminEventsResponse(BaseModel):
|
|
items: list[AdminUpdateEvent]
|
|
limit: int
|
|
offset: int
|
|
next_before: str | None = None
|
|
total: int
|
|
|
|
|
|
def _create_response(service: DdnsService, account: Mapping[str, object]) -> HostnameCreateResponse:
|
|
return HostnameCreateResponse(
|
|
hostname=str(account["hostname"]),
|
|
status="active" if account.get("accepted_at") else "pending",
|
|
update_url=service.fritz_update_url(account),
|
|
dashboard_url=service.dashboard_url(account),
|
|
registration_url=service.registration_url(account),
|
|
)
|
|
|
|
|
|
def _hostname_status(
|
|
service: DdnsService,
|
|
account: Mapping[str, object],
|
|
history: Sequence[Mapping[str, object]] | None = None,
|
|
) -> HostnameStatusResponse:
|
|
account_for_url = {"update_slug": str(account["update_slug"])}
|
|
account_for_dashboard = {"management_slug": str(account.get("management_slug", ""))}
|
|
return HostnameStatusResponse(
|
|
hostname=str(account["hostname"]),
|
|
status="active" if account.get("accepted_at") else "pending",
|
|
update_url=service.fritz_update_url(account_for_url),
|
|
dashboard_url=service.dashboard_url(account_for_dashboard) if account_for_dashboard["management_slug"] else "",
|
|
ipv4=str(account["ipv4"]) if account.get("ipv4") else None,
|
|
ipv6=str(account["ipv6"]) if account.get("ipv6") else None,
|
|
updated_at=str(account["updated_at"]) if account.get("updated_at") else None,
|
|
history=[_hostname_update_event(event) for event in history or []],
|
|
)
|
|
|
|
|
|
def _hostname_rotate_update_response(
|
|
service: DdnsService, account: Mapping[str, object], dashboard_secret: str
|
|
) -> HostnameRotateUpdateResponse:
|
|
return HostnameRotateUpdateResponse(
|
|
hostname=str(account["hostname"]),
|
|
status="active" if account.get("accepted_at") else "pending",
|
|
update_url=service.fritz_update_url({"update_slug": str(account["update_slug"])}),
|
|
dashboard_url=service.dashboard_url({"management_slug": dashboard_secret}),
|
|
)
|
|
|
|
|
|
def _hostname_update_event(row: Mapping[str, object]) -> HostnameUpdateEvent:
|
|
return HostnameUpdateEvent(
|
|
hostname=str(row["hostname"]),
|
|
ipv4=str(row["ipv4"]) if row.get("ipv4") else None,
|
|
ipv6=str(row["ipv6"]) if row.get("ipv6") else None,
|
|
status=str(row["status"]),
|
|
detail=str(row["detail"]),
|
|
created_at=str(row["created_at"]),
|
|
count=_int_value(row.get("count"), 1),
|
|
)
|
|
|
|
|
|
def _admin_hostname(account: Mapping[str, object]) -> AdminHostname:
|
|
return AdminHostname(
|
|
hostname=str(account["hostname"]),
|
|
status="disabled" if account.get("disabled") else ("active" if account.get("accepted_at") else "pending"),
|
|
ipv4=str(account["ipv4"]) if account.get("ipv4") else None,
|
|
ipv6=str(account["ipv6"]) if account.get("ipv6") else None,
|
|
updated_at=str(account["updated_at"]) if account.get("updated_at") else None,
|
|
created_at=str(account["created_at"]) if account.get("created_at") else None,
|
|
accepted_at=str(account["accepted_at"]) if account.get("accepted_at") else None,
|
|
disabled=bool(account.get("disabled")),
|
|
)
|
|
|
|
|
|
def _admin_metrics(metrics: dict[str, float]) -> AdminMetrics:
|
|
samples = metrics.get("update_latency_samples_total", 0)
|
|
average_latency = metrics.get("update_latency_ms_total", 0) / samples if samples else 0
|
|
return AdminMetrics(values=metrics, average_update_latency_ms=average_latency)
|
|
|
|
|
|
def _admin_record(row: Mapping[str, object]) -> AdminRecord:
|
|
return AdminRecord(
|
|
hostname=str(row["hostname"]),
|
|
ipv4=str(row["ipv4"]) if row.get("ipv4") else None,
|
|
ipv6=str(row["ipv6"]) if row.get("ipv6") else None,
|
|
updated_at=str(row["updated_at"]),
|
|
)
|
|
|
|
|
|
def _admin_update_event(row: Mapping[str, object]) -> AdminUpdateEvent:
|
|
return AdminUpdateEvent(
|
|
hostname=str(row["hostname"]),
|
|
ipv4=str(row["ipv4"]) if row.get("ipv4") else None,
|
|
ipv6=str(row["ipv6"]) if row.get("ipv6") else None,
|
|
status=str(row["status"]),
|
|
detail=str(row["detail"]),
|
|
source_ip=str(row["source_ip"]),
|
|
created_at=str(row["created_at"]),
|
|
count=_int_value(row.get("count"), 1),
|
|
)
|
|
|
|
|
|
def _admin_cleanup_run(row: Mapping[str, object]) -> AdminCleanupRun:
|
|
return AdminCleanupRun(
|
|
created_at=str(row["created_at"]),
|
|
unused_accounts_deleted=_int_value(row["unused_accounts_deleted"], 0),
|
|
)
|
|
|
|
|
|
def _admin_scheduled_task(row: Mapping[str, object]) -> AdminScheduledTask:
|
|
return AdminScheduledTask(
|
|
name=str(row["name"]),
|
|
interval_seconds=_int_value(row["interval_seconds"], 0),
|
|
next_run_at=str(row["next_run_at"]),
|
|
lease_owner=str(row["lease_owner"]) if row.get("lease_owner") else None,
|
|
lease_expires_at=str(row["lease_expires_at"]) if row.get("lease_expires_at") else None,
|
|
last_started_at=str(row["last_started_at"]) if row.get("last_started_at") else None,
|
|
last_finished_at=str(row["last_finished_at"]) if row.get("last_finished_at") else None,
|
|
last_status=str(row["last_status"]),
|
|
last_error=str(row["last_error"]),
|
|
updated_at=str(row["updated_at"]),
|
|
)
|
|
|
|
|
|
def _int_value(value: object, default: int) -> int:
|
|
if value is None:
|
|
return default
|
|
if isinstance(value, int):
|
|
return value
|
|
if isinstance(value, float):
|
|
return int(value)
|
|
if isinstance(value, str):
|
|
return int(value)
|
|
return default
|